C 对象 -> YAML

前言

用 C 语言写程序，现在依然能创造一切，但一切都已经存在了，你无需去创造。刀枪入库，马放南山吧。

不过，如果你还对过去的田园和疆场有所怀恋，无聊的时候，还是可以写写 C 程序。这时，你不是老板，不是员工，甚至也不是学生，而是假期里的一个少年，骑着单车四处游荡。这种心态，很适合写 C 程序。早期的程序员，就是这样写 C 程序的，于是就有了最早的 Unix，后来又有了最早的 Linux。

第一个开始抱怨 C 缺这少那的人，他就不再是少年，也没有假期了，所有对 C 的抱怨，皆因如此。没有人抱怨乐高积木会耽误他们盖摩天大楼，也没有人抱怨自行车会拖慢人类的前进速度，任何对 C 有所抱怨的人，实际上是抱怨自己，没有假期，不再是少年，家里的自行车已被灰尘掩盖。

有个叫朱志文的男人，骑着单车，遍历了整个地球，一大把年纪了，现在依然如此。他实际上挺适合写 C 程序的，而对 C 骂骂咧咧的人，大都以为随便就能买张高铁票就能到自己想去的地方，然而很有可能，他们连自家附近的小山都没爬过。

本文会带着你爬一座叫作 libyaml 的 C 小山，或小 C 山。你要有假期，你要是少年，你要去做一些看上去没用的事。

准备

写 C 程序，最好用 Linux 环境。Windows 和 macOS 早就不是少年，也没假期了。

由于 Ubuntu 用户众多，我用的是它的一个衍生版，Linux Mint。以前我是用 Gentoo 的，可能过段时间我会用回来，像个有假期的少年……由于 Ubuntu 用户众多，安装一个可以爬的 libyaml，只需用以下命令：

$ sudo apt install libyaml-dev

libyaml-dev 包安装完毕后，可用过以下程序验证 libyaml 库是否可用。

/* foo.c */
#include 
#include 
int main() {
    printf("libyaml version: %s\n", yaml_get_version_string());
    return 0;
}

假设上述代码保存于 foo.c 文件，使用以下命令编译它，并运行所得程序，结果应该输出 libyaml 的版本号。

$ gcc foo.c -o foo -lyaml
$ ./foo
libyaml version: 0.2.5

还需要做的准备是，你需要懂一些 YAML，因为我们要做的事情是，将一些 C 数据对象输出为 YAML 格式。如果你不懂 YAML，可从「YAML 小传」了解一二。

空流

假设我要向一个名为 foo.yaml 的文件写入一些 YAML 格式的数据，那么首先我应该以写模式打开或创建这个文件：

FILE *yaml_file = fopen("foo.yaml", "w");
if (!yaml_file) {
    fprintf(stderr, "failed to open foo.yaml");
    exit(EXIT_FAILURE);
}

如果每次打开文件都要写这样的代码，可以表现出自己非常严谨，直到有一天，你厌倦了这种严谨，就干脆定义一个宏吧。

#define YAH_OPEN_FILE(file, name, mode) do { \
    file = fopen(name, mode); \
    if (!file) { \
        fprintf(stderr, "failed to open %s", name); \
        exit(EXIT_FAILURE); \
    } \
} while (0)

宏的前缀 YAH 表示 youth and holidays. 现在，以写模式打开或创建 yaml_file 的过程可写为

FILE *yaml_file;
YAH_OPEN_FILE(yaml_file, "foo.yaml", "w");

以上为爬山前的热身运动。现在开始着手将什么也没有写入 foo.yaml 文件。什么也没有，就是空。

libyaml 为 C 数据对象所实现的 YAML 格式输出机制，采用了事件模型。无论你要输出什么，都需要准备一个事件，然后发送。发送给谁呢？发送给一个状态机，类型为 yaml_emitter_t，发送事件之前，需要几行代码初始化这个状态机。

yaml_emitter_t emitter;
if (!yaml_emitter_initialize(&emitter)) {
    fprintf(stderr, "failed to initialize yaml emitter!\n");
    exit(EXIT_FAILURE);
}

接下来，将 emitter 与 yaml_file 关联起来，即

yaml_emitter_set_output_file(&emitter, yaml_file);

我们也为上述代码做一下封装，但这次是用宏。

#define YAH_YAML_EMITTER_INIT(emitter, file) do { \
    if (!yaml_emitter_initialize(emitter)) { \
        fprintf(stderr, "failed to initialize yaml emitter!\n"); \
        exit(EXIT_FAILURE); \
    } \
    yaml_emitter_set_output_file(&emitter, file); \
} while (0)

于是 yaml_emitter_t 状态机定义及其初始化过程可写为

yaml_emitter_t emitter;
YAH_YAML_EMITTER_INIT(&emitter, yaml_file);

要向状态机 emitter 发送事件，前提是我们需要定义一个事件：

yaml_event_t event;

若向 emitter 发送事件，需要结合我们的期望，构造事件，然后发送。例如，我们期望向 foo.yaml 文件写入 YAML 流的开始——当然实际上什么也不会写入，只需

if (!yaml_stream_start_event_initialize(&event, YAML_UTF8_ENCODING)) {
    fprintf(stderr, "failed to initialize *stream_start* event.\n");
    exit(EXIT_FAILURE);
}
if (!yaml_emitter_emit(&emitter, &event)) {
    fprintf(stderr, "failed to emit %d because %s\n", event.type, emitter.problem);
    exit(EXIT_FAILURE);
}

上述代码构造的 event 是 stream_start，即流开始事件。不过，我们又遇到了严谨性代码，应该怎么处理呢，宏之！

#define YAH_YAML_EMIT(emitter, event) do { \
    if (!yaml_emitter_emit(emitter, event)) { \
        fprintf(stderr, \
                "failed to emit event %d because %s.\n", \
                (event)->type, \
                (emitter)->problem); \
        exit(EXIT_FAILURE); \
    } \
} while (0)

#define YAH_YAML_START(emitter, event, encoding) do { \
    if (!yaml_stream_start_event_initialize(event, encoding)) { \
        fprintf(stderr, "failed to initialize *stream_start* event.\n"); \
        exit(EXIT_FAILURE); \
    } \
    YAH_YAML_EMIT(emitter, event); \
} while (0)

