serial -- 직렬화 (JSON / XML / HTML / CSV / YAML / Markdown / Protobuf) #

#include <std/serial/value.h>
#include <std/serial/json.h>
#include <std/serial/xml.h>
#include <std/serial/html.h>

#define VAL_NULL   0
#define VAL_BOOL   1
#define VAL_INT    2
#define VAL_FLOAT  3
#define VAL_STRING 4
#define VAL_ARRAY  5
#define VAL_OBJECT 6

struct Value {
    int kind;   // one of the VAL_* constants above

    // Construction.
    static struct Value null();
    static struct Value from_bool(int v);
    static struct Value from_int(long long v);
    static struct Value from_float(double v);
    static struct Value from_str(const &char s);   // copies s
    static struct Value array();                   // empty; grow with v.array_push
    static struct Value object();                  // empty; grow with v.object_set

    int kind_of() const;
    int is_null() const;
    int as_bool() const;
    long long as_int() const;
    double as_float() const;
    const &char as_string() const;

    // Array/Object element access -- read-only views (the returned
    // reference aliases storage owned by this Value, don't free it
    // separately). 'array_at' trusts 'idx' is in range (see array_len());
    // 'object_get' is the one nullable lookup -- no entry for 'key' is a
    // real, expected outcome, not a caller error.
    unsigned long   array_len() const;
    &Value          array_at(unsigned long idx) const;
    unsigned long   object_len() const;
    ?&Value         object_get(const &char key) const;   // empty (null) if the key isn't present
    const &char     object_key_at(unsigned long idx) const;   // idx번째 항목, 삽입 순서
    &Value          object_value_at(unsigned long idx) const;

    // Building and lifetime.
    void            array_push(struct Value v);                    // takes ownership of v
    void            object_set(const &char key, struct Value v);   // takes ownership of v
    struct Value    clone() const;                                 // deep copy
    void            free() consume;                                // releases the whole tree

    // Text formats (any Format, see below).
    generic<F: Format> struct String encode(F f) const;                                  // a fresh String
    generic<F: Format> static struct Value decode(F f, const &char text, ?&int ok);    // *ok: 1, or 0
}

long long age = 0;
match (parsed.object_get("age")) {
    case null:    break;
    case some(a): age = a.as_int();
}

for (unsigned long i = 0UL; i < cfg.object_len(); i = i + 1UL) {
    std::print(cfg.object_key_at(i));
    std::print(" = ");
    std::println(cfg.object_value_at(i).as_string());
}

#include <std/serial/value.h>
#include <std/serial/json.h>
#include <std/collections/string.h>
extern int printf(const char* fmt, ...);

struct Point { double x; double y; struct Value to_value() const; };

struct Value Point::to_value() const {
    struct Value v = Value::object();
    v.object_set("x", Value::from_float(self.x));
    v.object_set("y", Value::from_float(self.y));
    return v;
}

int main() {
    struct Point p; p.x = 1.5; p.y = 2.5;

    struct Value pv = p.to_value();
    struct String json = value_to_json(&pv);
    unsafe { printf("%s\n", json.as_ptr()); }   // {"x":1.5,"y":2.5}

    json.free();
    pv.free();
    return 0;
}

trait Format {
    void         write(const &Value v, &String out) const;   // appends v's text to out
    struct Value parse(const &char text, ?&int ok) const;    // *ok: 1, or 0 on malformed input
}

#include <std/serial/value.h>
#include <std/serial/json.h>
#include <std/serial/yaml.h>
#include <std/serial/xml.h>
#include <std/io.h>

// Written once, works for every format: encode, then decode the text back.
generic<F: Format>
long long round_trip_age(F f, const &Value v) {
    struct String text = v.encode(f);
    int ok = 0;
    struct Value back = std::Value::decode(f, text.as_ptr(), &ok);
    long long age = -1LL;
    match (back.object_get("age")) {
        case some(a): age = a.as_int();
        case null:    { }
    }
    back.free();
    text.free();
    return ok ? age : -1LL;
}

