在C中使用libyaml将YAML解析为值

我正在尝试在linux服务器上使用C解析YAML文件（这是对现有应用程序的修改，因此无法更改语言）

我已经在Libyml wiki上阅读了教程

我想做的是将此应用程序的数据库配置从头文件移到YAML中，这样我就可以作为单独的步骤进行编译和配置，允许我使用Chef来管理配置

以下是yaml：

---
db_server: "localhost"
db_password: "wibble"
db_username: "test"
national_rail_username: test
national_rail_password: wibble

我要做的是迭代文件并根据键名设置变量

psuedo代码如下所示：

config = YAML::load("file.yaml")
DBUSER = config['db_username']
DBPASS = config['db_password']
DBSERVER = config['db_server']
NATIONAL_RAIL_USERNAME = config['national_rail_username']
NATIONAL_RAIL_PASSWORD = config['national_rail_password']

（如果上面看起来有点像ruby/python，那是因为我已经习惯了使用这些语言！）

我设法用YAML CPP来测试测试程序，然后我意识到，我一直在错误地树三个小时，因为主应用程序是用C编写的，而不是C++。 编辑：以下是我目前掌握的代码。这是上面教程网站上的一个剪切粘贴，但是我不相信这是正确的方法，而且它似乎没有为我提供一种在C代码中为变量分配YAML“键”的方法

#include <stdio.h>
#include <yaml.h>

int main(void)
{
  FILE *fh = fopen("config.yaml", "r");
  yaml_parser_t parser;
  yaml_token_t  token;   /* new variable */

  /* Initialize parser */
  if(!yaml_parser_initialize(&parser))
    fputs("Failed to initialize parser!\n", stderr);
  if(fh == NULL)
    fputs("Failed to open file!\n", stderr);

  /* Set input file */
  yaml_parser_set_input_file(&parser, fh);

  /* BEGIN new code */
  do {
    yaml_parser_scan(&parser, &token);
    switch(token.type)
    {
    /* Stream start/end */
    case YAML_STREAM_START_TOKEN: puts("STREAM START"); break;
    case YAML_STREAM_END_TOKEN:   puts("STREAM END");   break;
    /* Token types (read before actual token) */
    case YAML_KEY_TOKEN:   printf("(Key token)   "); break;
    case YAML_VALUE_TOKEN: printf("(Value token) "); break;
    /* Block delimeters */
    case YAML_BLOCK_SEQUENCE_START_TOKEN: puts("<b>Start Block (Sequence)</b>"); break;
    case YAML_BLOCK_ENTRY_TOKEN:          puts("<b>Start Block (Entry)</b>");    break;
    case YAML_BLOCK_END_TOKEN:            puts("<b>End block</b>");              break;
    /* Data */
    case YAML_BLOCK_MAPPING_START_TOKEN:  puts("[Block mapping]");            break;
    case YAML_SCALAR_TOKEN:  printf("scalar %s \n", token.data.scalar.value); break;
    /* Others */
    default:
      printf("Got token of type %d\n", token.type);
    }
    if(token.type != YAML_STREAM_END_TOKEN)
      yaml_token_delete(&token);
  } while(token.type != YAML_STREAM_END_TOKEN);
  yaml_token_delete(&token);
  /* END new code */

  /* Cleanup */
  yaml_parser_delete(&parser);
  fclose(fh);
  return 0;
}

#包括
#包括
内部主（空）
{
文件*fh=fopen（“config.yaml”，“r”）；
yaml_解析器_t解析器；
yaml_token_t token；/*新变量*/
/*初始化解析器*/
if（！yaml_解析器_初始化（&parser））
fputs（“未能初始化解析器！\n”，stderr）；
如果（fh==NULL）
fputs（“无法打开文件！\n”，标准文件）；
/*设置输入文件*/
yaml_解析器_集_输入文件（&parser，fh）；
/*开始新代码*/
做{
yaml_解析器_扫描（&解析器和令牌）；
开关（token.type）
{
/*流开始/结束*/
case YAML_STREAM_START_令牌：put（“STREAM START”）；break；
case YAML_STREAM_END_TOKEN:put（“STREAM END”）；break；
/*令牌类型（在实际令牌之前读取）*/
case YAML_KEY_TOKEN:printf（“（KEY TOKEN）”）；break；
case YAML_VALUE_TOKEN:printf（“（VALUE TOKEN）”）；break；
/*块状测厚仪*/
case YAML_BLOCK_SEQUENCE_START_TOKEN:put（“START BLOCK（SEQUENCE）”）；break；
case YAML_BLOCK_ENTRY_TOKEN:put（“起始块（条目）”）；break；
case YAML_BLOCK_END_TOKEN:put（“END BLOCK”）；break；
/*资料*/
case YAML_BLOCK_MAPPING_START_令牌：put（“[BLOCK MAPPING]”）；break；
case YAML\u SCALAR\u标记：printf（“标量%s\n”，TOKEN.data.SCALAR.value）；break；
/*其他*/
违约：
printf（“获取类型为%d\n的令牌”，token.type）；
}
if（token.type！=YAML\u STREAM\u END\u token）
yaml_令牌_删除（&T令牌）；
}while（token.type！=YAML\u STREAM\u END\u token）；
yaml_令牌_删除（&T令牌）；
/*结束新代码*/
/*清理*/
yaml_解析器_delete（&parser）；
fclose（fh）；
返回0；
}