现在，你已经是 C 语言宏定义大师了。当你在调用 YAH_YAML_EMIT 这个宏的时候，大概会有谈笑间，樯橹灰飞烟灭的感觉。这需要感谢 libyaml 作者喜欢为函数取很长的名字。

YAH_YAML_START(&emitter, &event, YAML_UTF8_ENCODING);

上述代码中的 YAML_UTF8_ENCODING 便是 YAH_YAML_EMIT 宏的可变参数。

流开始事件是包含着 YAML 文档编码信息的。YAML_UTF8_ENCODING 表示，向 YAML 文件写入的数据，其编码为 UTF-8。你也可以用其他编码，但 libyaml 提供的支持并不多，除了 UTF-8，就是 UTF-16，在这个时代，你大概不会用后者吧。如果你真的需要 UTF-16，大根端是 YAML_UTF16BE_ENCODING，小根端是 YAML_UTF16LE_ENCODING。

有始有终。只要我们构造 stream_end 事件并发送给 emitter，便意味着向 YAML 文件写入数据的过程彻底结束。

if (!yaml_stream_end_event_initialize(&event)) {
    fprintf(stderr, "failed to initialize *stream_end* event.\n");
    exit(EXIT_FAILURE);
}
if (!yaml_emitter_emit(&emitter, &event)) {
    fprintf(stderr, "failed to emit %d because %s\n", event.type, emitter.problem);
    exit(EXIT_FAILURE);
}

又遇到了严谨性代码，继续宏之。

#define YAH_YAML_END(emitter, event) do { \
    if (!yaml_stream_end_event_initialize(event)) { \
        fprintf(stderr, "failed to initialize *stream_end* event.\n"); \
        exit(EXIT_FAILURE); \
    } \
    YAH_YAML_EMIT(emitter, event); \
} while (0)

然后，stream_end 事件的构造和发送过程可简写为

YAH_YAML_END(&emitter, &event);

既然数据写入过程结束了，那么 event 和 emitter 也就没有必要存在了，虽然它们不是指针类型，但他们是结构体对象，成员变量会有一些指针，在它们初始化的时候，会被 libyaml 分配空间。此外，也应当记得关闭 yaml_file。

yaml_event_delete(&event);
yaml_emitter_delete(&emitter);
fclose(yaml_file);

现在，我们将上述过程汇总为 yah.h 和 foo.c 文件。yah-yaml.h 存放上述所有宏定义，而 foo.c 实现向 YAML 文件写入空的过程。

yah-yaml.h 文件内容如下：

#ifndef YAH_YAML_H
#define YAH_YAML_H
#include 

#define YAH_OPEN_FILE(file, name, mode) do { \
    file = fopen(name, mode); \
    if (!file) { \
        fprintf(stderr, "failed to open %s", name); \
        exit(EXIT_FAILURE); \
    } \
} while (0)


#define YAH_YAML_EMITTER_INIT(emitter, file) do { \
    if (!yaml_emitter_initialize(emitter)) { \
        fprintf(stderr, "failed to initialize yaml emitter!\n"); \
        exit(EXIT_FAILURE); \
    } \
    yaml_emitter_set_output_file(emitter, file); \
} while (0)

#define YAH_YAML_EMIT(emitter, event) do { \
    if (!yaml_emitter_emit(emitter, event)) { \
        fprintf(stderr, \
                "failed to emit event %d because %s.\n", \
                (event)->type, \
                (emitter)->problem); \
        exit(EXIT_FAILURE); \
    } \
} while (0)

#define YAH_YAML_START(emitter, event, encoding) do { \
    if (!yaml_stream_start_event_initialize(event, encoding)) { \
        fprintf(stderr, "failed to initialize *stream_start* event.\n"); \
        exit(EXIT_FAILURE); \
    } \
    YAH_YAML_EMIT(emitter, event); \
} while (0)

#define YAH_YAML_END(emitter, event) do { \
    if (!yaml_stream_end_event_initialize(event)) { \
        fprintf(stderr, "failed to initialize *stream_end* event.\n"); \
        exit(EXIT_FAILURE); \
    } \
    YAH_YAML_EMIT(emitter, event); \
} while (0)

#define YAH_YAML_DOC_START(emitter, event, name, ...) do { \
    if (!yaml_##name##_start_event_initialize(event, __VA_ARGS__)) { \
        fprintf(stderr, "failed to initialize *%s_start* event.\n", #name); \
        exit(EXIT_FAILURE); \
    } \
    YAH_YAML_EMIT(emitter, event); \
} while (0)

#define YAH_YAML_SCALAR(emitter, event, string, type) do { \
    if (!yaml_scalar_event_initialize(event, \
                                      NULL, \
                                      NULL, \
                                      string, \
                                      strlen(string), \
                                      1, \
                                      1, \
                                      type)) { \
        fprintf(stderr, "failed to initialize *scalar* event.\n"); \
        exit(EXIT_FAILURE); \
    } \
    YAH_YAML_EMIT(emitter, event); \
} while (0)

#endif

foo.c 的内容如下：

#include 

int main(void) {
    FILE *yaml_file;
    yaml_emitter_t emitter;
    yaml_event_t event;
    YAH_OPEN_FILE(yaml_file, "foo.yaml", "w");
    YAH_YAML_EMITTER_INIT(&emitter, yaml_file);
    YAH_YAML_START(&emitter, &event, YAML_UTF8_ENCODING);
    YAH_YAML_END(&emitter, &event);
    yaml_event_delete(&event);
    yaml_emitter_delete(&emitter);
    fclose(yaml_file);
    return EXIT_SUCCESS;
}

编译 foo.c 并执行所得程序，会在当前目录下生成 foo.yaml 文件，但其内容为空。在编译的时候，注意要用 -I.，不然 gcc 找不到 yah-yaml.h。

$ gcc -I. foo.c -o foo -lyaml
$ ./foo

上述代码大概 50 行，可见向 YAML 文件里写入空，并不是什么都不做，我们几乎用了 C 语言的全部知识……好在，main 函数里的代码，逻辑上基本是清晰的，感谢宏！