int main() {
    struct Value v = std::Value::object();
    v.object_set("name", std::Value::from_str("Ada"));
    v.object_set("age", std::Value::from_int(36LL));

    struct String json = v.encode(std::Json::new());
    std::println(json.as_ptr());                               // {"name":"Ada","age":36}

    long long a1 = round_trip_age(std::Json::new(), &v);
    long long a2 = round_trip_age(std::Yaml::new(), &v);
    long long a3 = round_trip_age(std::Xml::new("person"), &v);

    json.free();
    v.free();
    return a1 == 36LL && a2 == 36LL && a3 == 36LL ? 0 : 1;
}

void json_write(const &Value v, &String out);   // 추가만 함; 'out'을 먼저 비우지 않음
struct String value_to_json(const &Value v);      // 편의 함수: 새 String 반환

struct Value json_parse(const &char text, ?&int ok);
    // 성공하면 *ok = 1과 파싱된 트리; 실패하면 *ok = 0과 Value::null().
    // 첫 완전한 값 이후의 후행 내용은 무시됩니다.

struct Value v = Value::object();
v.object_set("name", Value::from_str("Ada"));
v.object_set("age", Value::from_int(36));

struct String json = value_to_json(&v);
printf("%s\n", json.as_ptr());   // {"name":"Ada","age":36}

int ok = 0;
struct Value parsed = json_parse(json.as_ptr(), &ok);
long long age = 0;
match (parsed.object_get("age")) {
    case null:    break;
    case some(a): age = a.as_int();   // 36
}

json.free();
v.free();
parsed.free();

void xml_write(const &Value v, const &char tag, &String out);
struct String value_to_xml(const &Value v, const &char root_tag);

struct Value xml_parse(const &char text, ?&int ok);   // 루트 태그 자체는 반환되지 않고, 그 내용만 반환됨

struct Value v = Value::object();
v.object_set("name", Value::from_str("Ada <Countess>"));
v.object_set("age", Value::from_int(36));

struct String xml = value_to_xml(&v, "person");
printf("%s\n", xml.as_ptr());
// <person><name>Ada &lt;Countess&gt;</name><age>36</age></person>

int ok = 0;
struct Value parsed = xml_parse(xml.as_ptr(), &ok);
// parsed.object_get("age")를 위 JSON 예제와 같은 방식으로 언래핑

xml.free();
v.free();
parsed.free();

void html_escape(&String out, const &char s);   // 단독 사용 가능, Value 렌더러와 무관
void html_unescape(&String out, const &char s);   // < ' — — ... -> UTF-8 텍스트
void html_strip_tags(&String out, const &char s); // HTML 조각의 텍스트 내용
void html_write(const &Value v, &String out);
struct String value_to_html(const &Value v);

struct Value html_parse(const &char text, ?&int ok);

struct Value v = Value::object();
v.object_set("comment", Value::from_str("<script>alert(1)</script>"));

struct String html = value_to_html(&v);
printf("%s\n", html.as_ptr());
// <dl><dt>comment</dt><dd>&lt;script&gt;alert(1)&lt;/script&gt;</dd></dl>

html.free();
v.free();

struct String tags = String::new();
html_strip_tags(&tags, "<h2>Title</h2><p>Fish &amp; chips</p>");
struct String text = String::new();
html_unescape(&text, tags.as_ptr());     // "Title Fish & chips"

#include <std/serial/csv.h>

void csv_write(const &Value v, &String out);   // 'v'는 반드시 VAL_ARRAY의 VAL_ARRAY여야 함
struct String value_to_csv(const &Value v);

struct Value csv_parse(const &char text, ?&int ok);

int ok = 0;
struct Value rows = csv_parse("name,age\nAda,36\n", &ok);
&Value row0 = rows.array_at(0);
&Value name = row0.array_at(0);   // VAL_STRING "name"
printf("%s\n", name.as_string());

rows.free();

#include <std/serial/yaml.h>

void yaml_write(const &Value v, &String out);
struct String value_to_yaml(const &Value v);

struct Value yaml_parse(const &char text, ?&int ok);
    // 구조적 오류(들여쓰기 불일치, 종료되지 않은 따옴표 스칼라, 시퀀스/매핑
    // 항목도 아니고 맨 스칼라가 기대되는 위치의 맨 스칼라도 아닌 줄)가
    // 있으면 *ok = 0 -- 반환값은 오류 전까지 파싱된 내용입니다.