我从该教程中获取了一大块示例代码，并对其进行了黑客攻击。买主，我上次写C已经有一段时间了

我使用了令牌API，事件API实际上看起来更简单

#include <stdio.h>
#include <yaml.h>

typedef struct Conf {
  char* db_server;
  char* db_pass;
  char* db_user;
  char* rail_user;
  char* rail_pass;
}

Conf* readConf(char* filename) {
  FILE* fh = fopen(filename, "r");
  yaml_parser_t parser;
  yaml_token_t token;
  Conf* conf = malloc(sizeof(Conf));

  if (!yaml_parser_initialize(&parser))
    fputs("Failed to initialize parser!\n", stderr);
  if (fh == NULL)
    fputs("Failed to open file!\n", stderr);
  yaml_parser_set_input_file(&parser, fh);

  do {
    /* As this is an example, I'll just use:
     *  state = 0 = expect key
     *  state = 1 = expect value
     */
    int state = 0;
    char** datap;
    char* tk;

    yaml_parser_scan(&parser, &token);
    switch(token.type)
    {
    case YAML_KEY_TOKEN:     state = 0; break;
    case YAML_VALUE_TOKEN:   state = 1; break;
    case YAML_SCALAR_TOKEN:
      tk = token.data.scalar.value;
      if (state == 0) {
        /* It's safe to not use strncmp as one string is a literal */
        if (!strcmp(tk, "db_server")) {
          datap = &conf.db_server;
        } else if (!strcmp(tk, "db_password")) {
          datap = &conf.db_pass;
        } else if (!strcmp(tk, "db_username")) {
          datap = &conf.db_user;
        } else if (!strcmp(tk, "national_rail_username")) {
          datap = &conf.rail_user;
        } else if (!strcmp(tk, "national_rail_password")) {
          datap = &conf.rail_pass;
        } else {
          printf("Unrecognised key: %s\n", tk);
        }
      } else {
        *datap = strdup(tk);
      }
      break;
    default: break;
    }
    if (token.type != YAML_STREAM_END_TOKEN)
      yaml_token_delete(&token);
  } while (token.type != YAML_STREAM_END_TOKEN);
  yaml_token_delete(&token);

  yaml_parser_delete(&parser);
  fclose(fh);
  return conf;
}

#包括
#包括
类型定义结构配置{
char*db_服务器；
char*db_pass；
char*db_用户；
字符*轨道用户；
char*铁路通行证；
}
Conf*readConf（char*filename）{
文件*fh=fopen（文件名，“r”）；
yaml_解析器_t解析器；
yaml_token_t token；
Conf*Conf=malloc（sizeof（Conf））；
if（！yaml_解析器_初始化（&parser））
fputs（“未能初始化解析器！\n”，stderr）；
如果（fh==NULL）
fputs（“无法打开文件！\n”，标准文件）；
yaml_解析器_集_输入文件（&parser，fh）；
做{
/*由于这是一个示例，我将仅使用：
*state=0=expect键
*状态=1=期望值
*/
int state=0；
字符**datap；
char*tk；
yaml_解析器_扫描（&解析器和令牌）；
开关（token.type）
{
案例YAML_密钥_令牌：状态=0；中断；
案例YAML_值_标记：状态=1；中断；
案例YAML\u标量\u令牌：
tk=token.data.scalar.value；
如果（状态==0）{
/*不使用strncmp是安全的，因为一个字符串是一个文本*/
如果（！strcmp（tk，“db_服务器”））{
datap=&conf.db_服务器；
}否则，如果（！strcmp（tk，“db_密码”））{
datap=&conf.db\u pass；
}如果（！strcmp（tk，“db_用户名”））{
datap=&conf.db\u用户；
}如果（！strcmp（tk，“国家铁路用户名”））{
datap=&conf.rail\u用户；
}否则，如果（！strcmp（tk，“国家铁路密码”））{
datap=&conf.rail\u pass；
}否则{
printf（“无法识别的密钥：%s\n”，tk）；
}
}否则{
*datap=标准偏差（tk）；
}
打破
默认：中断；
}
if（token.type！=YAML\u STREAM\u END\u token）
yaml_令牌_删除（&T令牌）；
}while（token.type！=YAML\u STREAM\u END\u token）；
yaml_令牌_删除（&T令牌）；
yaml_解析器_delete（&parser）；
fclose（fh）；
返回形态；
}