文档

一个 YAML 流，可包含多个文档。每个文档以 --- 开头，以 ... 结束。虽然 YAML 语言并不严格要求文档必须有起止标记，但是在用 libyaml 的时候，必须要有输出文档起止标记的过程，只是你可以控制文档起止标记显示与否。

文档开始标记的输出过程，我们现在可以直接用宏来表达，如下：

#define YAH_YAML_DOC_START(emitter, event, implicit) do { \
    if (!yaml_document_start_event_initialize(event, \
                                              NULL, \
                                              NULL, \
                                              NULL, \
                                              implicit)) { \
        fprintf(stderr, "failed to initialize *document_start* event.\n"); \
        exit(EXIT_FAILURE); \
    } \
    YAH_YAML_EMIT(emitter, event); \
} while (0)

事情开始变得复杂了起来。只是向 YAML 文件输出个开始标记而已，但是用于构造该事件的函数 yaml_document_start_event_initialize，这名字又臭又长也就罢了，参数还这么多。这个函数的声明如下：

YAML_DECLARE(int)
yaml_document_start_event_initialize(yaml_event_t *event,
                                     yaml_version_directive_t *version_directive,
                                     yaml_tag_directive_t *tag_directives_start,
                                     yaml_tag_directive_t *tag_directives_end,
                                     int implicit);

第一个参数 event 表达事件，不必多言。第二个参数用于存储要输出的 YAML 版本号，通常没必要，可设为 NULL。第三和第四个参数，用于设定输出到 YAML 文件首部的标签，通常没必要，可都设为 NULL。第五个参数，亦即最后一个，用于设定是否隐藏 YAML 文档开始标记，1 表示隐藏，0 表示显示。

YAH_YAML_DOC_START 宏假设你不需要输出 YAML 版本号，也不需要在 YAML 文件首部设置标签，故而第二至四个参数皆为 NULL，只保留文档开始标记隐藏与否的参数，交由宏调用者确定。这个宏的用法如下：

YAH_YAML_DOC_START(&emitter, &event, 1); /* 隐藏文档开始标记 */

文档结束标记的输出事件，要简单一些，如下：

#define YAH_YAML_DOC_END(emitter, event, implicit) do {      \
    if (!yaml_document_end_event_initialize(event, implicit)) { \
        fprintf(stderr, "failed to initialize *document_end* event.\n"); \
        exit(EXIT_FAILURE); \
    } \
    YAH_YAML_EMIT(emitter, event); \
} while (0)

YAH_YAML_DOC_END 的用法如下：

YAH_YAML_DOC_END(&emitter, &event, 1);

将上述宏定义放在 yah-yaml.h 中，现在它们还没有用处，因为 libyaml 不允许输出没有任何内容的 YAML 文档。

标量

YAML 语言里的标量，可对应 C 语言中的字符串常量或对象。以下代码，可将 C 字符串输出为 YAML 普通标量。

const char *hello = "Hello world!";
if (!yaml_scalar_event_initialize(&event, 
                                  NULL, /* 锚点 */
                                  NULL, /* 标签 */
                                  (const yaml_char *)hello, /* C 字符串，需强制转换为 libyaml 字符串类型 */ 
                                  strlen(hello),  /* C 字符串长度 */
                                  1, /* 为普通标量设定是否禁止标签显示，1 表示禁止，0 表示不禁止 */
                                  1, /* 为带引号的标量设定是否禁止标签显示，1 表示禁止，0 表示不禁止 */
                                  YAML_PLAIN_SCALAR_STYLE /* 普通标量风格 */)) {
    fprintf(stderr, "failed to initialize *scalar* event.\n");
    exit(EXIT_FAILURE);
}
if (!yaml_emitter_emit(&emitter, &event)) {
    fprintf(stderr,
            "failed to emit event %d because %s.\n",
            event.type,
            emitter.problem);
    exit(EXIT_FAILURE);
}

yaml_scalar_event_initialize 函数有 8 个参数，在上述代码里，我已给出了一些注释，但是如果你对 YAML 语言不熟悉，可能会觉得很烦躁。我的建议是，去他的锚点和标签……不用它。如果你愿意接受我的建议，那么我们就可以愉快地定义一个宏，收编上述代码。

#define YAH_YAML_SCALAR(emitter, event, string, style) do { \
    if (!yaml_scalar_event_initialize(event, \
                                      NULL, \
                                      NULL, \
                                      (const yaml_char *)(string), \
                                      strlen(string), \
                                      1, \
                                      1, \
                                      style)) { \
        fprintf(stderr, "failed to initialize *scalar* event.\n"); \
        exit(EXIT_FAILURE); \
    } \
    YAH_YAML_EMIT(emitter, event); \
} while (0)

现在，可以用 YAH_YAML_SCALAR 将 "Hello world!" 输出为 YAML 普通标量，如下：

YAH_YAML_SCALAR(&emitter, &event, "Hello world!", YAML_PLAIN_SCALAR_STYLE);

如果你想输出带引号的标量，例如单引号标量，只需

YAH_YAML_SCALAR(&emitter, &event, "Hello world!", YAML_SINGLE_QUOTED_SCALAR_STYLE);

对于双引号标量，只需

YAH_YAML_SCALAR(&emitter, &event, "Hello world!", YAML_DOUBLE_QUOTED_SCALAR_STYLE);

将上述宏定义放在 yah-yaml.h 中，然后将 foo.c 修改为

#include 

int main(void) {
    FILE *yaml_file;
    yaml_emitter_t emitter;
    yaml_event_t event;
    YAH_OPEN_FILE(yaml_file, "foo.yaml", "w");
    YAH_YAML_EMITTER_INIT(&emitter, yaml_file);
    YAH_YAML_START(&emitter, &event, YAML_UTF8_ENCODING);
    
    /* 输出只有一个标量的 YAML 文档 */
    YAH_YAML_DOC_START(&emitter, &event, 1);
    YAH_YAML_SCALAR(&emitter,
                    &event,
                    yah_yaml_scalar("Hello world!"),
                    YAML_PLAIN_SCALAR_STYLE);
    YAH_YAML_DOC_END(&emitter, &event, 1);

    YAH_YAML_END(&emitter, &event);
    yaml_event_delete(&event);
    yaml_emitter_delete(&emitter);
    fclose(yaml_file);
    return EXIT_SUCCESS;
}