struct Value v = Value::object();
v.object_set("name", Value::from_str("Ada"));
v.object_set("age", Value::from_int(36));

struct String yaml = value_to_yaml(&v);
printf("%s", yaml.as_ptr());
// name: Ada
// age: 36

yaml.free();
v.free();

int ok = 0;
struct Value fm = yaml_parse(
    "outline: [2, 4]\n"
    "hero: {name: SafeC, actions: [start, docs]}\n"
    "summary: >\n"
    "  Folded lines become\n"
    "  one paragraph.\n"
    "code: |\n"
    "  int x;\n"
    "  int y;\n", &ok);
// outline -> [2, 4] (VAL_INT의 VAL_ARRAY)
// summary -> "Folded lines become one paragraph.\n"
// code    -> "int x;\nint y;\n"
fm.free();

#include <std/serial/markdown.h>

#define MD_DOC             0
#define MD_HEADING         1  // level 1-6; id (heading_ids)
#define MD_PARAGRAPH       2
#define MD_LIST            3  // ordered, start, tight
#define MD_LIST_ITEM       4
#define MD_CODE_BLOCK      5  // text = code, info = info string ("c", "bash")
#define MD_BLOCKQUOTE      6
#define MD_HR              7
#define MD_TEXT            8  // inline text in 'text' (references decoded)
#define MD_BOLD            9
#define MD_ITALIC          10
#define MD_CODE_SPAN       11 // inline code in 'text'
#define MD_LINK            12 // children = link text; text = URL; title
#define MD_TABLE           13 // rows; the first, 'header' row is the thead
#define MD_TABLE_ROW       14
#define MD_TABLE_CELL      15 // inline children; align = MD_ALIGN_*
#define MD_CONTAINER       16 // info = kind; first child MD_CONTAINER_TITLE when titled
#define MD_HTML_BLOCK      17 // raw HTML in 'text'
#define MD_HTML_INLINE     18
#define MD_IMAGE           19 // children = alt text; text = src; title
#define MD_STRIKE          20
#define MD_BREAK           21 // hard line break
#define MD_CONTAINER_TITLE 22

struct MdOptions {
    int tables, html, containers, heading_ids, strikethrough, autolinks;
    static struct MdOptions commonmark();   // all off (what parse() uses)
    static struct MdOptions gfm();          // tables, strikethrough, autolinks
};

struct MdNode {
    int kind;
    int level;      // MD_HEADING
    int ordered;    // MD_LIST
    int start;      // MD_LIST: first number of an ordered list
    int tight;      // MD_LIST: no blank lines between items/blocks (no <p> in items)
    int align;      // MD_TABLE_CELL: MD_ALIGN_NONE/LEFT/CENTER/RIGHT
    int header;     // MD_TABLE_ROW/CELL: in the header row
    struct String text, info, id, title;
    struct Vec<&heap MdNode> children;

    static &heap MdNode parse(const &char text);                                // CommonMark
    static &heap MdNode parse_opts(const &char text, const &MdOptions opts);   // with extensions

    struct String render_html() const;       // text escaped; raw HTML only with the html option
    struct String render_markdown() const;   // round-trips: parse(render_markdown()) renders the same
    void          plain_text(&String out) const;   // text content, no markup
    void          free() consume;            // frees the subtree and the node itself
};

void md_slugify(const &char text, &String out);   // "2. Temporal Safety" -> "_2-temporal-safety"

generic<C>
struct String md_render_html_with(const &MdNode node,
                                  fn int(?&C, const &MdNode, int, &String) hook, ?&C ctx);

#include <std/serial/markdown.h>
#include <std/io.h>

int main() {
    &heap MdNode doc = std::MdNode::parse("# Title\n\nSome **bold** text.\n");
    struct String html = doc.render_html();
    std::println(html.as_ptr());   // <h1>Title</h1>\n<p>Some <strong>bold</strong> text.</p>
    html.free();
    doc.free();
    return 0;
}

struct Site { const char* base; };

