parsing YAML to values with libyaml in C

c, libyaml, linux

Solution

I took a chunk of example code from that tutorial and hacked on it. Caveat emptor, it's some time since I wrote C last!

I used the token API, the event API actually looks simpler.

#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;
}

Problem

I'm trying to parse a YAML file using C on a linux server (it's a modification to an existing app, so changing the language is not an option). I have read through the tutorial at http://wpsoftware.net/andrew/pages/libyaml.html and on the libyaml wiki. What I want to do is move the database configuration of this app out of a header file and into YAML so that I can compile and configure as separate steps, allowing me to use Chef to manage the configuration. Here is the yaml: ``` --- db_server: "localhost" db_password: "wibble" db_username: "test" national_rail_username: test national_rail_password: wibble ``` And what I want to do is iterate over the file and set variables based on the keyname. The psuedo-code is as follows: ``` 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'] ``` (if the above looks a bit like ruby/python, that's because I'm used to using those languages!) I managed to get a test setup working using YAML-cpp, then I realized that I'd been barking up the wrong tree for three hours because the primary app is written in C, not C++. EDIT: Here is the code I have so far. It is a cut and paste from the tutorial website above, however I do not believe it is the correct approach and it does not appear provide me with a way to allocate YAML "keys" to variables in the C code. ``` #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; } ```

Original source