上述程序编译并执行后， foo.yaml 文件会有以下内容：

Hello world!

如果将 YAH_YAML_DOC_START 和 YAH_YAML_DOC_END 的第 2 个参数设为 0，则 foo.yaml 的内容会变为

--- Hello world!
...

它虽然合法，但并非我们想要的。我们想要的是

---
Hello world!
...

然而，libyaml 对此却无能为力，除非你是它的维护者。不过，我们几乎不会只向 YAML 文件输出标量，故而 libyaml 的这个 bug 或 feature 无伤大雅。

如果确实需要，我们可以在禁止 libyaml 显示 YAML 文档起始标记的情况下，自行向 YAML 文件写入 --- 和 ...，例如

#include 

int main(void) {
    FILE *yaml_file;
    YAH_OPEN_FILE(yaml_file, "foo.yaml", "w");
    fprintf(yaml_file, "---\n"); /* 写入 YAML 文档起始标记 */
    
    yaml_emitter_t emitter;
    yaml_event_t event;
    YAH_YAML_EMITTER_INIT(&emitter, yaml_file);
    YAH_YAML_START(&emitter, &event, YAML_UTF8_ENCODING);
    
    /* 输出只有一个标量的 YAML 文档 */
    YAH_YAML_DOC_START(&emitter, &event, 1);
    YAH_YAML_SCALAR(&emitter,
                    &event,
                    yah_yaml_scalar("Hello world!"),
                    YAML_PLAIN_SCALAR_STYLE);
    YAH_YAML_DOC_END(&emitter, &event, 1);

    YAH_YAML_END(&emitter, &event);
    yaml_event_delete(&event);
    yaml_emitter_delete(&emitter);
    
    fprintf(yaml_file, "...\n"); /* 写入 YAML 文档结束标记 */
    fclose(yaml_file);
    return EXIT_SUCCESS;
}

序列

想向 YAML 文件中输出多个标量，用一个循环，重复调用 YAH_YAML_SCALAR 宏是不行的，例如，你可以向 foo.yaml 文件写入以下内容

a
b
c

但它不是三个标量，而是一个，即 a b c。因为 YAML 解析器会将其视为一个含有换行符的普通标量，然后解析器会将每个换行符替换为 1 个空格。

在 YAML 文件中，表达多个标量，只能用序列。例如

- a
- b
- c

用 libyaml 输出序列的过程，我们可以用两个宏来表达。

#define YAH_YAML_SEQ_START(emitter, event, style) do { \
    if (!yaml_sequence_start_event_initialize(event, \
                                              NULL, \
                                              NULL, \
                                              1, \
                                              style)) { \
        fprintf(stderr, "failed to initialize *sequence_start* event.\n"); \
        exit(EXIT_FAILURE); \
    } \
    YAH_YAML_EMIT(emitter, event); \
} while (0)
#define YAH_YAML_SEQ_END(emitter, event) do {      \
    if (!yaml_sequence_end_event_initialize(event)) { \
        fprintf(stderr, "failed to initialize *sequence_end* event.\n"); \
        exit(EXIT_FAILURE); \
    } \
    YAH_YAML_EMIT(emitter, event); \
} while (0)

yaml_sequence_start_event_initialize 的第二、三个参数分别是锚点和标签，我们可以用 NULL 忽略它们，第四个参数表示隐藏还是显示标签，1 表示禁止，0 表示显示，由于我们不关心标签，故而将其设为 1。第五个参数，也就是最后一个参数，将其作为 YAH_YAML_SEQ_START 的参数，由用户设定，该参数用于设定序列的风格是块风格（block style）还是流风格（flow style）。

以下代码可以输出块风格的序列：

const char *seq[] = {"a", "b", "c"};
size_t n = sizeof(seq) / sizeof(const char *);
YAH_YAML_SEQ_START(&emitter, &event, YAML_BLOCK_SEQUENCE_STYLE);
for (size_t i = 0; i < n; i++) {
    YAH_YAML_SCALAR(&emitter,
                    &event,
                    seq[i],
                    YAML_PLAIN_SCALAR_STYLE);
}
YAH_YAML_SEQ_END(&emitter, &event);

输出结果应当为

- a
- b
- c

若将 YAH_YAML_SEQ_START 的第三个参数更换为 YAML_FLOW_SEQUENCE_STYLE，便可输出流风格的序列，即

[a, b, c]

映射

映射事件的构造和发送，与序列完全一致，将上一节定义的两个宏，更换一下名字即可实现该过程。

#define YAH_YAML_MAP_START(emitter, event, style) do { \
    if (!yaml_mapping_start_event_initialize(event, \
                                             NULL, \
                                             NULL, \
                                             1, \
                                             style)) { \
        fprintf(stderr, "failed to initialize *mapping_start* event.\n"); \
        exit(EXIT_FAILURE); \
    } \
    YAH_YAML_EMIT(emitter, event); \
} while (0)
#define YAH_YAML_MAP_END(emitter, event) do { \
    if (!yaml_mapping_end_event_initialize(event)) { \
        fprintf(stderr, "failed to initialize *mapping_end* event.\n"); \
        exit(EXIT_FAILURE); \
    } \
    YAH_YAML_EMIT(emitter, event); \
} while (0)

如果我们想将一个变量的名字和值以 YAML 格式输出，便可以用映射。例如

/* 要保存的数据 */
int truth = 42;
/* 构造键和值 */
const char *key = "truth";
char value[255];
snprintf(value, sizeof(value), "%d", truth);
/* 输出只含有一个键值对的映射 */
YAH_YAML_MAP_START(&emitter, &event, YAML_BLOCK_MAPPING_STYLE);
YAH_YAML_SCALAR(&emitter, &event, key, YAML_PLAIN_SCALAR_STYLE);
YAH_YAML_SCALAR(&emitter, &event, value, YAML_PLAIN_SCALAR_STYLE);
YAH_YAML_MAP_END(&emitter, &event);