int site_hook(?&Site site, const &MdNode n, int entering, &String out) {
    if (n.kind == MD_LINK && entering) {          // prefix every absolute link
        out.push("<a href=\"");
        match (site) { case some(s): { unsafe { out.push(s.base); } } case null: { } }
        html_escape(out, n.text.as_ptr());
        out.push("\">");
        return 2;                                 // children + default </a>
    }
    if (n.kind == MD_HEADING && !entering) {      // anchor before </hN>
        out.push(" <a class=\"anchor\" href=\"#");
        out.push(n.id.as_ptr());
        out.push("\">#</a></h");
        out.push_int((long long)n.level);
        out.push(">\n");
        return 1;
    }
    if (n.kind == MD_HEADING) {
        out.push("<h"); out.push_int((long long)n.level);
        out.push(" id=\""); out.push(n.id.as_ptr()); out.push("\">");
        return 2;
    }
    return 0;
}

struct MdOptions o = MdOptions::gfm();
o.heading_ids = 1;
&heap MdNode doc = MdNode::parse_opts(text, &o);
struct Site site;
site.base = "/docs";
struct String html;
unsafe { html = md_render_html_with(doc, site_hook, (?&Site)&site); }

#include <std/serial/protobuf.h>

#define PB_WIRE_VARINT  0   // int32/int64/uint32/uint64/sint32/sint64/bool/enum
#define PB_WIRE_FIXED64 1   // fixed64/sfixed64/double
#define PB_WIRE_LEN     2   // string/bytes/embedded messages/packed repeated
#define PB_WIRE_FIXED32 5   // fixed32/sfixed32/float
// Group wire types 3/4 are not supported (proto3 never emits them).

// Writer: each *_field call appends its own tag, then the value.
void pb_write_varint(&String out, unsigned long long v);
void pb_write_tag(&String out, int field_num, int wire_type);
void pb_write_int64_field(&String out, int field_num, long long v);   // negative values take 10 bytes, like protoc
void pb_write_uint64_field(&String out, int field_num, unsigned long long v);
void pb_write_sint64_field(&String out, int field_num, long long v);  // zigzag
void pb_write_bool_field(&String out, int field_num, int v);
void pb_write_double_field(&String out, int field_num, double v);
void pb_write_float_field(&String out, int field_num, float v);
void pb_write_string_field(&String out, int field_num, const &char s);
void pb_write_bytes_field(&String out, int field_num, []const unsigned char data); // also nested messages

// Reader: a zero-copy cursor over an existing buffer.
struct PbReader {
    const &unsigned char data;
    unsigned long        len;
    unsigned long        pos;

    static struct PbReader new([]const unsigned char data);   // at data[0]

    int has_more() const;

    // Each returns 1 on success, 0 on truncated or malformed input.
    int read_varint(&unsigned long long out);
    int read_tag(&int field_num, &int wire_type);
    int read_int64(&long long out);
    int read_uint64(&unsigned long long out);
    int read_sint64(&long long out);
    int read_bool(&int out);
    int read_double(&double out);
    int read_float(&float out);
    // A slice of the reader's own buffer (zero-copy) — copy it if it must outlive
    // that buffer. null on a truncated encoding.
    ?[]const unsigned char read_length_delimited();
    int skip_field(int wire_type);   // skip an unknown field (forward compatibility)
};

#include <std/serial/protobuf.h>

// .proto: message Point { int32 x = 1; int32 y = 2; }
struct Point { int x; int y; };

int main() {
    struct String buf = std::String::new();
    std::pb_write_int64_field(&buf, 1, 3LL);
    std::pb_write_int64_field(&buf, 2, -4LL);

    struct Point p;
    p.x = 0; p.y = 0;
    struct PbReader r;
    r = std::PbReader::new(buf.as_bytes());   // []const char is a byte slice
    while (r.has_more()) {
        int field = 0; int wire = 0;
        if (!r.read_tag(&field, &wire)) break;
        long long v = 0LL;
        if (wire == PB_WIRE_VARINT && r.read_int64(&v)) {
            if (field == 1) p.x = (int)v;
            if (field == 2) p.y = (int)v;
        } else if (!r.skip_field(wire)) break;
    }
    buf.free();
    return (p.x == 3 && p.y == -4) ? 0 : 1;
}