我认为lxs中的答案应该是

int state = 0;
char** datap;
char* tk;

在执行之前，请循环并使用&conf->key而不是&conf.key

有一个代码对我很有用：

#include <stdio.h>
#include <string.h>
#include <yaml.h>

typedef struct Conf {
    char* db_server;
    char* db_pass;
    char* db_user;
    char* rail_user;
    char* rail_pass;
}

Conf* readConf(char* filename) {
    FILE* fh = fopen(filename, "r");
    yaml_parser_t parser;
    yaml_token_t token;
    Conf* conf = malloc(sizeof(Conf));

    if (!yaml_parser_initialize(&parser))
        fputs("Failed to initialize parser!\n", stderr);
    if (fh == NULL)
        fputs("Failed to open file!\n", stderr);
    yaml_parser_set_input_file(&parser, fh);


    /* As this is an example, I'll just use:
     *  state = 0 = expect key
     *  state = 1 = expect value
     */
    int state = 0;
    char** datap;
    char* tk;

    do {
        yaml_parser_scan(&parser, &token);
        switch(token.type) {
            case YAML_KEY_TOKEN:     state = 0; break;
            case YAML_VALUE_TOKEN:   state = 1; break;
            case YAML_SCALAR_TOKEN:
                tk = token.data.scalar.value;
                if (state == 0) {
                    /* It's safe to not use strncmp as 
                       one string is a literal */
                    if (!strcmp(tk, "db_server")) {
                        datap = &conf->db_server;
                    } else if (!strcmp(tk, "db_password")) {
                        datap = &conf->db_pass;
                    } else if (!strcmp(tk, "db_username")) {
                        datap = &conf->db_user;
                    } else if (!strcmp(tk, "national_rail_username")) {
                        datap = &conf->rail_user;
                    } else if (!strcmp(tk, "national_rail_password")) {
                        datap = &conf->rail_pass;
                    } else {
                        printf("Unrecognised key: %s\n", tk);
                    }
                } else {
                      *datap = strdup(tk);
                }
                break;
           default: break;
           }
       if (token.type != YAML_STREAM_END_TOKEN)
           yaml_token_delete(&token);
   } while (token.type != YAML_STREAM_END_TOKEN);

   yaml_token_delete(&token);
   yaml_parser_delete(&parser);
   fclose(fh);
   return conf;
 }  

#包括
#包括
#包括
类型定义结构配置{
char*db_服务器；
char*db_pass；
char*db_用户；
字符*轨道用户；
char*铁路通行证；
}
Conf*readConf（char*filename）{
文件*fh=fopen（文件名，“r”）；
yaml_解析器_t解析器；
yaml_token_t token；
Conf*Conf=malloc（sizeof（Conf））；
if（！yaml_解析器_初始化（&parser））
fputs（“未能初始化解析器！\n”，stderr）；
如果（fh==NULL）
fputs（“无法打开文件！\n”，标准文件）；
yaml_解析器_集_输入文件（&parser，fh）；
/*由于这是一个示例，我将仅使用：
*state=0=expect键
*状态=1=期望值
*/
int state=0；
字符**datap；
char*tk；
做{
yaml_解析器_扫描（&解析器和令牌）；
开关（token.type）{
案例YAML_密钥_令牌：状态=0；中断；
案例YAML_值_标记：状态=1；中断；
案例YAML\u标量\u令牌：
tk=token.data.scalar.value；
如果（状态==0）{
/*不用担心