上述代码可输出以下内容：

truth: 42

如果你将上述代码中的映射风格由块风格 YAML_BLOCK_MAPPING_STYLE 换位流风格 YAML_FLOW_MAPPING_STYLE，则输出内容会变为

{truth: 42}

我知道，你也许已经有些不耐烦了，大概会想，为何不用 printf 或 fprintf 直接向输出上述内容呢？简单的数据可以如此，但是对于复杂一些的数据，例如多层嵌套的结构体，要输出为 YAML 嵌套映射格式，也许你会不想自己去处理块风格中的缩进。不过，要输出这样的结构体，即使我们用宏简化了很多代码，但代码量依然是非常可观，以致于我根本不想举例说明。对于映射，我们还需要再想一些简化方法。

键的输出过程，可以简化为宏：

#define YAH_YAML_KEY(name, style) do { \
    const char *key = #name; \
    YAH_YAML_SCALAR(&emitter, &event, key, YAML_##style##_SCALAR_STYLE); \
} while (0)

上述宏定义，使用了 C 语言宏的 ## 和 # 语法。符号 ## 可将宏参数与相邻的文本连接起来，例如若 style 的值为 PLAIN，则 YAML_##style 会被展开为 YAML_PLAIN。符号 # 可为其后的宏参数添加引号，例如若 name 的值为 true，则 #true 会被展开为 "truth"。

YAH_YAML_KEY 的用法如下：

int truth = 42;
char value[255];
snprintf(value, sizeof(value), "%d", truth);
YAH_YAML_MAP_START(&emitter, &event, YAML_BLOCK_MAPPING_STYLE);
YAH_YAML_KEY(truth, PLAIN); /* 输出键 truth */
YAH_YAML_SCALAR(&emitter, &event, value, YAML_PLAIN_SCALAR_STYLE); /* 输出值 */
YAH_YAML_MAP_END(&emitter, &event);

至于键值对里的值，其 YAML 格式输出过程则很难简化，因为输出形式可能是标量，也可能是序列，还可能是映射。如果我们暂且只考虑值为标量的情况。若值在 C 程序中为数字，则可定义一个宏，将其转换为字符串，然后输出为 YAML 标量。

/* 将整型数输出为 YAML 标量 */
/* 整形数转换成的文本，最多只能是 1024 个字节 */
#define YAH_YAML_INT(interger, style) do { \
    char value[1024]; \
    snprintf(value, sizeof(value), "%d", interger); \
    YAH_YAML_SCALAR(&emitter, &event, value, YAML_##style##_SCALAR_STYLE); \
} while (0)

/* 将浮点数（实数）输出为 YAML 标量 */
/* 浮点数转换成的文本，最多只能是 1024 个字节 */
#define YAH_YAML_REAL(real, style) do { \
    char value[1024]; \
    snprintf(value, sizeof(value), "%f", real); \
    YAH_YAML_SCALAR(&emitter, &event, value, YAML_##style##_SCALAR_STYLE); \
} while (0)

/* 将字符串输出为 YAML 标量 */
#define YAH_YAML_STR(string, style) do { \
    YAH_YAML_SCALAR(&emitter, &event, string, YAML_##style##_SCALAR_STYLE); \
} while (0)

通过 YAH_YAML_INT 宏，可以将上述的 truth 变量的值输出为 YAML 格式的过程简化为

int truth = 42;
YAH_YAML_MAP_START(&emitter, &event, YAML_BLOCK_MAPPING_STYLE);
YAH_YAML_KEY(truth, PLAIN); /* 输出键 truth */
YAH_YAML_INT(truth, PLAIN); /* 输出值 42 */
YAH_YAML_MAP_END(&emitter, &event);

现在，可以尝试将 C 结构体输出为 YAML 块格式。例如

struct foo {
    int a;
    double b;
    const char *c;
} x = {42, 3.1415926, "Hello world!"};

/* 输出 x：第一层映射 */
YAH_YAML_MAP_START(&emitter, &event, YAML_BLOCK_MAPPING_STYLE);
YAH_YAML_KEY(x, PLAIN); /* 输出键 x */
/* 输出 x 的成员：第二层映射 */
YAH_YAML_MAP_START(&emitter, &event, YAML_BLOCK_MAPPING_STYLE);
/* 输出 x.a */
YAH_YAML_KEY(a, PLAIN); YAH_YAML_INT(x.a, PLAIN);
/* 输出 x.b */
YAH_YAML_KEY(b, PLAIN); YAH_YAML_REAL(x.b, PLAIN);
/* 输出 x.c */
YAH_YAML_KEY(c, PLAIN); YAH_YAML_STR(x.c, PLAIN);
/* 第二层映射结束 */
YAH_YAML_MAP_END(&emitter, &event);
/* 第一层映射结束 */
YAH_YAML_MAP_END(&emitter, &event);

上述代码的输出结果为块风格的嵌套映射：

x:
  a: 42
  b: 3.141593
  c: Hello world!

若将上述代码中的 YAML_BLOCK_MAPPING_STYLE 都替换为 YAML_FLOW_MAPPING_STYLE，便可输出流风格的嵌套映射：

{x: {a: 42, b: 3.141593, c: Hello world!}}

将上述宏定义都加入到 yah-yaml.h 里，然后，我可以给出一个完整的 foo.c，它实现了上述结构体的输出。

#include 

