static int
parse_fatso_yml(struct fatso_project* p, const char* file, char** out_error_message) {
int r = 1;
yaml_parser_t parser;
yaml_document_t doc;
yaml_parser_initialize(&parser);
FILE* fp = fopen(file, "r");
if (!fp) {
*out_error_message = strdup(strerror(errno));
goto out;
}
yaml_parser_set_input_file(&parser, fp);
if (!yaml_parser_load(&parser, &doc)) {
*out_error_message = strdup(parser.problem);
goto out_doc;
}
yaml_node_t* root = yaml_document_get_root_node(&doc);
if (root == NULL) {
*out_error_message = strdup("YAML file does not contain a document");
goto out_doc;
}
r = fatso_package_parse(&p->package, &doc, root, out_error_message);
out_doc:
yaml_document_delete(&doc);
out:
yaml_parser_delete(&parser);
fclose(fp);
return r;
}
int yaml_parser_set_input_filename(yaml_parser_t *parser, const char *filename)
{
FILE *in = fopen(filename, "r");
if (!in) return 0;
yaml_parser_set_input_file(parser, in);
return 1;
}
config_t load_config_yml(const char * filename, config_t conf) {
yaml_parser_t parser;
FILE * fcfg;
char path[CONF_STR];
memset(path, 0, CONF_STR);
sprintf(path, "%s", filename);
memset(&parser, 0, sizeof(parser));
config_t r = conf;
if (!yaml_parser_initialize(&parser)) {
yaml_parser_error(parser);
}
if ((fcfg = fopen(path, "r"))) {
plc_log("Looking for configuration from %s ...", path);
yaml_parser_set_input_file(&parser, fcfg);
r = process(CONF_ERR, &parser, conf);
if(r->err < CONF_OK)
plc_log( "Configuration error ");
fclose(fcfg);
} else {
r->err = CONF_ERR;
plc_log("Could not open file %s", filename);
}
yaml_parser_delete(&parser);
return r;
}
SEXP
R_readYAML(SEXP stream, SEXP isFile, SEXP simplify, SEXP nullValue, SEXP simplifyWithNames, SEXP encoding)
{
yaml_parser_t parser;
FILE *input = NULL;
SEXP ans = R_NilValue;
yaml_parser_initialize(&parser);
if(LOGICAL(isFile)[0]) {
input = fopen(CHAR(STRING_ELT(stream, 0)), "r");
yaml_parser_set_input_file(&parser, input);
} else {
yaml_parser_set_input(&parser, read_handler, NULL);
}
if(input)
fclose(input);
ans = processYAMLStream(&parser, INTEGER(simplify)[0], nullValue, INTEGER(simplifyWithNames)[0], INTEGER(encoding)[0]);
yaml_parser_delete(&parser);
if(!ans) {
PROBLEM "failed in yaml"
ERROR;
}
return(ans);
}
int mosaic_parse_config(const char *cfg, struct mosaic *m)
{
FILE *cfg_f;
yaml_parser_t parser;
int ret = -1;
cfg_f = fopen(cfg, "r");
if (!cfg_f) {
loge("%s: can't open %s: %m\n", __func__, cfg);
goto out;
}
if (!yaml_parser_initialize(&parser)) {
loge("%s: can't initialize yaml parser\n",
__func__);
goto out_c;
}
yaml_parser_set_input_file(&parser, cfg_f);
ret = yaml_parse_all(&parser, parse_config, m);
yaml_parser_delete(&parser);
out_c:
fclose(cfg_f);
out:
if (ret) {
loge("%s: Can't parse %s (ret=%d)\n", __func__, cfg, ret);
return -1;
}
if (!m->m_ops) {
loge("%s: Missing or unknown \"type\" in %s\n", __func__, cfg);
return -1;
}
return ret;
}
static rstatus_t
conf_yaml_init(struct conf *cf)
{
int rv;
ASSERT(!cf->valid_parser);
rv = fseek(cf->fh, 0L, SEEK_SET);
if (rv < 0) {
log_error("conf: failed to seek to the beginning of file '%s': %s",
cf->fname, strerror(errno));
return NC_ERROR;
}
rv = yaml_parser_initialize(&cf->parser);
if (!rv) {
log_error("conf: failed (err %d) to initialize yaml parser",
cf->parser.error);
return NC_ERROR;
}
yaml_parser_set_input_file(&cf->parser, cf->fh);
cf->valid_parser = 1;
return NC_OK;
}
int main (
int argc,
char *argv [])
{
FILE *fh = fopen("/etc/cpanel/ea4/php.conf", "r");
if( !fh )
fh = fopen("/etc/apache2/conf.d/php.conf.yaml", "r");
yaml_parser_t parser;
yaml_event_t event; /* 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);
/* START new code */
do {
if (!yaml_parser_parse(&parser, &event)) {
printf("Parser error %d\n", parser.error);
exit(EXIT_FAILURE);
}
switch(event.type)
{
case YAML_NO_EVENT: puts("No event!"); break;
/* Stream start/end */
case YAML_STREAM_START_EVENT: puts("STREAM START"); break;
case YAML_STREAM_END_EVENT: puts("STREAM END"); break;
/* Block delimeters */
case YAML_DOCUMENT_START_EVENT: puts("<b>Start Document</b>"); break;
case YAML_DOCUMENT_END_EVENT: puts("<b>End Document</b>"); break;
case YAML_SEQUENCE_START_EVENT: puts("<b>Start Sequence</b>"); break;
case YAML_SEQUENCE_END_EVENT: puts("<b>End Sequence</b>"); break;
case YAML_MAPPING_START_EVENT: puts("<b>Start Mapping</b>"); break;
case YAML_MAPPING_END_EVENT: puts("<b>End Mapping</b>"); break;
/* Data */
case YAML_ALIAS_EVENT: printf("Got alias (anchor %s)\n", event.data.alias.anchor); break;
case YAML_SCALAR_EVENT: printf("Got scalar (value %s)\n", event.data.scalar.value); break;
}
if(event.type != YAML_STREAM_END_EVENT)
yaml_event_delete(&event);
} while (event.type != YAML_STREAM_END_EVENT);
yaml_event_delete(&event);
/* END new code */
/* Cleanup */
yaml_parser_delete(&parser);
fclose(fh);
return 0;
}
int
main(int argc, char *argv[])
{
int number;
if (argc < 2) {
printf("Usage: %s file1.yaml ...\n", argv[0]);
return 0;
}
for (number = 1; number < argc; number ++)
{
FILE *file;
yaml_parser_t parser;
yaml_document_t document;
int done = 0;
int count = 0;
int error = 0;
printf("[%d] Loading '%s': ", number, argv[number]);
fflush(stdout);
file = fopen(argv[number], "rb");
assert(file);
assert(yaml_parser_initialize(&parser));
yaml_parser_set_input_file(&parser, file);
while (!done)
{
if (!yaml_parser_load(&parser, &document)) {
error = 1;
break;
}
done = (!yaml_document_get_root_node(&document));
yaml_document_delete(&document);
if (!done) count ++;
}
yaml_parser_delete(&parser);
assert(!fclose(file));
printf("%s (%d documents)\n", (error ? "FAILURE" : "SUCCESS"), count);
}
return 0;
}
int YamlCfgParser_ParseFile(struct CfgParser * apParser, const char *apFileName)
{
FILE *source = fopen(apFileName, "r");
if (source == NULL)
return -1;
assert(apParser != NULL);
yaml_parser_set_input_file(&apParser->parser, source);
process_yaml_parser(apParser);
fclose(source);
return 0;
}
FILE *init_parser(t_conf *conf, yaml_parser_t *parser,
char *filename)
{
FILE *fd;
fd = fopen(filename, "r");
init_conf(conf);
if (!yaml_parser_initialize(parser))
fputs("Failed to initialize parser!\n", stderr);
if (fd == NULL)
fputs("Failed to open file!\n", stderr);
yaml_parser_set_input_file(parser, fd);
return (fd);
}
int
main (int argc, char* argv[]) {
int number;
if (argc < 2) {
printf ("Usage: %s file1.yaml ...\n", argv[0]);
return 0;
}
for (number = 1; number < argc; number ++) {
FILE* file;
yaml_parser_t parser;
yaml_token_t token;
int done = 0;
int count = 0;
int error = 0;
printf ("[%d] Scanning '%s': ", number, argv[number]);
fflush (stdout);
file = fopen (argv[number], "rb");
assert (file);
assert (yaml_parser_initialize (&parser));
yaml_parser_set_input_file (&parser, file);
while (!done) {
if (!yaml_parser_scan (&parser, &token)) {
error = 1;
break;
}
done = (token.type == YAML_STREAM_END_TOKEN);
yaml_token_delete (&token);
count ++;
}
yaml_parser_delete (&parser);
assert (!fclose (file));
printf ("%s (%d tokens)\n", (error ? "FAILURE" : "SUCCESS"), count);
}
return 0;
}
bool
YamlDocument::load(char *fname)
{
FILE *fh = fopen(fname, "rb");
if(fh == NULL){
std::cerr << "Fail to open file: " << fname << std::endl;
return false;
}
if(!yaml_parser_initialize(&parser)){
std::cerr << "Fail to initialize parser." << std::endl;
fclose(fh);
return false;
}
yaml_parser_set_input_file(&parser, fh);
do{
yaml_parser_parse(&parser, &event);
switch(event.type){
case YAML_STREAM_START_EVENT:
break;
case YAML_STREAM_END_EVENT:
break;
case YAML_DOCUMENT_START_EVENT:
root = ParseYamlDoc();
break;
case YAML_DOCUMENT_END_EVENT:
break;
default:
std::cerr << "YAML Format error." << std::endl;
break;
}
if(event.type != YAML_STREAM_END_EVENT){
yaml_event_delete(&event);
}
}while(event.type != YAML_STREAM_END_EVENT);
yaml_event_delete(&event);
yaml_parser_delete(&parser);
fclose(fh);
return (root != NULL);
}
int YamlHelper::InitParser(const char* pPathname)
{
m_hFile = fopen(pPathname, "r");
if (m_hFile == NULL)
{
return 0;
}
if (!yaml_parser_initialize(&m_parser))
{
return 0;
}
yaml_parser_set_input_file(&m_parser, m_hFile);
return 1;
}
wb_configuration*
wb_read_config(wb_configuration *config, char *filename)
{
wb_config_parser_state state_static_alloc;
wb_config_parser_state *state = &state_static_alloc;
FILE *input = fopen(filename, "rb");
if (!input)
error("Reading configuration file %s failed", filename);
wb_config_parser_init(state);
yaml_parser_set_input_file(&(state->parser), input);
wb_read_main_config(state, config);
wb_config_parser_delete(state);
return config;
}
int main(void)
{
FILE *fh = fopen("c.yaml", "r");
yaml_parser_t parser;
/* 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);
/* CODE HERE */
/* Cleanup */
yaml_parser_delete(&parser);
fclose(fh);
return 0;
}
int load_documents(char *config_file_path) {
int rv = 0;
FILE *config_file = NULL;
yaml_parser_t parser;
yaml_document_t document;
config_file = fopen(config_file_path, "r");
if (config_file == NULL) {
printf("ERROR: failed to open file %s\n", config_file_path);
return ERR_FILE_OPEN_FAIL;
}
if (!yaml_parser_initialize(&parser)) {
printf("ERROR: failed to initialize YAML parser\n");
return ERR_YAML_INIT_FAIL;
}
yaml_parser_set_input_file(&parser, config_file);
int done = 0;
while (!done) {
if (!yaml_parser_load(&parser, &document)) {
printf("ERROR: failed to load document\n");
return ERR_DOC_LOAD_FAIL;
}
yaml_node_t *root_node = yaml_document_get_root_node(&document);
if (root_node == NULL) {
done = 1;
} else {
print_document(&document, root_node);
}
yaml_document_delete(&document);
}
yaml_parser_delete(&parser);
fclose(config_file);
return rv;
}
yoml_t *load_config(const char *fn)
{
FILE *fp;
yaml_parser_t parser;
yoml_t *yoml;
if ((fp = fopen(fn, "rb")) == NULL) {
fprintf(stderr, "could not open configuration file:%s:%s\n", fn, strerror(errno));
return NULL;
}
yaml_parser_initialize(&parser);
yaml_parser_set_input_file(&parser, fp);
yoml = yoml_parse_document(&parser, NULL);
if (yoml == NULL)
fprintf(stderr, "failed to parse configuration file:%s:%s\n", fn, parser.problem);
yaml_parser_delete(&parser);
return yoml;
}
bool DataLoader::load(const char* name, IObject* receiver) {
bool r = true;
clearCurrentName();
yaml_parser_initialize(&parser);
FILE *input = fopen(name, "rb");
yaml_parser_set_input_file(&parser, input);
int done = 0;
while (!done) {
if (!yaml_parser_parse(&parser, &event)) {
r = false;
}
if (!notify(receiver)) {
r = false;
}
if (!r) break;
done = (event.type == YAML_STREAM_END_EVENT);
yaml_event_delete(&event);
}
yaml_parser_delete(&parser);
fclose(input);
return r;
}
MapObject MapObject::processYaml(FILE* fh) {
int debug = 0;
#ifdef DEBUG
debug = 0;
#endif
MapObject yamlMap;
if (fh == NULL) {
yamlMap._type = MapObject::MAP_OBJ_FAILED;
if (debug)
fputs("Failed to open file!\n", stderr);
return yamlMap;
}
yaml_parser_t parser;
yaml_event_t event;
if (! yaml_parser_initialize(&parser)) {
yamlMap._type = MapObject::MAP_OBJ_FAILED;
if (debug)
fputs("Failed to initialize parser!\n", stderr);
return yamlMap;
}
yaml_parser_set_input_file(&parser, fh);
hardcoreYamlProcess(&yamlMap, &parser, &event);
yaml_event_delete(&event);
yaml_parser_delete(&parser);
fclose(fh);
return yamlMap;
}
int cloud_config_main(const gchar* filename) {
yaml_parser_t parser;
GList* handlers = NULL;
int i;
cloud_config_global_data = g_hash_table_new(g_str_hash, g_str_equal);
LOG("Parsing user data file %s\n", filename);
GNode* userdata = g_node_new(g_strdup(filename));
FILE* cloud_config_file = fopen(filename, "rb");
yaml_parser_initialize(&parser);
yaml_parser_set_input_file(&parser, cloud_config_file);
cloud_config_parse(&parser, userdata, 0);
yaml_parser_delete(&parser);
fclose(cloud_config_file);
g_node_traverse(userdata, G_POST_ORDER, G_TRAVERSE_ALL, -1, cloud_config_simplify, NULL);
cloud_config_dump(userdata);
/* built-in handlers */
for (i = 0; cc_module_structs[i] != NULL; ++i) {
LOG("Loaded handler for block \"%s\"\n", cc_module_structs[i]->name);
handlers = g_list_prepend(handlers, cc_module_structs[i]);
}
cloud_config_process(userdata, handlers);
g_node_traverse(userdata, G_POST_ORDER, G_TRAVERSE_ALL, -1, cloud_config_free, NULL);
g_node_destroy(userdata);
g_list_free(handlers);
g_hash_table_destroy(cloud_config_global_data);
return 0;
}
void moloch_rules_load(char **names)
{
int i;
// Make a copy of current items to free later
MolochRulesInfo_t *freeing = MOLOCH_TYPE_ALLOC0(MolochRulesInfo_t);
memcpy(freeing, ¤t, sizeof(current));
moloch_free_later(freeing, (GDestroyNotify) moloch_rules_free);
// Load all the rule files
for (i = 0; names[i]; i++) {
yaml_parser_t parser;
yaml_parser_initialize(&parser);
FILE *input = fopen(names[i], "rb");
if (!input)
LOGEXIT("ERROR - can not open rules file %s", names[i]);
yaml_parser_set_input_file(&parser, input);
YamlNode_t *parent = moloch_rules_parse_yaml(names[i], NULL, &parser, FALSE);
yaml_parser_delete(&parser);
if (!parent) {
LOG("WARNING %s - has no rules", names[i]);
continue;
}
#ifdef RULES_DEBUG
moloch_rules_parse_print(parent, 0);
#endif
moloch_rules_load_file(names[i], parent);
moloch_rules_free_node(parent);
fclose(input);
}
// Part 2, which will also copy loading to current
moloch_rules_load_complete();
}
struct config* parse_config(FILE *input) {
struct config *config = malloc(sizeof(struct config));
if (config == NULL) {
stats_error_log("malloc() error");
return NULL;
}
init_proto_config(&config->carbon_config);
if (config->carbon_config.ring == NULL) {
stats_error_log("failed to allocate ring");
free(config);
return NULL;
}
config->carbon_config.bind = strdup("127.0.0.1:2003");
init_proto_config(&config->statsd_config);
config->statsd_config.bind = strdup("127.0.0.1:8125");
yaml_parser_t parser;
yaml_event_t event;
if (!yaml_parser_initialize(&parser)) {
stats_log("failed to initialize yaml parser");
goto parse_err;
}
yaml_parser_set_input_file(&parser, input);
struct proto_config *protoc = NULL;
char *strval;
long numval;
int shard_count = -1;
int map_nesting = 0;
bool in_document = false;
bool keep_going = true;
bool is_key = false;
bool update_bind = false;
bool update_send_queue = false;
bool update_validate = false;
bool update_tcp_cork = false;
bool always_resolve_dns = false;
bool expect_shard_map = false;
while (keep_going) {
if (!yaml_parser_parse(&parser, &event)) {
goto parse_err;
}
switch(event.type) {
case YAML_NO_EVENT:
case YAML_STREAM_START_EVENT:
break; // nothing to do
case YAML_STREAM_END_EVENT:
keep_going = false;
break;
case YAML_DOCUMENT_START_EVENT:
if (in_document) {
stats_error_log("config should not have nested documents");
goto parse_err;
}
in_document = true;
break;
case YAML_DOCUMENT_END_EVENT:
in_document = false;
break;
case YAML_SEQUENCE_START_EVENT:
case YAML_SEQUENCE_END_EVENT:
stats_error_log("unexpectedly got sequence");
goto parse_err;
break;
case YAML_MAPPING_START_EVENT:
is_key = true;
map_nesting++;
break;
case YAML_MAPPING_END_EVENT:
map_nesting--;
break;
case YAML_ALIAS_EVENT:
stats_error_log("don't know how to handle yaml aliases");
goto parse_err;
break;
case YAML_SCALAR_EVENT:
strval = (char *) event.data.scalar.value;
switch (map_nesting) {
case 0:
stats_error_log("unexpectedly got scalar outside of a map");
goto parse_err;
break;
case 1:
if (strcmp(strval, "carbon") == 0) {
protoc = &config->carbon_config;
config->carbon_config.initialized = true;
} else if (strcmp(strval, "statsd") == 0) {
protoc = &config->statsd_config;
config->statsd_config.initialized = true;
} else {
stats_error_log("unexpectedly got map value: \"%s\"", strval);
goto parse_err;
}
break;
case 2:
if (is_key) {
if (strcmp(strval, "bind") == 0) {
update_bind = true;
} else if (strcmp(strval, "max_send_queue") == 0) {
update_send_queue = true;
} else if (strcmp(strval, "shard_map") == 0) {
shard_count = -1;
expect_shard_map = true;
} else if (strcmp(strval, "validate") == 0) {
update_validate = true;
} else if (strcmp(strval, "tcp_cork") == 0) {
update_tcp_cork = true;
} else if (strcmp(strval, "always_resolve_dns") == 0) {
always_resolve_dns = true;
}
} else {
if (update_bind) {
free(protoc->bind);
protoc->bind = strdup(strval);
update_bind = false;
} else if (update_send_queue) {
if (!convert_number(strval, &numval)) {
stats_error_log("max_send_queue was not a number: %s", strval);
}
protoc->max_send_queue = numval;
update_send_queue = false;
} else if (update_validate) {
if (!set_boolean(strval, &protoc->enable_validation)) {
goto parse_err;
}
update_validate = false;
} else if (update_tcp_cork) {
if (!set_boolean(strval, &protoc->enable_tcp_cork)) {
goto parse_err;
}
update_tcp_cork = false;
} else if (always_resolve_dns) {
if (!set_boolean(strval, &protoc->always_resolve_dns)) {
goto parse_err;
}
}
}
break;
case 3:
if (!expect_shard_map) {
stats_error_log("was not expecting shard map");
goto parse_err;
} else if (is_key) {
if (!convert_number(strval, &numval)) {
stats_error_log("shard key was not a number: \"%s\"", strval);
goto parse_err;
}
shard_count++;
if (numval != shard_count) {
stats_error_log("expected to see shard key %d, instead saw %d",
shard_count, numval);
goto parse_err;
}
} else {
if (statsrelay_list_expand(protoc->ring) == NULL) {
stats_error_log("unable to expand list");
goto parse_err;
}
if ((protoc->ring->data[protoc->ring->size - 1] = strdup(strval)) == NULL) {
stats_error_log("failed to copy string");
goto parse_err;
}
}
}
is_key = !is_key;
break;
default:
stats_error_log("unhandled yaml event");
goto parse_err;
}
yaml_event_delete(&event);
}
yaml_parser_delete(&parser);
return config;
parse_err:
destroy_config(config);
yaml_event_delete(&event);
yaml_parser_delete(&parser);
return NULL;
}
int
main(int argc, char *argv[])
{
int help = 0;
int canonical = 0;
int unicode = 0;
int k;
int done = 0;
yaml_parser_t parser;
yaml_emitter_t emitter;
yaml_event_t input_event;
yaml_document_t output_document;
int root;
/* Clear the objects. */
memset(&parser, 0, sizeof(parser));
memset(&emitter, 0, sizeof(emitter));
memset(&input_event, 0, sizeof(input_event));
memset(&output_document, 0, sizeof(output_document));
/* Analyze command line options. */
for (k = 1; k < argc; k ++)
{
if (strcmp(argv[k], "-h") == 0
|| strcmp(argv[k], "--help") == 0) {
help = 1;
}
else if (strcmp(argv[k], "-c") == 0
|| strcmp(argv[k], "--canonical") == 0) {
canonical = 1;
}
else if (strcmp(argv[k], "-u") == 0
|| strcmp(argv[k], "--unicode") == 0) {
unicode = 1;
}
else {
fprintf(stderr, "Unrecognized option: %s\n"
"Try `%s --help` for more information.\n",
argv[k], argv[0]);
return 1;
}
}
/* Display the help string. */
if (help)
{
printf("%s <input\n"
"or\n%s -h | --help\nDeconstruct a YAML stream\n\nOptions:\n"
"-h, --help\t\tdisplay this help and exit\n"
"-c, --canonical\t\toutput in the canonical YAML format\n"
"-u, --unicode\t\toutput unescaped non-ASCII characters\n",
argv[0], argv[0]);
return 0;
}
/* Initialize the parser and emitter objects. */
if (!yaml_parser_initialize(&parser)) {
fprintf(stderr, "Could not initialize the parser object\n");
return 1;
}
if (!yaml_emitter_initialize(&emitter)) {
yaml_parser_delete(&parser);
fprintf(stderr, "Could not inialize the emitter object\n");
return 1;
}
/* Set the parser parameters. */
yaml_parser_set_input_file(&parser, stdin);
/* Set the emitter parameters. */
yaml_emitter_set_output_file(&emitter, stdout);
yaml_emitter_set_canonical(&emitter, canonical);
yaml_emitter_set_unicode(&emitter, unicode);
/* Create and emit the STREAM-START event. */
if (!yaml_emitter_open(&emitter))
goto emitter_error;
/* Create a output_document object. */
if (!yaml_document_initialize(&output_document, NULL, NULL, NULL, 0, 0))
goto document_error;
/* Create the root sequence. */
root = yaml_document_add_sequence(&output_document, NULL,
YAML_BLOCK_SEQUENCE_STYLE);
if (!root) goto document_error;
/* Loop through the input events. */
while (!done)
{
int properties, key, value, map, seq;
/* Get the next event. */
if (!yaml_parser_parse(&parser, &input_event))
goto parser_error;
/* Check if this is the stream end. */
if (input_event.type == YAML_STREAM_END_EVENT) {
done = 1;
}
/* Create a mapping node and attach it to the root sequence. */
properties = yaml_document_add_mapping(&output_document, NULL,
YAML_BLOCK_MAPPING_STYLE);
if (!properties) goto document_error;
if (!yaml_document_append_sequence_item(&output_document,
root, properties)) goto document_error;
/* Analyze the event. */
switch (input_event.type)
{
case YAML_STREAM_START_EVENT:
/* Add 'type': 'STREAM-START'. */
key = yaml_document_add_scalar(&output_document, NULL,
"type", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, NULL,
"STREAM-START", -1, YAML_PLAIN_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, value)) goto document_error;
/* Add 'encoding': <encoding>. */
if (input_event.data.stream_start.encoding)
{
yaml_encoding_t encoding
= input_event.data.stream_start.encoding;
key = yaml_document_add_scalar(&output_document, NULL,
"encoding", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, NULL,
(encoding == YAML_UTF8_ENCODING ? "utf-8" :
encoding == YAML_UTF16LE_ENCODING ? "utf-16-le" :
encoding == YAML_UTF16BE_ENCODING ? "utf-16-be" :
"unknown"), -1, YAML_PLAIN_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, value)) goto document_error;
}
break;
case YAML_STREAM_END_EVENT:
/* Add 'type': 'STREAM-END'. */
key = yaml_document_add_scalar(&output_document, NULL,
"type", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, NULL,
"STREAM-END", -1, YAML_PLAIN_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, value)) goto document_error;
break;
case YAML_DOCUMENT_START_EVENT:
/* Add 'type': 'DOCUMENT-START'. */
key = yaml_document_add_scalar(&output_document, NULL,
"type", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, NULL,
"DOCUMENT-START", -1, YAML_PLAIN_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, value)) goto document_error;
/* Display the output_document version numbers. */
if (input_event.data.document_start.version_directive)
{
yaml_version_directive_t *version
= input_event.data.document_start.version_directive;
char number[64];
/* Add 'version': {}. */
key = yaml_document_add_scalar(&output_document, NULL,
"version", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
map = yaml_document_add_mapping(&output_document, NULL,
YAML_FLOW_MAPPING_STYLE);
if (!map) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, map)) goto document_error;
/* Add 'major': <number>. */
key = yaml_document_add_scalar(&output_document, NULL,
"major", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
sprintf(number, "%d", version->major);
value = yaml_document_add_scalar(&output_document, YAML_INT_TAG,
number, -1, YAML_PLAIN_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
map, key, value)) goto document_error;
/* Add 'minor': <number>. */
key = yaml_document_add_scalar(&output_document, NULL,
"minor", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
sprintf(number, "%d", version->minor);
value = yaml_document_add_scalar(&output_document, YAML_INT_TAG,
number, -1, YAML_PLAIN_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
map, key, value)) goto document_error;
}
/* Display the output_document tag directives. */
if (input_event.data.document_start.tag_directives.start
!= input_event.data.document_start.tag_directives.end)
{
yaml_tag_directive_t *tag;
/* Add 'tags': []. */
key = yaml_document_add_scalar(&output_document, NULL,
"tags", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
seq = yaml_document_add_sequence(&output_document, NULL,
YAML_BLOCK_SEQUENCE_STYLE);
if (!seq) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, seq)) goto document_error;
for (tag = input_event.data.document_start.tag_directives.start;
tag != input_event.data.document_start.tag_directives.end;
tag ++)
{
/* Add {}. */
map = yaml_document_add_mapping(&output_document, NULL,
YAML_FLOW_MAPPING_STYLE);
if (!map) goto document_error;
if (!yaml_document_append_sequence_item(&output_document,
seq, map)) goto document_error;
/* Add 'handle': <handle>. */
key = yaml_document_add_scalar(&output_document, NULL,
"handle", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, NULL,
tag->handle, -1, YAML_DOUBLE_QUOTED_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
map, key, value)) goto document_error;
/* Add 'prefix': <prefix>. */
key = yaml_document_add_scalar(&output_document, NULL,
"prefix", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, NULL,
tag->prefix, -1, YAML_DOUBLE_QUOTED_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
map, key, value)) goto document_error;
}
}
/* Add 'implicit': <flag>. */
key = yaml_document_add_scalar(&output_document, NULL,
"implicit", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, YAML_BOOL_TAG,
(input_event.data.document_start.implicit ?
"true" : "false"), -1, YAML_PLAIN_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, value)) goto document_error;
break;
case YAML_DOCUMENT_END_EVENT:
/* Add 'type': 'DOCUMENT-END'. */
key = yaml_document_add_scalar(&output_document, NULL,
"type", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, NULL,
"DOCUMENT-END", -1, YAML_PLAIN_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, value)) goto document_error;
/* Add 'implicit': <flag>. */
key = yaml_document_add_scalar(&output_document, NULL,
"implicit", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, YAML_BOOL_TAG,
(input_event.data.document_end.implicit ?
"true" : "false"), -1, YAML_PLAIN_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, value)) goto document_error;
break;
case YAML_ALIAS_EVENT:
/* Add 'type': 'ALIAS'. */
key = yaml_document_add_scalar(&output_document, NULL,
"type", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, NULL,
"ALIAS", -1, YAML_PLAIN_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, value)) goto document_error;
/* Add 'anchor': <anchor>. */
key = yaml_document_add_scalar(&output_document, NULL,
"anchor", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, NULL,
input_event.data.alias.anchor, -1,
YAML_DOUBLE_QUOTED_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, value)) goto document_error;
break;
case YAML_SCALAR_EVENT:
/* Add 'type': 'SCALAR'. */
key = yaml_document_add_scalar(&output_document, NULL,
"type", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, NULL,
"SCALAR", -1, YAML_PLAIN_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, value)) goto document_error;
/* Add 'anchor': <anchor>. */
if (input_event.data.scalar.anchor)
{
key = yaml_document_add_scalar(&output_document, NULL,
"anchor", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, NULL,
input_event.data.scalar.anchor, -1,
YAML_DOUBLE_QUOTED_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, value)) goto document_error;
}
/* Add 'tag': <tag>. */
if (input_event.data.scalar.tag)
{
key = yaml_document_add_scalar(&output_document, NULL,
"tag", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, NULL,
input_event.data.scalar.tag, -1,
YAML_DOUBLE_QUOTED_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, value)) goto document_error;
}
/* Add 'value': <value>. */
key = yaml_document_add_scalar(&output_document, NULL,
"value", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, NULL,
input_event.data.scalar.value,
input_event.data.scalar.length,
YAML_DOUBLE_QUOTED_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, value)) goto document_error;
/* Display if the scalar tag is implicit. */
/* Add 'implicit': {} */
key = yaml_document_add_scalar(&output_document, NULL,
"version", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
map = yaml_document_add_mapping(&output_document, NULL,
YAML_FLOW_MAPPING_STYLE);
if (!map) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, map)) goto document_error;
/* Add 'plain': <flag>. */
key = yaml_document_add_scalar(&output_document, NULL,
"plain", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, YAML_BOOL_TAG,
(input_event.data.scalar.plain_implicit ?
"true" : "false"), -1, YAML_PLAIN_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
map, key, value)) goto document_error;
/* Add 'quoted': <flag>. */
key = yaml_document_add_scalar(&output_document, NULL,
"quoted", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, YAML_BOOL_TAG,
(input_event.data.scalar.quoted_implicit ?
"true" : "false"), -1, YAML_PLAIN_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
map, key, value)) goto document_error;
/* Display the style information. */
if (input_event.data.scalar.style)
{
yaml_scalar_style_t style = input_event.data.scalar.style;
/* Add 'style': <style>. */
key = yaml_document_add_scalar(&output_document, NULL,
"style", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, NULL,
(style == YAML_PLAIN_SCALAR_STYLE ? "plain" :
style == YAML_SINGLE_QUOTED_SCALAR_STYLE ?
"single-quoted" :
style == YAML_DOUBLE_QUOTED_SCALAR_STYLE ?
"double-quoted" :
style == YAML_LITERAL_SCALAR_STYLE ? "literal" :
style == YAML_FOLDED_SCALAR_STYLE ? "folded" :
"unknown"), -1, YAML_PLAIN_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, value)) goto document_error;
}
break;
case YAML_SEQUENCE_START_EVENT:
/* Add 'type': 'SEQUENCE-START'. */
key = yaml_document_add_scalar(&output_document, NULL,
"type", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, NULL,
"SEQUENCE-START", -1, YAML_PLAIN_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, value)) goto document_error;
/* Add 'anchor': <anchor>. */
if (input_event.data.sequence_start.anchor)
{
key = yaml_document_add_scalar(&output_document, NULL,
"anchor", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, NULL,
input_event.data.sequence_start.anchor, -1,
YAML_DOUBLE_QUOTED_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, value)) goto document_error;
}
/* Add 'tag': <tag>. */
if (input_event.data.sequence_start.tag)
{
key = yaml_document_add_scalar(&output_document, NULL,
"tag", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, NULL,
input_event.data.sequence_start.tag, -1,
YAML_DOUBLE_QUOTED_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, value)) goto document_error;
}
/* Add 'implicit': <flag>. */
key = yaml_document_add_scalar(&output_document, NULL,
"implicit", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, YAML_BOOL_TAG,
(input_event.data.sequence_start.implicit ?
"true" : "false"), -1, YAML_PLAIN_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, value)) goto document_error;
/* Display the style information. */
if (input_event.data.sequence_start.style)
{
yaml_sequence_style_t style
= input_event.data.sequence_start.style;
/* Add 'style': <style>. */
key = yaml_document_add_scalar(&output_document, NULL,
"style", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, NULL,
(style == YAML_BLOCK_SEQUENCE_STYLE ? "block" :
style == YAML_FLOW_SEQUENCE_STYLE ? "flow" :
"unknown"), -1, YAML_PLAIN_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, value)) goto document_error;
}
break;
case YAML_SEQUENCE_END_EVENT:
/* Add 'type': 'SEQUENCE-END'. */
key = yaml_document_add_scalar(&output_document, NULL,
"type", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, NULL,
"SEQUENCE-END", -1, YAML_PLAIN_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, value)) goto document_error;
break;
case YAML_MAPPING_START_EVENT:
/* Add 'type': 'MAPPING-START'. */
key = yaml_document_add_scalar(&output_document, NULL,
"type", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, NULL,
"MAPPING-START", -1, YAML_PLAIN_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, value)) goto document_error;
/* Add 'anchor': <anchor>. */
if (input_event.data.mapping_start.anchor)
{
key = yaml_document_add_scalar(&output_document, NULL,
"anchor", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, NULL,
input_event.data.mapping_start.anchor, -1,
YAML_DOUBLE_QUOTED_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, value)) goto document_error;
}
/* Add 'tag': <tag>. */
if (input_event.data.mapping_start.tag)
{
key = yaml_document_add_scalar(&output_document, NULL,
"tag", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, NULL,
input_event.data.mapping_start.tag, -1,
YAML_DOUBLE_QUOTED_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, value)) goto document_error;
}
/* Add 'implicit': <flag>. */
key = yaml_document_add_scalar(&output_document, NULL,
"implicit", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, YAML_BOOL_TAG,
(input_event.data.mapping_start.implicit ?
"true" : "false"), -1, YAML_PLAIN_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, value)) goto document_error;
/* Display the style information. */
if (input_event.data.sequence_start.style)
{
yaml_sequence_style_t style
= input_event.data.mapping_start.style;
/* Add 'style': <style>. */
key = yaml_document_add_scalar(&output_document, NULL,
"style", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, NULL,
(style == YAML_BLOCK_MAPPING_STYLE ? "block" :
style == YAML_FLOW_MAPPING_STYLE ? "flow" :
"unknown"), -1, YAML_PLAIN_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, value)) goto document_error;
}
break;
case YAML_MAPPING_END_EVENT:
/* Add 'type': 'MAPPING-END'. */
key = yaml_document_add_scalar(&output_document, NULL,
"type", -1, YAML_PLAIN_SCALAR_STYLE);
if (!key) goto document_error;
value = yaml_document_add_scalar(&output_document, NULL,
"MAPPING-END", -1, YAML_PLAIN_SCALAR_STYLE);
if (!value) goto document_error;
if (!yaml_document_append_mapping_pair(&output_document,
properties, key, value)) goto document_error;
break;
default:
/* It couldn't really happen. */
break;
}
/* Delete the event object. */
yaml_event_delete(&input_event);
}
if (!yaml_emitter_dump(&emitter, &output_document))
goto emitter_error;
if (!yaml_emitter_close(&emitter))
goto emitter_error;
yaml_parser_delete(&parser);
yaml_emitter_delete(&emitter);
return 0;
parser_error:
/* Display a parser error message. */
switch (parser.error)
{
case YAML_MEMORY_ERROR:
fprintf(stderr, "Memory error: Not enough memory for parsing\n");
break;
case YAML_READER_ERROR:
if (parser.problem_value != -1) {
fprintf(stderr, "Reader error: %s: #%X at %zd\n", parser.problem,
parser.problem_value, parser.problem_offset);
}
else {
fprintf(stderr, "Reader error: %s at %zd\n", parser.problem,
parser.problem_offset);
}
break;
case YAML_SCANNER_ERROR:
if (parser.context) {
fprintf(stderr, "Scanner error: %s at line %lu, column %lu\n"
"%s at line %lu, column %lu\n", parser.context,
parser.context_mark.line+1, parser.context_mark.column+1,
parser.problem, parser.problem_mark.line+1,
parser.problem_mark.column+1);
}
else {
fprintf(stderr, "Scanner error: %s at line %lu, column %lu\n",
parser.problem, parser.problem_mark.line+1,
parser.problem_mark.column+1);
}
break;
case YAML_PARSER_ERROR:
if (parser.context) {
fprintf(stderr, "Parser error: %s at line %lu, column %lu\n"
"%s at line %lu, column %lu\n", parser.context,
parser.context_mark.line+1, parser.context_mark.column+1,
parser.problem, parser.problem_mark.line+1,
parser.problem_mark.column+1);
}
else {
fprintf(stderr, "Parser error: %s at line %lu, column %lu\n",
parser.problem, parser.problem_mark.line+1,
parser.problem_mark.column+1);
}
break;
default:
/* Couldn't happen. */
fprintf(stderr, "Internal error\n");
break;
}
yaml_event_delete(&input_event);
yaml_document_delete(&output_document);
yaml_parser_delete(&parser);
yaml_emitter_delete(&emitter);
return 1;
emitter_error:
/* Display an emitter error message. */
switch (emitter.error)
{
case YAML_MEMORY_ERROR:
fprintf(stderr, "Memory error: Not enough memory for emitting\n");
break;
case YAML_WRITER_ERROR:
fprintf(stderr, "Writer error: %s\n", emitter.problem);
break;
case YAML_EMITTER_ERROR:
fprintf(stderr, "Emitter error: %s\n", emitter.problem);
break;
default:
/* Couldn't happen. */
fprintf(stderr, "Internal error\n");
break;
}
yaml_event_delete(&input_event);
yaml_document_delete(&output_document);
yaml_parser_delete(&parser);
yaml_emitter_delete(&emitter);
return 1;
document_error:
fprintf(stderr, "Memory error: Not enough memory for creating a document\n");
yaml_event_delete(&input_event);
yaml_document_delete(&output_document);
yaml_parser_delete(&parser);
yaml_emitter_delete(&emitter);
return 1;
}
bool _load_drop_config_from_yaml_file(char *path, entity_t *entity) {
yaml_parser_t parser;
yaml_event_t event;
FILE *input;
char *currentKey = NULL;
drop_t *drop_data = (drop_t *)entity->entity_data;
yaml_parser_initialize(&parser);
input = fopen(path, "rb");
if (input == NULL) {
goto error;
}
yaml_parser_set_input_file(&parser, input);
do {
int handledValue = 0;
if (!yaml_parser_parse(&parser, &event)) {
break;
}
switch (event.type) {
case YAML_SCALAR_EVENT:
if (!currentKey) {
char *aKey = (char *)event.data.scalar.value;
int length = (strlen(aKey) + 1);
currentKey = malloc(length * sizeof(char));
strncpy(currentKey, aKey, length);
currentKey[length - 1] = '\0';
}
else {
if (strcmp(currentKey, "name") == 0) {
snprintf(entity->class_name, ENTITY_CLASS_NAME_LENGTH, "drop:%s", event.data.scalar.value);
}
else if (strcmp(currentKey, "sprite") == 0) {
char *spriteFile = (char *)event.data.scalar.value;
drop_data->sprite = animated_sprite_create(spriteFile);
animated_sprite_set_current_animation(drop_data->sprite, "idle");
}
else if (strcmp(currentKey, "target") == 0) {
drop_data->target = atoi((char *)event.data.scalar.value);
}
else if (strcmp(currentKey, "bounding_box") == 0) {
int x, y, width, height;
sscanf((char *)event.data.scalar.value, "%i,%i,%i,%i", &x, &y, &width, &height);
entity->bounding_box = graphics_rect_make(x, y, width, height);
}
handledValue = 1;
}
break;
default:
break;
}
if (handledValue) {
free(currentKey);
currentKey = NULL;
handledValue = 0;
}
if (event.type != YAML_STREAM_END_EVENT) {
yaml_event_delete(&event);
}
} while (event.type != YAML_STREAM_END_EVENT);
yaml_event_delete(&event);
yaml_parser_delete(&parser);
fclose(input);
return true;
error:
yaml_event_delete(&event);
yaml_parser_delete(&parser);
fclose(input);
return false;
}
int
main(int argc, char *argv[])
{
int help = 0;
int canonical = 0;
int unicode = 0;
int k;
int done = 0;
yaml_parser_t parser;
yaml_emitter_t emitter;
yaml_event_t input_event;
yaml_event_t output_event;
/* Clear the objects. */
memset(&parser, 0, sizeof(parser));
memset(&emitter, 0, sizeof(emitter));
memset(&input_event, 0, sizeof(input_event));
memset(&output_event, 0, sizeof(output_event));
/* Analyze command line options. */
for (k = 1; k < argc; k ++)
{
if (strcmp(argv[k], "-h") == 0
|| strcmp(argv[k], "--help") == 0) {
help = 1;
}
else if (strcmp(argv[k], "-c") == 0
|| strcmp(argv[k], "--canonical") == 0) {
canonical = 1;
}
else if (strcmp(argv[k], "-u") == 0
|| strcmp(argv[k], "--unicode") == 0) {
unicode = 1;
}
else {
fprintf(stderr, "Unrecognized option: %s\n"
"Try `%s --help` for more information.\n",
argv[k], argv[0]);
return 1;
}
}
/* Display the help string. */
if (help)
{
printf("%s <input\n"
"or\n%s -h | --help\nDeconstruct a YAML stream\n\nOptions:\n"
"-h, --help\t\tdisplay this help and exit\n"
"-c, --canonical\t\toutput in the canonical YAML format\n"
"-u, --unicode\t\toutput unescaped non-ASCII characters\n",
argv[0], argv[0]);
return 0;
}
/* Initialize the parser and emitter objects. */
if (!yaml_parser_initialize(&parser)) {
fprintf(stderr, "Could not initialize the parser object\n");
return 1;
}
if (!yaml_emitter_initialize(&emitter)) {
yaml_parser_delete(&parser);
fprintf(stderr, "Could not inialize the emitter object\n");
return 1;
}
/* Set the parser parameters. */
yaml_parser_set_input_file(&parser, stdin);
/* Set the emitter parameters. */
yaml_emitter_set_output_file(&emitter, stdout);
yaml_emitter_set_canonical(&emitter, canonical);
yaml_emitter_set_unicode(&emitter, unicode);
/* Create and emit the STREAM-START event. */
if (!yaml_stream_start_event_initialize(&output_event, YAML_UTF8_ENCODING))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Create and emit the DOCUMENT-START event. */
if (!yaml_document_start_event_initialize(&output_event,
NULL, NULL, NULL, 0))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Create and emit the SEQUENCE-START event. */
if (!yaml_sequence_start_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:seq", 1,
YAML_BLOCK_SEQUENCE_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Loop through the input events. */
while (!done)
{
/* Get the next event. */
if (!yaml_parser_parse(&parser, &input_event))
goto parser_error;
/* Check if this is the stream end. */
if (input_event.type == YAML_STREAM_END_EVENT) {
done = 1;
}
/* Create and emit a MAPPING-START event. */
if (!yaml_mapping_start_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:map", 1,
YAML_BLOCK_MAPPING_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Analyze the event. */
switch (input_event.type)
{
case YAML_STREAM_START_EVENT:
/* Write 'type'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "type", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write 'STREAM-START'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "STREAM-START", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Display encoding information. */
if (input_event.data.stream_start.encoding)
{
yaml_encoding_t encoding
= input_event.data.stream_start.encoding;
/* Write 'encoding'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "encoding", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write the stream encoding. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str",
(encoding == YAML_UTF8_ENCODING ? "utf-8" :
encoding == YAML_UTF16LE_ENCODING ? "utf-16-le" :
encoding == YAML_UTF16BE_ENCODING ? "utf-16-be" :
"unknown"), -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
}
break;
case YAML_STREAM_END_EVENT:
/* Write 'type'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "type", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write 'STREAM-END'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "STREAM-END", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
break;
case YAML_DOCUMENT_START_EVENT:
/* Write 'type'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "type", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write 'DOCUMENT-START'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "DOCUMENT-START", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Display the document version numbers. */
if (input_event.data.document_start.version_directive)
{
yaml_version_directive_t *version
= input_event.data.document_start.version_directive;
char number[64];
/* Write 'version'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "version", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write '{'. */
if (!yaml_mapping_start_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:map", 1,
YAML_FLOW_MAPPING_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write 'major'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "major", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write a number. */
sprintf(number, "%d", version->major);
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:int", number, -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write 'minor'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "minor", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write a number. */
sprintf(number, "%d", version->minor);
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:int", number, -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write '}'. */
if (!yaml_mapping_end_event_initialize(&output_event))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
}
/* Display the document tag directives. */
if (input_event.data.document_start.tag_directives.start
!= input_event.data.document_start.tag_directives.end)
{
yaml_tag_directive_t *tag;
/* Write 'tags'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "tags", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Start a block sequence. */
if (!yaml_sequence_start_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:seq", 1,
YAML_BLOCK_SEQUENCE_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
for (tag = input_event.data.document_start.tag_directives.start;
tag != input_event.data.document_start.tag_directives.end;
tag ++)
{
/* Write '{'. */
if (!yaml_mapping_start_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:map", 1,
YAML_FLOW_MAPPING_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write 'handle'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "handle", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write the tag directive handle. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str",
tag->handle, -1,
0, 1, YAML_DOUBLE_QUOTED_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write 'prefix'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "prefix", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write the tag directive prefix. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str",
tag->prefix, -1,
0, 1, YAML_DOUBLE_QUOTED_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write '}'. */
if (!yaml_mapping_end_event_initialize(&output_event))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
}
/* End a block sequence. */
if (!yaml_sequence_end_event_initialize(&output_event))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
}
/* Write 'implicit'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "implicit", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write if the document is implicit. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:bool",
(input_event.data.document_start.implicit ?
"true" : "false"), -1,
1, 0, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
break;
case YAML_DOCUMENT_END_EVENT:
/* Write 'type'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "type", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write 'DOCUMENT-END'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "DOCUMENT-END", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write 'implicit'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "implicit", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write if the document is implicit. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:bool",
(input_event.data.document_end.implicit ?
"true" : "false"), -1,
1, 0, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
break;
case YAML_ALIAS_EVENT:
/* Write 'type'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "type", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write 'ALIAS'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "ALIAS", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write 'anchor'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "anchor", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write the alias anchor. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str",
input_event.data.alias.anchor, -1,
0, 1, YAML_DOUBLE_QUOTED_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
break;
case YAML_SCALAR_EVENT:
/* Write 'type'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "type", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write 'SCALAR'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "SCALAR", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Display the scalar anchor. */
if (input_event.data.scalar.anchor)
{
/* Write 'anchor'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "anchor", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write the scalar anchor. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str",
input_event.data.scalar.anchor, -1,
0, 1, YAML_DOUBLE_QUOTED_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
}
/* Display the scalar tag. */
if (input_event.data.scalar.tag)
{
/* Write 'tag'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "tag", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write the scalar tag. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str",
input_event.data.scalar.tag, -1,
0, 1, YAML_DOUBLE_QUOTED_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
}
/* Display the scalar value. */
/* Write 'value'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "value", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write the scalar value. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str",
input_event.data.scalar.value,
input_event.data.scalar.length,
0, 1, YAML_DOUBLE_QUOTED_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Display if the scalar tag is implicit. */
/* Write 'implicit'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "implicit", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write '{'. */
if (!yaml_mapping_start_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:map", 1,
YAML_FLOW_MAPPING_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write 'plain'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "plain", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write if the scalar is implicit in the plain style. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:bool",
(input_event.data.scalar.plain_implicit ?
"true" : "false"), -1,
1, 0, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write 'quoted'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "non-plain", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write if the scalar is implicit in a non-plain style. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:bool",
(input_event.data.scalar.quoted_implicit ?
"true" : "false"), -1,
1, 0, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write '}'. */
if (!yaml_mapping_end_event_initialize(&output_event))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Display the style information. */
if (input_event.data.scalar.style)
{
yaml_scalar_style_t style = input_event.data.scalar.style;
/* Write 'style'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "style", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write the scalar style. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str",
(style == YAML_PLAIN_SCALAR_STYLE ? "plain" :
style == YAML_SINGLE_QUOTED_SCALAR_STYLE ?
"single-quoted" :
style == YAML_DOUBLE_QUOTED_SCALAR_STYLE ?
"double-quoted" :
style == YAML_LITERAL_SCALAR_STYLE ? "literal" :
style == YAML_FOLDED_SCALAR_STYLE ? "folded" :
"unknown"), -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
}
break;
case YAML_SEQUENCE_START_EVENT:
/* Write 'type'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "type", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write 'SEQUENCE-START'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "SEQUENCE-START", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Display the sequence anchor. */
if (input_event.data.sequence_start.anchor)
{
/* Write 'anchor'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "anchor", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write the sequence anchor. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str",
input_event.data.sequence_start.anchor, -1,
0, 1, YAML_DOUBLE_QUOTED_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
}
/* Display the sequence tag. */
if (input_event.data.sequence_start.tag)
{
/* Write 'tag'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "tag", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write the sequence tag. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str",
input_event.data.sequence_start.tag, -1,
0, 1, YAML_DOUBLE_QUOTED_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
}
/* Write 'implicit'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "implicit", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write if the sequence tag is implicit. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:bool",
(input_event.data.sequence_start.implicit ?
"true" : "false"), -1,
1, 0, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Display the style information. */
if (input_event.data.sequence_start.style)
{
yaml_sequence_style_t style
= input_event.data.sequence_start.style;
/* Write 'style'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "style", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write the scalar style. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str",
(style == YAML_BLOCK_SEQUENCE_STYLE ? "block" :
style == YAML_FLOW_SEQUENCE_STYLE ? "flow" :
"unknown"), -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
}
break;
case YAML_SEQUENCE_END_EVENT:
/* Write 'type'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "type", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write 'SEQUENCE-END'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "SEQUENCE-END", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
break;
case YAML_MAPPING_START_EVENT:
/* Write 'type'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "type", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write 'MAPPING-START'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "MAPPING-START", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Display the mapping anchor. */
if (input_event.data.mapping_start.anchor)
{
/* Write 'anchor'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "anchor", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write the mapping anchor. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str",
input_event.data.mapping_start.anchor, -1,
0, 1, YAML_DOUBLE_QUOTED_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
}
/* Display the mapping tag. */
if (input_event.data.mapping_start.tag)
{
/* Write 'tag'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "tag", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write the mapping tag. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str",
input_event.data.mapping_start.tag, -1,
0, 1, YAML_DOUBLE_QUOTED_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
}
/* Write 'implicit'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "implicit", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write if the mapping tag is implicit. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:bool",
(input_event.data.mapping_start.implicit ?
"true" : "false"), -1,
1, 0, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Display the style information. */
if (input_event.data.mapping_start.style)
{
yaml_mapping_style_t style
= input_event.data.mapping_start.style;
/* Write 'style'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "style", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write the scalar style. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str",
(style == YAML_BLOCK_MAPPING_STYLE ? "block" :
style == YAML_FLOW_MAPPING_STYLE ? "flow" :
"unknown"), -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
}
break;
case YAML_MAPPING_END_EVENT:
/* Write 'type'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "type", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Write 'MAPPING-END'. */
if (!yaml_scalar_event_initialize(&output_event,
NULL, "tag:yaml.org,2002:str", "MAPPING-END", -1,
1, 1, YAML_PLAIN_SCALAR_STYLE))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
break;
default:
/* It couldn't really happen. */
break;
}
/* Delete the event object. */
yaml_event_delete(&input_event);
/* Create and emit a MAPPING-END event. */
if (!yaml_mapping_end_event_initialize(&output_event))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
}
/* Create and emit the SEQUENCE-END event. */
if (!yaml_sequence_end_event_initialize(&output_event))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Create and emit the DOCUMENT-END event. */
if (!yaml_document_end_event_initialize(&output_event, 0))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
/* Create and emit the STREAM-END event. */
if (!yaml_stream_end_event_initialize(&output_event))
goto event_error;
if (!yaml_emitter_emit(&emitter, &output_event))
goto emitter_error;
yaml_parser_delete(&parser);
yaml_emitter_delete(&emitter);
return 0;
parser_error:
/* Display a parser error message. */
switch (parser.error)
{
case YAML_MEMORY_ERROR:
fprintf(stderr, "Memory error: Not enough memory for parsing\n");
break;
case YAML_READER_ERROR:
if (parser.problem_value != -1) {
fprintf(stderr, "Reader error: %s: #%X at %d\n", parser.problem,
parser.problem_value, parser.problem_offset);
}
else {
fprintf(stderr, "Reader error: %s at %d\n", parser.problem,
parser.problem_offset);
}
break;
case YAML_SCANNER_ERROR:
if (parser.context) {
fprintf(stderr, "Scanner error: %s at line %d, column %d\n"
"%s at line %d, column %d\n", parser.context,
parser.context_mark.line+1, parser.context_mark.column+1,
parser.problem, parser.problem_mark.line+1,
parser.problem_mark.column+1);
}
else {
fprintf(stderr, "Scanner error: %s at line %d, column %d\n",
parser.problem, parser.problem_mark.line+1,
parser.problem_mark.column+1);
}
break;
case YAML_PARSER_ERROR:
if (parser.context) {
fprintf(stderr, "Parser error: %s at line %d, column %d\n"
"%s at line %d, column %d\n", parser.context,
parser.context_mark.line+1, parser.context_mark.column+1,
parser.problem, parser.problem_mark.line+1,
parser.problem_mark.column+1);
}
else {
fprintf(stderr, "Parser error: %s at line %d, column %d\n",
parser.problem, parser.problem_mark.line+1,
parser.problem_mark.column+1);
}
break;
default:
/* Couldn't happen. */
fprintf(stderr, "Internal error\n");
break;
}
yaml_event_delete(&input_event);
yaml_event_delete(&output_event);
yaml_parser_delete(&parser);
yaml_emitter_delete(&emitter);
return 1;
emitter_error:
/* Display an emitter error message. */
switch (emitter.error)
{
case YAML_MEMORY_ERROR:
fprintf(stderr, "Memory error: Not enough memory for emitting\n");
break;
case YAML_WRITER_ERROR:
fprintf(stderr, "Writer error: %s\n", emitter.problem);
break;
case YAML_EMITTER_ERROR:
fprintf(stderr, "Emitter error: %s\n", emitter.problem);
break;
default:
/* Couldn't happen. */
fprintf(stderr, "Internal error\n");
break;
}
yaml_event_delete(&input_event);
yaml_event_delete(&output_event);
yaml_parser_delete(&parser);
yaml_emitter_delete(&emitter);
return 1;
event_error:
fprintf(stderr, "Memory error: Not enough memory for creating an event\n");
yaml_event_delete(&input_event);
yaml_event_delete(&output_event);
yaml_parser_delete(&parser);
yaml_emitter_delete(&emitter);
return 1;
}
int
stage1_parse(struct streamstate* stp, FILE* file, int verbose)
{
int rc = 0;
int done = 0;
int error = 0;
rc = yaml_parser_initialize(&stp->parser);
if (! rc)
return error_parser_initialize_failed(stp);
yaml_parser_set_input_file(&stp->parser, file);
while (!done)
{
rc = yaml_parser_parse(&stp->parser, &stp->event);
if (!rc)
{
error = error_parser_parse_failed(stp);
break;
}
if (verbose)
debug_event_type(&stp->event);
rc = 0;
switch (stp->event.type)
{
case YAML_STREAM_START_EVENT:
if (stp->stream_start)
rc = error_invalid_stream_start(stp);
else
stp->stream_start = 1;
break;
case YAML_DOCUMENT_START_EVENT:
if (stp->document_start)
rc = error_invalid_document_start(stp);
else
stp->document_start = 1;
break;
case YAML_MAPPING_START_EVENT:
if (! stp->stream_start)
rc = error_stream_not_started(stp, "mapping_start_event");
else if (! stp->document_start)
rc = error_document_not_started(stp, "mapping_start_event");
else
rc = handle_mapping_start(stp);
break;
case YAML_MAPPING_END_EVENT:
if (! stp->stream_start)
rc = error_stream_not_started(stp, "mapping_end_event");
else if (! stp->document_start)
rc = error_document_not_started(stp, "mapping_end_event");
else if (stp->curmap == NULL)
rc = error_no_current_mapping(stp, "mapping_end_event");
else
rc = handle_mapping_end(stp);
break;
case YAML_SCALAR_EVENT:
if (! stp->stream_start)
rc = error_stream_not_started(stp, "scalar_event");
else if (! stp->document_start)
rc = error_document_not_started(stp, "scalar_event");
else if (stp->curmap == NULL)
rc = error_no_current_mapping(stp, "scalar_event");
else
rc = handle_scalar(stp);
break;
case YAML_DOCUMENT_END_EVENT:
if (! stp->stream_start)
rc = error_stream_not_started(stp, "document_end_event");
else if (! stp->document_start)
rc = error_document_not_started(stp, "document_end_event");
else
stp->document_start = 0;
break;
case YAML_STREAM_END_EVENT:
if (! stp->stream_start)
rc = error_stream_not_started(stp, "stream_end_event");
else
{
stp->stream_start = 0;
done = 1;
}
break;
default:
rc = unexpected_event(stp);
break;
}
yaml_event_delete(&stp->event);
if (rc)
{
error = 1;
break;
}
}
yaml_parser_delete(&stp->parser);
return error;
}
/* this is where the magic happens */
static set* _cluster_keys(range_request* rr, apr_pool_t* pool,
const char* cluster, const char* cluster_file)
{
apr_array_header_t* working_range;
set* sections;
char* section;
char* cur_section;
apr_pool_t* req_pool = range_request_pool(rr);
yaml_node_t *node;
yaml_node_t *rootnode;
yaml_node_t *keynode;
yaml_node_t *valuenode;
yaml_parser_t parser;
yaml_node_item_t *item;
yaml_node_pair_t *pair;
yaml_document_t document;
FILE* fp = fopen(cluster_file, "r");
/* make sure we can open the file and parse it */
if (!fp) {
range_request_warn(rr, "%s: %s not readable", cluster, cluster_file);
return set_new(pool, 0);
}
if (!yaml_parser_initialize(&parser)) {
range_request_warn(rr, "%s: cannot initialize yaml parser", cluster);
fclose(fp);
return set_new(pool, 0);
}
yaml_parser_set_input_file(&parser, fp);
if(!yaml_parser_load(&parser, &document)) {
range_request_warn(rr, "%s: malformatted cluster definition %s",
cluster, cluster_file);
fclose(fp);
yaml_parser_delete(&parser);
return set_new(pool, 0);
}
fclose(fp);
rootnode = yaml_document_get_root_node(&document);
/* make sure it's just a simple dictionary */
if(rootnode->type != YAML_MAPPING_NODE) {
range_request_warn(rr, "%s: malformatted cluster definition %s",
cluster, cluster_file);
yaml_document_delete(&document);
yaml_parser_delete(&parser);
return set_new(pool, 0);
}
/* "sections" refers to cluster sections - %cluster:SECTION
it's what we're going to return */
sections = set_new(pool, 0);
section = cur_section = NULL;
for(pair = rootnode->data.mapping.pairs.start;
pair < rootnode->data.mapping.pairs.top;
pair++) { /* these are the keys */
keynode = yaml_document_get_node(&document, pair->key);
/* cur_section is the keyname - the WHATEVER in %cluster:WHATEVER */
cur_section = apr_pstrdup(pool, (char *)(keynode->data.scalar.value));
valuenode = yaml_document_get_node(&document, pair->value);
/* if the value is a scalar, that's our answer */
if(valuenode->type == YAML_SCALAR_NODE) {
set_add(sections, cur_section,
apr_psprintf(pool, "%s", valuenode->data.scalar.value));
} else if (valuenode->type == YAML_SEQUENCE_NODE) {
/* otherwise, glue together all the values in the list */
working_range = apr_array_make(req_pool, 1, sizeof(char*));
for(item = valuenode->data.sequence.items.start;
item < valuenode->data.sequence.items.top;
item++) {
node = yaml_document_get_node(&document, (int)*item);
if(node->type != YAML_SCALAR_NODE) { /* only scalars allowed */
range_request_warn(rr,
"%s: malformed cluster definition %s",
cluster, cluster_file);
yaml_document_delete(&document);
yaml_parser_delete(&parser);
return set_new(pool, 0);
} else { /* add to the working set */
/* include it in () because we're going to comma it
together later */
*(char**)apr_array_push(working_range) =
apr_psprintf(pool, "(%s)", _substitute_dollars(pool,
cluster, node->data.scalar.value));
}
}
/* glue the list items together with commas */
set_add(sections, cur_section,
apr_array_pstrcat(pool, working_range, ','));
}
}
/* Add a "KEYS" toplevel key that lists all the other keys */
/* TODO: make an error if somebody tries to specify KEYS manually? */
set_add(sections, "KEYS", _join_elements(pool, ',', sections));
yaml_document_delete(&document);
yaml_parser_delete(&parser);
return sections;
}
int
main(int argc, char *argv[])
{
int number;
int canonical = 0;
int unicode = 0;
number = 1;
while (number < argc) {
if (strcmp(argv[number], "-c") == 0) {
canonical = 1;
}
else if (strcmp(argv[number], "-u") == 0) {
unicode = 1;
}
else if (argv[number][0] == '-') {
printf("Unknown option: '%s'\n", argv[number]);
return 0;
}
if (argv[number][0] == '-') {
if (number < argc-1) {
memmove(argv+number, argv+number+1, (argc-number-1)*sizeof(char *));
}
argc --;
}
else {
number ++;
}
}
if (argc < 2) {
printf("Usage: %s [-c] [-u] file1.yaml ...\n", argv[0]);
return 0;
}
for (number = 1; number < argc; number ++)
{
FILE *file;
yaml_parser_t parser;
yaml_emitter_t emitter;
yaml_document_t document;
unsigned char buffer[BUFFER_SIZE];
size_t written = 0;
yaml_document_t documents[MAX_DOCUMENTS];
size_t document_number = 0;
int done = 0;
int count = 0;
int error = 0;
int k;
memset(buffer, 0, BUFFER_SIZE);
memset(documents, 0, MAX_DOCUMENTS*sizeof(yaml_document_t));
printf("[%d] Loading, dumping, and loading again '%s': ", number, argv[number]);
fflush(stdout);
file = fopen(argv[number], "rb");
assert(file);
assert(yaml_parser_initialize(&parser));
yaml_parser_set_input_file(&parser, file);
assert(yaml_emitter_initialize(&emitter));
if (canonical) {
yaml_emitter_set_canonical(&emitter, 1);
}
if (unicode) {
yaml_emitter_set_unicode(&emitter, 1);
}
yaml_emitter_set_output_string(&emitter, buffer, BUFFER_SIZE, &written);
yaml_emitter_open(&emitter);
while (!done)
{
if (!yaml_parser_load(&parser, &document)) {
error = 1;
break;
}
done = (!yaml_document_get_root_node(&document));
if (!done) {
assert(document_number < MAX_DOCUMENTS);
assert(copy_document(&(documents[document_number++]), &document));
assert(yaml_emitter_dump(&emitter, &document) ||
(yaml_emitter_flush(&emitter) && print_output(argv[number], buffer, written, count)));
count ++;
}
else {
yaml_document_delete(&document);
}
}
yaml_parser_delete(&parser);
assert(!fclose(file));
yaml_emitter_close(&emitter);
yaml_emitter_delete(&emitter);
if (!error)
{
count = done = 0;
assert(yaml_parser_initialize(&parser));
yaml_parser_set_input_string(&parser, buffer, written);
while (!done)
{
assert(yaml_parser_load(&parser, &document) || print_output(argv[number], buffer, written, count));
done = (!yaml_document_get_root_node(&document));
if (!done) {
assert(compare_documents(documents+count, &document) || print_output(argv[number], buffer, written, count));
count ++;
}
yaml_document_delete(&document);
}
yaml_parser_delete(&parser);
}
for (k = 0; k < document_number; k ++) {
yaml_document_delete(documents+k);
}
printf("PASSED (length: %d)\n", written);
print_output(argv[number], buffer, written, -1);
}
return 0;
}
int
main(int argc, char *argv[])
{
int help = 0;
int canonical = 0;
int unicode = 0;
int k;
int done = 0;
yaml_parser_t parser;
yaml_emitter_t emitter;
yaml_document_t document;
/* Clear the objects. */
memset(&parser, 0, sizeof(parser));
memset(&emitter, 0, sizeof(emitter));
memset(&document, 0, sizeof(document));
/* Analyze command line options. */
for (k = 1; k < argc; k ++)
{
if (strcmp(argv[k], "-h") == 0
|| strcmp(argv[k], "--help") == 0) {
help = 1;
}
else if (strcmp(argv[k], "-c") == 0
|| strcmp(argv[k], "--canonical") == 0) {
canonical = 1;
}
else if (strcmp(argv[k], "-u") == 0
|| strcmp(argv[k], "--unicode") == 0) {
unicode = 1;
}
else {
fprintf(stderr, "Unrecognized option: %s\n"
"Try `%s --help` for more information.\n",
argv[k], argv[0]);
return 1;
}
}
/* Display the help string. */
if (help)
{
printf("%s [--canonical] [--unicode] <input >output\n"
"or\n%s -h | --help\nReformat a YAML stream\n\nOptions:\n"
"-h, --help\t\tdisplay this help and exit\n"
"-c, --canonical\t\toutput in the canonical YAML format\n"
"-u, --unicode\t\toutput unescaped non-ASCII characters\n",
argv[0], argv[0]);
return 0;
}
/* Initialize the parser and emitter objects. */
if (!yaml_parser_initialize(&parser))
goto parser_error;
if (!yaml_emitter_initialize(&emitter))
goto emitter_error;
/* Set the parser parameters. */
yaml_parser_set_input_file(&parser, stdin);
/* Set the emitter parameters. */
yaml_emitter_set_output_file(&emitter, stdout);
yaml_emitter_set_canonical(&emitter, canonical);
yaml_emitter_set_unicode(&emitter, unicode);
/* The main loop. */
while (!done)
{
/* Get the next event. */
if (!yaml_parser_load(&parser, &document))
goto parser_error;
/* Check if this is the stream end. */
if (!yaml_document_get_root_node(&document)) {
done = 1;
}
/* Emit the event. */
if (!yaml_emitter_dump(&emitter, &document))
goto emitter_error;
}
yaml_parser_delete(&parser);
yaml_emitter_delete(&emitter);
return 0;
parser_error:
/* Display a parser error message. */
switch (parser.error)
{
case YAML_MEMORY_ERROR:
fprintf(stderr, "Memory error: Not enough memory for parsing\n");
break;
case YAML_READER_ERROR:
if (parser.problem_value != -1) {
fprintf(stderr, "Reader error: %s: #%X at %zd\n", parser.problem,
parser.problem_value, parser.problem_offset);
}
else {
fprintf(stderr, "Reader error: %s at %lu\n", parser.problem,
parser.problem_offset);
}
break;
case YAML_SCANNER_ERROR:
if (parser.context) {
fprintf(stderr, "Scanner error: %s at line %lu, column %lu\n"
"%s at line %lu, column %lu\n", parser.context,
parser.context_mark.line+1, parser.context_mark.column+1,
parser.problem, parser.problem_mark.line+1,
parser.problem_mark.column+1);
}
else {
fprintf(stderr, "Scanner error: %s at line %lu, column %lu\n",
parser.problem, parser.problem_mark.line+1,
parser.problem_mark.column+1);
}
break;
case YAML_PARSER_ERROR:
if (parser.context) {
fprintf(stderr, "Parser error: %s at line %lu, column %lu\n"
"%s at line %lu, column %lu\n", parser.context,
parser.context_mark.line+1, parser.context_mark.column+1,
parser.problem, parser.problem_mark.line+1,
parser.problem_mark.column+1);
}
else {
fprintf(stderr, "Parser error: %s at line %lu, column %lu\n",
parser.problem, parser.problem_mark.line+1,
parser.problem_mark.column+1);
}
break;
case YAML_COMPOSER_ERROR:
if (parser.context) {
fprintf(stderr, "Composer error: %s at line %lu, column %lu\n"
"%s at line %lu, column %lu\n", parser.context,
parser.context_mark.line+1, parser.context_mark.column+1,
parser.problem, parser.problem_mark.line+1,
parser.problem_mark.column+1);
}
else {
fprintf(stderr, "Composer error: %s at line %lu, column %lu\n",
parser.problem, parser.problem_mark.line+1,
parser.problem_mark.column+1);
}
break;
default:
/* Couldn't happen. */
fprintf(stderr, "Internal error\n");
break;
}
yaml_parser_delete(&parser);
yaml_emitter_delete(&emitter);
return 1;
emitter_error:
/* Display an emitter error message. */
switch (emitter.error)
{
case YAML_MEMORY_ERROR:
fprintf(stderr, "Memory error: Not enough memory for emitting\n");
break;
case YAML_WRITER_ERROR:
fprintf(stderr, "Writer error: %s\n", emitter.problem);
break;
case YAML_EMITTER_ERROR:
fprintf(stderr, "Emitter error: %s\n", emitter.problem);
break;
default:
/* Couldn't happen. */
fprintf(stderr, "Internal error\n");
break;
}
yaml_parser_delete(&parser);
yaml_emitter_delete(&emitter);
return 1;
}
void Load_All_AI(Player* players, const char* filename, int* ai_indices)
{
// append path to front of filename.
char newfilename[512];
sprintf(newfilename, "%s%s",g_DataPath, filename);
FILE* fp = fopen(newfilename, "r");
if (!fp)
SYS_Error("Error loading AI\n");
// pre allocate the maximum number of characters
character_type* ais = (character_type*)malloc(sizeof(character_type) * MAX_AIS);
memset(ais, 0, sizeof(character_type) * MAX_AIS);
// open the YAML file
yaml_parser_t parser;
yaml_parser_initialize(&parser);
yaml_parser_set_input_file(&parser, fp);
// NOTE: YAML file is expected to contain a sequence of maps.
// One map per character.
int done = 0;
int ai_index = 0;
char key[128];
bool read_key = false;
while (!done)
{
yaml_event_t event;
// get the next event
if (!yaml_parser_parse(&parser, &event))
{
SYS_Error("error parsing YAML file \"%s\"\n", newfilename);
return;
}
// process the event
switch (event.type)
{
case YAML_MAPPING_START_EVENT:
read_key = true;
break;
case YAML_SCALAR_EVENT:
if (read_key)
strcpy(key, (char*)event.data.scalar.value);
else
Character_Set(&ais[ai_index], key, (char*)event.data.scalar.value);
read_key = !read_key;
break;
case YAML_MAPPING_END_EVENT:
assert(ai_index < MAX_AIS); // too many ais in yaml file.
ai_index++;
break;
case YAML_NO_EVENT:
case YAML_STREAM_START_EVENT:
case YAML_STREAM_END_EVENT:
case YAML_DOCUMENT_START_EVENT:
case YAML_DOCUMENT_END_EVENT:
case YAML_ALIAS_EVENT:
case YAML_SEQUENCE_START_EVENT:
case YAML_SEQUENCE_END_EVENT:
default:
break;
}
done = (event.type == YAML_STREAM_END_EVENT);
yaml_event_delete(&event);
}
yaml_parser_delete(&parser);
// load each player's sound fx.
for (int i = 0; i < 6; ++i)
{
character_type* c = &players[i].character;
memcpy(c, &ais[ai_indices[i]], sizeof(character_type));
for (int j = 0; j < NUMBER_CHARACTER_SOUNDS; ++j)
c->samples[j] = SYS_LoadSound(c->sample_filenames[j]);
}
free(ais);
}