int main(void) {
    FILE *yaml_file;
    yaml_emitter_t emitter;
    yaml_event_t event;
    YAH_OPEN_FILE(yaml_file, "foo.yaml", "w")
    YAH_YAML_EMITTER_INIT(&emitter, yaml_file);
    YAH_YAML_START(&emitter, &event, YAML_UTF8_ENCODING);
    YAH_YAML_DOC_START(&emitter, &event, 0);

    struct foo {
        int a;
        double b;
        const char *c;
    } x = {42, 3.1415926, "Hello world!"};
    
    /* 输出 x */
    YAH_YAML_MAP_START(&emitter, &event, YAML_BLOCK_MAPPING_STYLE);
    YAH_YAML_KEY(x, PLAIN); /* 输出键 x */
    /* 输出 x 的成员 */
    YAH_YAML_MAP_START(&emitter, &event, YAML_BLOCK_MAPPING_STYLE);
    /* 输出 x.a */
    YAH_YAML_KEY(a, PLAIN); YAH_YAML_INT(x.a, PLAIN);
    /* 输出 x.b */
    YAH_YAML_KEY(b, PLAIN); YAH_YAML_REAL(x.b, PLAIN);
    /* 输出 x.c */
    YAH_YAML_KEY(c, PLAIN); YAH_YAML_STR(x.c, PLAIN);
    YAH_YAML_MAP_END(&emitter, &event);
    YAH_YAML_MAP_END(&emitter, &event);
    
    YAH_YAML_DOC_END(&emitter, &event, 0);
    YAH_YAML_END(&emitter, &event);
    yaml_event_delete(&event);
    yaml_emitter_delete(&emitter);
    fclose(yaml_file);
    return EXIT_SUCCESS;
}

修整

既然我们已经掌握了宏定义中的 ## 符号的用法，那么之前定义的几个宏，它们颇长的参数也可以有所简化，如下：

#define YAH_YAML_START(emitter, event, encoding) do { \
    if (!yaml_stream_start_event_initialize(event, YAML_##encoding##_ENCODING)) { \
        fprintf(stderr, "failed to initialize *stream_start* event.\n"); \
        exit(EXIT_FAILURE); \
    } \
    YAH_YAML_EMIT(emitter, event); \
} while (0)
#define YAH_YAML_SCALAR(emitter, event, string, style) do { \
    if (!yaml_scalar_event_initialize(event, \
                                      NULL, \
                                      NULL, \
                                      (const yaml_char_t *)(string), \
                                      strlen(string), \
                                      1, \
                                      1, \
                                      YAML_##style##_SCALAR_STYLE)) { \
        fprintf(stderr, "failed to initialize *scalar* event.\n"); \
        exit(EXIT_FAILURE); \
    } \
    YAH_YAML_EMIT(emitter, event); \
} while (0)
#define YAH_YAML_SEQ_START(emitter, event, style) do { \
    if (!yaml_sequence_start_event_initialize(event, \
                                              NULL, \
                                              NULL, \
                                              1, \
                                              YAML_##style##_SEQUENCE_STYLE)) { \
        fprintf(stderr, "failed to initialize *sequence_start* event.\n"); \
        exit(EXIT_FAILURE); \
    } \
    YAH_YAML_EMIT(emitter, event); \
} while (0)
#define YAH_YAML_MAP_START(emitter, event, style) do { \
    if (!yaml_mapping_start_event_initialize(event, \
                                             NULL, \
                                             NULL, \
                                             1, \
                                             YAML_##style##_MAPPING_STYLE)) { \
        fprintf(stderr, "failed to initialize *mapping_start* event.\n"); \
        exit(EXIT_FAILURE); \
    } \
    YAH_YAML_EMIT(emitter, event); \
} while (0)
#define YAH_YAML_INT(interger, style) do { \
    char value[1024]; \
    snprintf(value, sizeof(value), "%d", interger); \
    YAH_YAML_SCALAR(&emitter, &event, value, style); \
} while (0)

#define YAH_YAML_REAL(real, style) do { \
    char value[1024]; \
    snprintf(value, sizeof(value), "%f", real); \
    YAH_YAML_SCALAR(&emitter, &event, value, style); \
} while (0)

#define YAH_YAML_STR(string, style) do { \
    YAH_YAML_SCALAR(&emitter, &event, string, style); \
} while (0)

用上述修改的宏定义替换 yah-yaml.h 中相应的宏定义，然后 foo.c 便可以更为清爽一些，如下：

#include 

int main(void) {
    FILE *yaml_file;
    yaml_emitter_t emitter;
    yaml_event_t event;
    YAH_OPEN_FILE(yaml_file, "foo.yaml", "w");
    YAH_YAML_EMITTER_INIT(&emitter, yaml_file);
    YAH_YAML_START(&emitter, &event, UTF8);
    YAH_YAML_DOC_START(&emitter, &event, 0);

    struct foo {
        int a;
        double b;
        const char *c;
    } x = {42, 3.1415926, "Hello world!"};
    YAH_YAML_MAP_START(&emitter, &event, BLOCK);
    YAH_YAML_KEY(x, PLAIN);
    YAH_YAML_MAP_START(&emitter, &event, BLOCK);
    YAH_YAML_KEY(a, PLAIN); YAH_YAML_INT(x.a, PLAIN);
    YAH_YAML_KEY(b, PLAIN); YAH_YAML_REAL(x.b, PLAIN);
    YAH_YAML_KEY(c, PLAIN); YAH_YAML_STR(x.c, PLAIN);
    YAH_YAML_MAP_END(&emitter, &event);
    YAH_YAML_MAP_END(&emitter, &event);
    
    YAH_YAML_DOC_END(&emitter, &event, 0);
    YAH_YAML_END(&emitter, &event);
    yaml_event_delete(&event);
    yaml_emitter_delete(&emitter);
    fclose(yaml_file);
    return EXIT_SUCCESS;
}

总结

现在，我们已经征服了遍布灌木的 libyaml 山。这是一座并不高的山，但是当我们站在山顶上，终归是能感受到夏日里习习凉风。休息一会便可以下山。下山的途中，你可以思考这样一个问题，能否将要输出的 C 数据依序组织成链表或数组，每个节点或单元存储 C 变量的名字和它的值，再用一些节点或单元表达序列和映射的开始和结束，然后我们遍历这个链表或数组，以 YAML 格式输出每个节点或单元的信息。这个想法有些类似于，我们不必再一步一步走到山下，而是修建一条索道，像飞鸟一样滑到山下。

你可能感兴趣的:(yamlc)

  • 桌面上有多个球在同时运动，怎么实现球之间不交叉，即碰撞？ 换个号韩国红果果 html小球碰撞
    稍微想了一下，然后解决了很多bug，最后终于把它实现了。其实原理很简单。在每改变一个小球的x y坐标后，遍历整个在dom树中的其他小球，看一下它们与当前小球的距离是否小于球半径的两倍？若小于说明下一次绘制该小球（设为a）前要把他的方向变为原来相反方向（与a要碰撞的小球设为b），即假如当前小球的距离小于球半径的两倍的话，马上改变当前小球方向。那么下一次绘制也是先绘制b，再绘制a，由于a的方向已经改变
  • 《高性能HTML5》读后整理的Web性能优化内容 白糖_ html5
    读后感         先说说《高性能HTML5》这本书的读后感吧，个人觉得这本书前两章跟书的标题完全搭不上关系，或者说只能算是讲解了“高性能”这三个字，HTML5完全不见踪影。个人觉得作者应该首先把HTML5的大菜拿出来讲一讲，再去分析性能优化的内容，这样才会有吸引力。因为只是在线试读，没有机会看后面的内容，所以不胡乱评价了。  
  • [JShop]Spring MVC的RequestContextHolder使用误区 dinguangx jeeshop商城系统jshop电商系统
        在spring mvc中，为了随时都能取到当前请求的request对象，可以通过RequestContextHolder的静态方法getRequestAttributes()获取Request相关的变量，如request, response等。         在jshop中，对RequestContextHolder的
  • 算法之时间复杂度 周凡杨 java算法时间复杂度效率
          在 计算机科学 中， 算法 的时间复杂度是一个 函数 ，它定量描述了该算法的运行时间。这是一个关于代表算法输入值的 字符串 的长度的函数。时间复杂度常用 大O符号 表述，不包括这个函数的低阶项和首项系数。使用这种方式时，时间复杂度可被称为是 渐近 的，它考察当输入值大小趋近无穷时的情况。 这样用大写O()来体现算法时间复杂度的记法，
  • Java事务处理 g21121 java
    一、什么是Java事务 通常的观念认为，事务仅与数据库相关。 事务必须服从ISO/IEC所制定的ACID原则。ACID是原子性（atomicity）、一致性（consistency）、隔离性（isolation）和持久性（durability）的缩写。事务的原子性表示事务执行过程中的任何失败都将导致事务所做的任何修改失效。一致性表示当事务执行失败时，所有被该事务影响的数据都应该恢复到事务执行前的状
  • Linux awk命令详解 510888780 linux
    一.  AWK 说明   awk是一种编程语言，用于在linux/unix下对文本和数据进行处理。数据可以来自标准输入、一个或多个文件，或其它命令的输出。它支持用户自定义函数和动态正则表达式等先进功能，是linux/unix下的一个强大编程工具。它在命令行中使用，但更多是作为脚本来使用。    awk的处理文本和数据的方式：它逐行扫描文件，从第一行到
  • android permission 布衣凌宇 Permission
    <uses-permission android:name="android.permission.ACCESS_CHECKIN_PROPERTIES" ></uses-permission>允许读写访问"properties"表在checkin数据库中，改值可以修改上传 <uses-permission android:na
  • Oracle和谷歌Java Android官司将推迟 aijuans javaoracle
    北京时间 10 月 7 日，据国外媒体报道，Oracle 和谷歌之间一场等待已久的官司可能会推迟至 10 月 17 日以后进行，这场官司的内容是 Android 操作系统所谓的 Java 专利权之争。本案法官 William Alsup 称根据专利权专家 Florian Mueller 的预测，谷歌 Oracle 案很可能会被推迟。　　该案中的第二波辩护被安排在 10 月 17 日出庭，从目前看来
  • linux shell 常用命令 antlove linuxshellcommand
    grep [options] [regex] [files] /var/root # grep -n "o" * hello.c:1:/* This C source can be compiled with:
  • Java解析XML配置数据库连接(DOM技术连接 SAX技术连接) 百合不是茶 sax技术Java解析xml文档dom技术XML配置数据库连接
        XML配置数据库文件的连接其实是个很简单的问题,为什么到现在才写出来主要是昨天在网上看了别人写的,然后一直陷入其中,最后发现不能自拔 所以今天决定自己完成 ,,,,现将代码与思路贴出来供大家一起学习   XML配置数据库的连接主要技术点的博客; JDBC编程 : JDBC连接数据库 DOM解析XML:  DOM解析XML文件 SA
  • underscore.js 学习（二） bijian1013 JavaScriptunderscore
            Array Functions 所有数组函数对参数对象一样适用。1.first   _.first(array, [n])   别名: head, take       返回array的第一个元素，设置了参数n，就
  • plSql介绍 bijian1013 oracle数据库plsql
    /* * PL/SQL 程序设计学习笔记 * 学习plSql介绍.pdf * 时间：2010-10-05 */ --创建DEPT表 create table DEPT ( DEPTNO NUMBER(10), DNAME NVARCHAR2(255), LOC NVARCHAR2(255) ) delete dept; select
  • 【Nginx一】Nginx安装与总体介绍 bit1129 nginx
    启动、停止、重新加载Nginx nginx 启动Nginx服务器，不需要任何参数u nginx -s stop 快速(强制)关系Nginx服务器 nginx -s quit 优雅的关闭Nginx服务器 nginx -s reload 重新加载Nginx服务器的配置文件 nginx -s reopen 重新打开Nginx日志文件  
  • spring mvc开发中浏览器兼容的奇怪问题 bitray jqueryAjaxspringMVC浏览器上传文件
        最近个人开发一个小的OA项目,属于复习阶段.使用的技术主要是spring mvc作为前端框架,mybatis作为数据库持久化技术.前台使用jquery和一些jquery的插件.     在开发到中间阶段时候发现自己好像忽略了一个小问题,整个项目一直在firefox下测试,没有在IE下测试,不确定是否会出现兼容问题.由于jquer
  • Lua的io库函数列表 ronin47 lua io
    1、io表调用方式：使用io表，io.open将返回指定文件的描述，并且所有的操作将围绕这个文件描述 　　io表同样提供三种预定义的文件描述io.stdin,io.stdout,io.stderr 　　2、文件句柄直接调用方式,即使用file:XXX()函数方式进行操作,其中file为io.open()返回的文件句柄 　　多数I/O函数调用失败时返回nil加错误信息,有些函数成功时返回nil
  • java-26-左旋转字符串 bylijinnan java
    public class LeftRotateString { /** * Q 26 左旋转字符串 * 题目：定义字符串的左旋转操作：把字符串前面的若干个字符移动到字符串的尾部。 * 如把字符串abcdef左旋转2位得到字符串cdefab。 * 请实现字符串左旋转的函数。要求时间对长度为n的字符串操作的复杂度为O(n)，辅助内存为O(1)。 */ pu
  • 《vi中的替换艺术》-linux命令五分钟系列之十一 cfyme linux命令
    vi方面的内容不知道分类到哪里好，就放到《Linux命令五分钟系列》里吧！ 今天编程，关于栈的一个小例子，其间我需要把”S.”替换为”S->”(替换不包括双引号)。 其实这个不难，不过我觉得应该总结一下vi里的替换技术了，以备以后查阅。   1 所有替换方案都要在冒号“:”状态下书写。 2 如果想将abc替换为xyz，那么就这样 :s/abc/xyz/ 不过要特别
  • [轨道与计算]新的并行计算架构 comsci 并行计算
         我在进行流程引擎循环反馈试验的过程中，发现一个有趣的事情。。。如果我们在流程图的每个节点中嵌入一个双向循环代码段，而整个流程中又充满着很多并行路由，每个并行路由中又包含着一些并行节点，那么当整个流程图开始循环反馈过程的时候，这个流程图的运行过程是否变成一个并行计算的架构呢？      
  • 重复执行某段代码 dai_lm android
    用handler就可以了 private Handler handler = new Handler(); private Runnable runnable = new Runnable() { public void run() { update(); handler.postDelayed(this, 5000); } }; 开始计时 h
  • Java实现堆栈（list实现） datageek 数据结构——堆栈
    public interface IStack<T> { //元素出栈，并返回出栈元素 public T pop(); //元素入栈 public void push(T element); //获取栈顶元素 public T peek(); //判断栈是否为空 public boolean isEmpty
  • 四大备份MySql数据库方法及可能遇到的问题 dcj3sjt126com DBbackup
    一：通过备份王等软件进行备份前台进不去？ 用备份王等软件进行备份是大多老站长的选择，这种方法方便快捷，只要上传备份软件到空间一步步操作就可以，但是许多刚接触备份王软件的客用户来说还原后会出现一个问题：因为新老空间数据库用户名和密码不统一，网站文件打包过来后因没有修改连接文件，还原数据库是好了，可是前台会提示数据库连接错误，网站从而出现打不开的情况。 解决方法：学会修改网站配置文件，大多是由co
  • github做webhooks：[1]钩子触发是否成功测试 dcj3sjt126com githubgitwebhook
    转自: http://jingyan.baidu.com/article/5d6edee228c88899ebdeec47.html github和svn一样有钩子的功能，而且更加强大。例如我做的是最常见的push操作触发的钩子操作，则每次更新之后的钩子操作记录都会在github的控制板可以看到！ 工具/原料 github 方法/步骤
  • ">的作用" target="_blank">JSP中的作用 蕃薯耀
    JSP中<base href="<%=basePath%>">的作用 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  • linux下SAMBA服务安装与配置 hanqunfeng linux
    局域网使用的文件共享服务。 一.安装包： rpm -qa | grep samba samba-3.6.9-151.el6.x86_64 samba-common-3.6.9-151.el6.x86_64 samba-winbind-3.6.9-151.el6.x86_64 samba-client-3.6.9-151.el6.x86_64 samba-winbind-clients
  • guava cache IXHONG cache
    缓存，在我们日常开发中是必不可少的一种解决性能问题的方法。简单的说，cache 就是为了提升系统性能而开辟的一块内存空间。 　　缓存的主要作用是暂时在内存中保存业务系统的数据处理结果，并且等待下次访问使用。在日常开发的很多场合，由于受限于硬盘IO的性能或者我们自身业务系统的数据处理和获取可能非常费时，当我们发现我们的系统这个数据请求量很大的时候，频繁的IO和频繁的逻辑处理会导致硬盘和CPU资源的
  • Query的开始--全局变量,noconflict和兼容各种js的初始化方法 kvhur JavaScriptjquerycss
    这个是整个jQuery代码的开始，里面包含了对不同环境的js进行的处理，例如普通环境，Nodejs，和requiredJs的处理方法。 还有jQuery生成$, jQuery全局变量的代码和noConflict代码详解  完整资源： http://www.gbtags.com/gb/share/5640.htm jQuery 源码：   (
  • 美国人的福利和中国人的储蓄 nannan408
       今天看了篇文章，震动很大，说的是美国的福利。    美国医院的无偿入院真的是个好措施。小小的改善，对于社会是大大的信心。小孩，税费等，政府不收反补，真的体现了人文主义。    美国这么高的社会保障会不会使人变懒？答案是否定的。正因为政府解决了后顾之忧，人们才得以倾尽精力去做一些有创造力，更造福社会的事情，这竟成了美国社会思想、人
  • N阶行列式计算(JAVA) qiuwanchi N阶行列式计算
    package gaodai; import java.util.List; /** * N阶行列式计算 * @author 邱万迟 * */ public class DeterminantCalculation { public DeterminantCalculation(List<List<Double>> determina
  • C语言算法之打渔晒网问题 qiufeihu c算法
    如果一个渔夫从2011年1月1日开始每三天打一次渔，两天晒一次网，编程实现当输入2011年1月1日以后任意一天，输出该渔夫是在打渔还是在晒网。 代码如下：   #include <stdio.h> int leap(int a) /*自定义函数leap()用来指定输入的年份是否为闰年*/ { if((a%4 == 0 && a%100 != 0
  • XML中DOCTYPE字段的解析 wyzuomumu xml
    DTD声明始终以!DOCTYPE开头,空一格后跟着文档根元素的名称,如果是内部DTD,则再空一格出现[],在中括号中是文档类型定义的内容. 而对于外部DTD,则又分为私有DTD与公共DTD,私有DTD使用SYSTEM表示,接着是外部DTD的URL. 而公共DTD则使用PUBLIC,接着是DTD公共名称,接着是DTD的URL.   私有DTD <!DOCTYPErootSYST
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他