static int yaml_parser_load_document(yaml_parser_t *parser, yaml_event_t *first_event) { yaml_event_t event; assert(first_event->type == YAML_DOCUMENT_START_EVENT); /* DOCUMENT-START is expected. */ parser->document->version_directive = first_event->data.document_start.version_directive; parser->document->tag_directives.start = first_event->data.document_start.tag_directives.start; parser->document->tag_directives.end = first_event->data.document_start.tag_directives.end; parser->document->start_implicit = first_event->data.document_start.implicit; parser->document->start_mark = first_event->start_mark; if (!yaml_parser_parse(parser, &event)) return 0; if (!yaml_parser_load_node(parser, &event)) return 0; if (!yaml_parser_parse(parser, &event)) return 0; assert(event.type == YAML_DOCUMENT_END_EVENT); /* DOCUMENT-END is expected. */ parser->document->end_implicit = event.data.document_end.implicit; parser->document->end_mark = event.end_mark; return 1; }
void Region::parse(yaml_parser_t* parser){ yaml_event_t ekey; yaml_event_t eval; do { /* parse key */ yaml_parser_parse(parser, &ekey) || yaml_error(parser); if ( ekey.type == YAML_MAPPING_END_EVENT ){ /* finished */ break; } else if ( ekey.type != YAML_SCALAR_EVENT ){ /* malformed yaml */ fprintf(stderr, "YAML dict key must be string\n"); abort(); } /* Parse value */ yaml_parser_parse(parser, &eval) || yaml_error(parser); /* delegate parsing of value */ const std::string key = std::string((const char*)ekey.data.scalar.value, ekey.data.scalar.length); const std::string val = std::string((const char*)eval.data.scalar.value, eval.data.scalar.length); this->set(key, val); } while ( true ); }
static int yaml_parser_load_sequence(yaml_parser_t *parser, yaml_event_t *first_event) { yaml_event_t event; yaml_node_t node; struct { yaml_node_item_t *start; yaml_node_item_t *end; yaml_node_item_t *top; } items = { NULL, NULL, NULL }; int index, item_index; yaml_char_t *tag = first_event->data.sequence_start.tag; if (!STACK_LIMIT(parser, parser->document->nodes, INT_MAX-1)) goto error; if (!tag || strcmp((char *)tag, "!") == 0) { yaml_free(tag); tag = yaml_strdup((yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG); if (!tag) goto error; } if (!STACK_INIT(parser, items, INITIAL_STACK_SIZE)) goto error; SEQUENCE_NODE_INIT(node, tag, items.start, items.end, first_event->data.sequence_start.style, first_event->start_mark, first_event->end_mark); if (!PUSH(parser, parser->document->nodes, node)) goto error; index = (int)(parser->document->nodes.top - parser->document->nodes.start); if (!yaml_parser_register_anchor(parser, index, first_event->data.sequence_start.anchor)) return 0; if (!yaml_parser_parse(parser, &event)) return 0; while (event.type != YAML_SEQUENCE_END_EVENT) { if (!STACK_LIMIT(parser, parser->document->nodes.start[index-1].data.sequence.items, INT_MAX-1)) return 0; item_index = yaml_parser_load_node(parser, &event); if (!item_index) return 0; if (!PUSH(parser, parser->document->nodes.start[index-1].data.sequence.items, item_index)) return 0; if (!yaml_parser_parse(parser, &event)) return 0; } parser->document->nodes.start[index-1].end_mark = event.end_mark; return index; error: yaml_free(tag); yaml_free(first_event->data.sequence_start.anchor); return 0; }
static int yaml_parser_load_mapping(yaml_parser_t *parser, yaml_event_t *first_event) { yaml_event_t event; yaml_node_t node; struct { yaml_node_pair_t *start; yaml_node_pair_t *end; yaml_node_pair_t *top; } pairs = { NULL, NULL, NULL }; int index; yaml_node_pair_t pair; yaml_char_t *tag = first_event->data.mapping_start.tag; if (!tag || strcmp((char *)tag, "!") == 0) { yaml_free(tag); tag = yaml_strdup((yaml_char_t *)YAML_DEFAULT_MAPPING_TAG); if (!tag) goto error; } if (!STACK_INIT(parser, pairs, INITIAL_STACK_SIZE)) goto error; MAPPING_NODE_INIT(node, tag, pairs.start, pairs.end, first_event->data.mapping_start.style, first_event->start_mark, first_event->end_mark); if (!PUSH(parser, parser->document->nodes, node)) goto error; index = (int) (parser->document->nodes.top - parser->document->nodes.start); if (!yaml_parser_register_anchor(parser, index, first_event->data.mapping_start.anchor)) return 0; if (!yaml_parser_parse(parser, &event)) return 0; while (event.type != YAML_MAPPING_END_EVENT) { pair.key = yaml_parser_load_node(parser, &event); if (!pair.key) return 0; if (!yaml_parser_parse(parser, &event)) return 0; pair.value = yaml_parser_load_node(parser, &event); if (!pair.value) return 0; if (!PUSH(parser, parser->document->nodes.start[index-1].data.mapping.pairs, pair)) return 0; if (!yaml_parser_parse(parser, &event)) return 0; } parser->document->nodes.start[index-1].end_mark = event.end_mark; return index; error: yaml_free(tag); yaml_free(first_event->data.mapping_start.anchor); return 0; }
void eol_config_parse_tier(yaml_parser_t *parser, eolKeychain *chain) { int done = 0; eolLine last_key; eolKeychain *next = NULL; yaml_event_t event; /* First element must be a variable, or we'll change states to SEQ */ int state = KEY; eol_line_cpy(last_key,""); do { yaml_parser_parse(parser, &event); switch(event.type) { case YAML_SCALAR_EVENT: if (state == KEY) { /* new key, hold on to it until we get a value as well */ eol_line_cpy(last_key,(char *)event.data.scalar.value); } else { /* state is VAL or SEQ */ /* TODO data type logic should go here */ next = eol_keychain_new_string((char *)event.data.scalar.value); eol_keychain_hash_insert(chain,last_key,next); } state ^= VAL; /* Toggles KEY/VAL, avoids touching SEQ */ break; case YAML_SEQUENCE_START_EVENT: next = eol_keychain_new_list(); eol_keychain_hash_insert(chain,last_key, next); eol_config_parse_sequence(parser, next); break; case YAML_MAPPING_START_EVENT: if (strlen(last_key) == 0)break;/*first level is implied hash.*/ next = eol_keychain_new_hash(); eol_keychain_hash_insert(chain,last_key,next); state ^= VAL; eol_config_parse_tier(parser, next); break; case YAML_MAPPING_END_EVENT: case YAML_STREAM_END_EVENT: case YAML_SEQUENCE_END_EVENT: done = 1; /* terminate the while loop, see below */ break; default: fprintf(stderr,"eol_config_parse_tier: unhandled event\n"); } if(parser->error != YAML_NO_ERROR) { fprintf(stderr,"eol_config_parse_tier: error\n"); return; } yaml_event_delete(&event); } while (!done); }
int config_parse_mapping(yaml_parser_t *parser, monikor_config_dict_t *dict) { yaml_event_t ev; monikor_config_dict_t *elm = NULL; while (42) { if (!yaml_parser_parse(parser, &ev)) return 1; if (ev.type == YAML_MAPPING_END_EVENT) { yaml_event_delete(&ev); return 0; } switch(ev.type) { case YAML_SCALAR_EVENT: if (elm) { elm->next = monikor_config_dict_new(); elm = elm->next; } else { elm = dict; } if (config_parse_key(parser, (char *)ev.data.scalar.value, elm)) { printf("bad return from parse_key\n"); return 1; } break; default: printf("error in parse_mapping, event %d\n", ev.type); return 1; break; } yaml_event_delete(&ev); } }
void eol_config_parse_sequence(yaml_parser_t *parser, eolKeychain *chain) { int done = 0; eolKeychain *next = NULL; yaml_event_t event; /* First element must be a variable, or we'll change states to SEQ */ int state = KEY; do { yaml_parser_parse(parser, &event); switch(event.type) { case YAML_MAPPING_START_EVENT: next = eol_keychain_new_hash(); eol_keychain_list_append(chain,next); state ^= VAL; eol_config_parse_tier(parser, next); break; case YAML_SEQUENCE_END_EVENT: case YAML_MAPPING_END_EVENT: case YAML_STREAM_END_EVENT: done = 1; /* terminate the while loop, see below */ break; default: fprintf(stderr,"eol_config_parse_sequence: unhandled event\n"); } if(parser->error != YAML_NO_ERROR) { fprintf(stderr,"eol_config_parse_sequence: unhandled event\n"); return; } yaml_event_delete(&event); }while (!done); }
yaml_parser_load(yaml_parser_t *parser, yaml_document_t *document) { yaml_event_t event; assert(parser); /* Non-NULL parser object is expected. */ assert(document); /* Non-NULL document object is expected. */ memset(document, 0, sizeof(yaml_document_t)); if (!STACK_INIT(parser, document->nodes, INITIAL_STACK_SIZE)) goto error; if (!parser->stream_start_produced) { if (!yaml_parser_parse(parser, &event)) goto error; assert(event.type == YAML_STREAM_START_EVENT); /* STREAM-START is expected. */ } if (parser->stream_end_produced) { return 1; } if (!yaml_parser_parse(parser, &event)) goto error; if (event.type == YAML_STREAM_END_EVENT) { return 1; } if (!STACK_INIT(parser, parser->aliases, INITIAL_STACK_SIZE)) goto error; parser->document = document; if (!yaml_parser_load_document(parser, &event)) goto error; yaml_parser_delete_aliases(parser); parser->document = NULL; return 1; error: yaml_parser_delete_aliases(parser); yaml_document_delete(document); parser->document = NULL; return 0; }
void GetEvent(ctr_yaml_context *ctx) { if (!yaml_parser_parse(&ctx->parser, &ctx->event)){ ctx->error = YAML_API_ERROR; return; } CheckEvent(ctx); }
void YamlHelper::GetNextEvent(bool bInMap /*= false*/) { if (!yaml_parser_parse(&m_parser, &m_newEvent)) { //printf("Parser error %d\n", m_parser.error); throw std::string("Parser error"); } }
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; }
Sprite* Sprite::from_yaml(yaml_parser_t* parser, const Sprite* base){ Sprite* sprite = Game::create_sprite(base); yaml_event_t event; yaml_event_t evalue; yaml_parser_parse(parser, &event) || yaml_error(parser); if ( event.type != YAML_MAPPING_START_EVENT ){ fprintf(stderr, "Sprite expected a mapping at line %lu:%lu\n", parser->mark.line+1, parser->mark.column+1); abort(); } do { yaml_parser_parse(parser, &event) || yaml_error(parser); if ( event.type == YAML_MAPPING_END_EVENT ){ /* All elements has been consumed */ return sprite; } else if ( event.type != YAML_SCALAR_EVENT ){ /* For this purpose only strings are allowed as keys */ fprintf(stderr, "YAML dict key must be string at line %lu:%lu\n", parser->mark.line+1, parser->mark.column+1); abort(); } const std::string key((const char*)event.data.scalar.value, event.data.scalar.length); if ( key == "texture" ){ yaml_parser_parse(parser, &evalue) || yaml_error(parser); const std::string texture((const char*)evalue.data.scalar.value, evalue.data.scalar.length); sprite->load_texture(texture); } else if ( key == "offset" ){ sprite->set_offset(Vector2f::from_yaml(parser)); } else if ( key == "scale" ){ sprite->set_scale(Vector2f::from_yaml(parser) * Vector2f(Game::tile_width(), Game::tile_height())); } else { /* warning only */ fprintf(stderr, "Unhandled key `%s'\n", key.c_str()); } } while (1); }
YamlNode_t *moloch_rules_parse_yaml(char *filename, YamlNode_t *parent, yaml_parser_t *parser, gboolean sequence) { char *key = NULL; YamlNode_t *node; int done = 0; while (!done) { yaml_event_t event; if (!yaml_parser_parse(parser, &event)) LOGEXIT("%s:%zu - Parse error '%s'", filename, parser->problem_mark.line, parser->problem); #ifdef RULES_DEBUG LOG("%s %d", yaml_names[event.type], event.type); #endif switch(event.type) { case YAML_NO_EVENT: done = 1; break; case YAML_SCALAR_EVENT: #ifdef RULES_DEBUG LOG("SCALAR_EVENT: %s => %s", key, event.data.scalar.value); #endif if (sequence) { moloch_rules_add_node(parent, g_strdup((gchar *)event.data.scalar.value), YAML_NODE_SEQUENCE_VALUE); } else if (key) { moloch_rules_add_node(parent, key, g_strdup((gchar *)event.data.scalar.value)); key = NULL; } else { key = g_strdup((gchar *)event.data.scalar.value); } break; case YAML_SEQUENCE_START_EVENT: case YAML_MAPPING_START_EVENT: if (parent == NULL) { parent = node = moloch_rules_add_node(NULL, g_strdup("root"), NULL); } else { node = moloch_rules_add_node(parent, key, NULL); } key = NULL; if (moloch_rules_parse_yaml(filename, node, parser, event.type == YAML_SEQUENCE_START_EVENT) == NULL) return NULL; break; case YAML_MAPPING_END_EVENT: case YAML_SEQUENCE_END_EVENT: done = 1; default: ; } yaml_event_delete(&event); } return parent; }
SEXP processYAMLStream(yaml_parser_t *parser, int simplify, SEXP nullValue, int simplifyWithNames, cetype_t charEncoding) { SEXP ans = R_NilValue; int done = 0; yaml_event_t event; while (!done) { /* Get the next event. */ if (!yaml_parser_parse(parser, &event)) { return(NULL); } fprintf(stderr, "type -> %d\n", (int) event.type); /* Process the event */ switch(event.type) { case YAML_STREAM_START_EVENT: break; case YAML_STREAM_END_EVENT: break; case YAML_DOCUMENT_START_EVENT: break; case YAML_DOCUMENT_END_EVENT: break; case YAML_ALIAS_EVENT: break; case YAML_SCALAR_EVENT: break; case YAML_SEQUENCE_START_EVENT: break; case YAML_SEQUENCE_END_EVENT: break; case YAML_MAPPING_START_EVENT: break; case YAML_MAPPING_END_EVENT: break; case YAML_NO_EVENT: break; } /* Are we finished? */ done = (event.type == YAML_STREAM_END_EVENT); /* The application is responsible for destroying the event object. */ yaml_event_delete(&event); } ans = R_NilValue; return(ans); }
YamlSequence * YamlDocument::ParseYamlSequence() { YamlSequence * ret = new YamlSequence(); yaml_event_delete(&event); do{ yaml_parser_parse(&parser, &event); switch(event.type) { case YAML_SEQUENCE_START_EVENT: { YamlSequence *v; v = ParseYamlSequence(); ret->appendValue(reinterpret_cast<YamlNode *>(v)); } break; case YAML_SEQUENCE_END_EVENT: break; case YAML_MAPPING_START_EVENT: { YamlMapping *v; v=ParseYamlMapping(); ret->appendValue(reinterpret_cast<YamlNode *>(v)); } break; case YAML_MAPPING_END_EVENT: break; case YAML_SCALAR_EVENT: { YamlScalar *v = new YamlScalar((char *)event.data.scalar.value ); ret->appendValue(reinterpret_cast<YamlNode *>(v)); } break; case YAML_NO_EVENT: break; case YAML_ALIAS_EVENT: break; default: std::cerr << "FORMAT ERROR in Sequence." << std::endl; break; } if(event.type != YAML_SEQUENCE_END_EVENT){ yaml_event_delete(&event); } }while(event.type != YAML_SEQUENCE_END_EVENT); yaml_event_delete(&event); return ret; }
PetscErrorCode PetscParseLayerYAML(yaml_parser_t *parser,int *lvl) { yaml_event_t event; int storage = VAR; /* mapping cannot start with VAL definition w/o VAR key */ char key[PETSC_MAX_PATH_LEN],option[PETSC_MAX_PATH_LEN],prefix[PETSC_MAX_PATH_LEN]; PetscErrorCode ierr; PetscFunctionBegin; ierr = PetscSNPrintf(option,PETSC_MAX_PATH_LEN,"%s"," ");CHKERRQ(ierr); do { yaml_parser_parse(parser,&event); /* Parse value either as a new leaf in the mapping */ /* or as a leaf value (one of them, in case it's a sequence) */ switch (event.type) { case YAML_SCALAR_EVENT: if (storage) { ierr = PetscSNPrintf(option,PETSC_MAX_PATH_LEN,"-%s %s",key,(char*)event.data.scalar.value);CHKERRQ(ierr); ierr = PetscOptionsInsertString(option);CHKERRQ(ierr); } else { ierr = PetscStrncpy(key,(char*)event.data.scalar.value,event.data.scalar.length+1);CHKERRQ(ierr); } storage ^= VAL; /* Flip VAR/VAL switch for the next event */ break; case YAML_SEQUENCE_START_EVENT: /* Sequence - all the following scalars will be appended to the last_leaf */ storage = SEQ; SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP ,"Unable to open YAML option file: sequences not supported"); yaml_event_delete(&event); break; case YAML_SEQUENCE_END_EVENT: storage = VAR; yaml_event_delete(&event); break; case YAML_MAPPING_START_EVENT: ierr = PetscSNPrintf(prefix,PETSC_MAX_PATH_LEN,"%s_",key);CHKERRQ(ierr); if (*lvl > 0) { ierr = PetscOptionsPrefixPush(prefix);CHKERRQ(ierr); } (*lvl)++; ierr = PetscParseLayerYAML(parser,lvl);CHKERRQ(ierr); (*lvl)--; if (*lvl > 0) { ierr = PetscOptionsPrefixPop();CHKERRQ(ierr); } storage ^= VAL; /* Flip VAR/VAL, w/o touching SEQ */ yaml_event_delete(&event); break; default: break; } } while ((event.type != YAML_MAPPING_END_EVENT) && (event.type != YAML_STREAM_END_EVENT)); PetscFunctionReturn(0); }
YamlNode * YamlDocument::ParseYamlDoc() { YamlNode *root = new YamlNode(); yaml_event_delete(&event); do{ yaml_parser_parse(&parser, &event); switch(event.type){ case YAML_STREAM_END_EVENT: case YAML_DOCUMENT_END_EVENT: return root; case YAML_SEQUENCE_START_EVENT: { YamlSequence *v; v = ParseYamlSequence(); root->addChild(reinterpret_cast<YamlNode *>(v)); } break; case YAML_SEQUENCE_END_EVENT: break; case YAML_MAPPING_START_EVENT: { YamlMapping *v; v=ParseYamlMapping(); root->addChild(reinterpret_cast<YamlNode *>(v)); } break; case YAML_MAPPING_END_EVENT: break; case YAML_SCALAR_EVENT: { YamlScalar *v = new YamlScalar((char *)event.data.scalar.value ); root->addChild(reinterpret_cast<YamlNode *>(v)); } break; default: std::cout << "FORMAT ERROR" << std::endl; break; } if(event.type != YAML_DOCUMENT_END_EVENT){ yaml_event_delete(&event); } }while(event.type != YAML_DOCUMENT_END_EVENT); yaml_event_delete(&event); return root; }
/* * This is the main function for dumping any node. */ SV * load_node(perl_yaml_loader_t *loader) { /* Get the next parser event */ if (!yaml_parser_parse(&loader->parser, &loader->event)) goto load_error; /* Return NULL when we hit the end of a scope */ if (loader->event.type == YAML_DOCUMENT_END_EVENT || loader->event.type == YAML_MAPPING_END_EVENT || loader->event.type == YAML_SEQUENCE_END_EVENT) return NULL; /* Handle loading a mapping */ if (loader->event.type == YAML_MAPPING_START_EVENT) { SV *hash_ref; char *tag = (char *)loader->event.data.mapping_start.tag; /* Handle mapping tagged as a Perl hard reference */ if (tag && strEQ(tag, TAG_PERL_REF)) return load_scalar_ref(loader); /* Handle mapping tagged as a Perl typeglob */ if (tag && strEQ(tag, TAG_PERL_GLOB)) return load_glob(loader); /* Load the mapping into a hash ref and return it */ return load_mapping(loader, NULL); } /* Handle loading a sequence into an array */ if (loader->event.type == YAML_SEQUENCE_START_EVENT) return load_sequence(loader); /* Handle loading a scalar */ if (loader->event.type == YAML_SCALAR_EVENT) return load_scalar(loader); /* Handle loading an alias node */ if (loader->event.type == YAML_ALIAS_EVENT) return load_alias(loader); /* Some kind of error occurred */ if (loader->event.type == YAML_NO_EVENT) croak(loader_error_msg(loader, NULL)); croak(ERRMSG "Invalid event '%d' at top level", (int) loader->event.type); load_error: croak(loader_error_msg(loader, NULL)); }
static int event_iter (lua_State *L) { lyaml_parser *parser = (lyaml_parser *)lua_touserdata(L, lua_upvalueindex(1)); char *str; parser_delete_event (parser); if (yaml_parser_parse (&parser->parser, &parser->event) != 1) { parser_generate_error_message (parser); return lua_error (L); } parser->validevent = 1; lua_newtable (L); lua_pushliteral (L, "type"); switch (parser->event.type) { /* First the simple events, generated right here... */ #define MENTRY(_s) \ case YAML_##_s##_EVENT: parser_push_eventtable (parser, #_s, 0); break MENTRY( STREAM_END ); MENTRY( SEQUENCE_END ); MENTRY( MAPPING_END ); #undef MENTRY /* ...then the complex events, generated by a function call. */ #define MENTRY(_s) \ case YAML_##_s##_EVENT: parse_##_s (parser); break MENTRY( STREAM_START ); MENTRY( DOCUMENT_START ); MENTRY( DOCUMENT_END ); MENTRY( ALIAS ); MENTRY( SCALAR ); MENTRY( SEQUENCE_START ); MENTRY( MAPPING_START ); #undef MENTRY case YAML_NO_EVENT: lua_pushnil (L); break; default: lua_pushfstring (L, "invalid event %d", parser->event.type); return lua_error (L); } return 1; }
static bool wb_expect_sequence(wb_config_parser_state *state) { bool result = true; if (!yaml_parser_parse(&(state->parser), &(state->event))) { state->done = true; return true; } if (state->event.type != YAML_SEQUENCE_START_EVENT) result = false; yaml_event_delete(&(state->event)); return result; }
/** * Parse a (possibly base64 encoded) payload and set it on * the `req`. * * It is assumed that the `parser` has just encountered a * YAML_SCALAR_EVENT whose value was either "payload" or * "payload64", and the next event will be a YAML_SCALAR_EVENT * representing the payload itself. * * Return 1 on error or 0 on success. */ int parse_payload(yaml_parser_t* parser, yaml_event_t* event, request* req) { char* payload; unsigned long rawlength; yaml_event_t payload_event; if (!yaml_parser_parse(parser, &payload_event)) return 1; payload = (char *)payload_event.data.scalar.value; // printf("raw payload: '%s'\n", payload_event.data.scalar.value); rawlength = strlen(payload); if (0 == strncmp("payload64", (const char*)event->data.scalar.value, 9)) { unsigned long payload_length; if (rawlength < 0 || rawlength % 4 != 0) { fprintf(stderr, "base64-encoded POST payload length must be a positive multiple of 4 (was %lu)", rawlength); yaml_event_delete(&payload_event); return 1; } payload_length = rawlength / 4 * 3; if (payload[rawlength - 1] == '=') payload_length--; if (payload[rawlength - 2] == '=') payload_length--; if (!(req->payload = malloc(sizeof(char) * (payload_length + 1)))) { yaml_event_delete(&payload_event); return 1; } req->payload[payload_length] = '\0'; base64_decodestate state; base64_init_decodestate(&state); base64_decode_block((const char*)payload_event.data.scalar.value, rawlength, req->payload, &state); req->payload_length = payload_length; } else { if (!(req->payload = malloc(sizeof(char) * (rawlength + 1)))) { yaml_event_delete(&payload_event); return 1; } strcpy(req->payload, (const char*)payload_event.data.scalar.value); req->payload_length = rawlength; } return 0; }
static rstatus_t conf_event_next(struct conf *cf) { int rv; ASSERT(cf->valid_parser && !cf->valid_event); rv = yaml_parser_parse(&cf->parser, &cf->event); if (!rv) { log_error("conf: failed (err %d) to get next event", cf->parser.error); return NC_ERROR; } cf->valid_event = 1; return NC_OK; }
static char* wb_read_string(wb_config_parser_state *state) { char *result; if (!yaml_parser_parse(&(state->parser), &(state->event))) { state->done = true; return 0; } if (state->event.type != YAML_SCALAR_EVENT) error("Unexpected event type while parsing YAML"); else result = wb_str_value(state); yaml_event_delete(&(state->event)); return result; }
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); }
static int wb_read_int(wb_config_parser_state *state) { int result; if (!yaml_parser_parse(&(state->parser), &(state->event))) { state->done = true; return 0; } if (state->event.type != YAML_SCALAR_EVENT) error("Unexpected event type while parsing YAML"); else if (!wb_int_value(state, &result)) error("Invalid format for integer: '%s'", wb_str_value(state)); yaml_event_delete(&(state->event)); return result; }
static bool wb_expect_mapping_file(wb_config_parser_state *state) { bool keep_scanning = true; bool result = true; while (keep_scanning) { if (!yaml_parser_parse(&(state->parser), &(state->event))) { state->done = true; return true; } keep_scanning = (state->event.type == YAML_STREAM_START_EVENT || state->event.type == YAML_DOCUMENT_START_EVENT); result = (state->event.type == YAML_MAPPING_START_EVENT); yaml_event_delete(&(state->event)); } return result; }
static bool yaml_next_event(rb_yaml_parser_t *parser) { if (NIL_P(parser->input)) { rb_raise(rb_eRuntimeError, "input needed"); } if (parser->event_valid) { yaml_event_delete(&parser->event); parser->event_valid = false; } if (yaml_parser_parse(&parser->parser, &parser->event) == 0) { rb_exc_raise(rb_yaml_parser_generate_error(&parser->parser)); parser->event_valid = false; } else { parser->event_valid = true; } return parser->event_valid; }
static char* wb_read_key(wb_config_parser_state *state) { char *result; if (!yaml_parser_parse(&(state->parser), &(state->event))) { state->done = true; return NULL; } if (state->event.type == YAML_MAPPING_END_EVENT) result = NULL; else if (state->event.type != YAML_SCALAR_EVENT) error("Unexpected event type %d while parsing YAML", state->event.type); else result = wb_str_value(state); yaml_event_delete(&(state->event)); return result; }
static bool wb_sequence_of_mappings(wb_config_parser_state *state) { bool result; if (!yaml_parser_parse(&(state->parser), &(state->event))) { state->done = true; return true; } if (state->event.type == YAML_MAPPING_START_EVENT) result = true; else if (state->event.type == YAML_SEQUENCE_END_EVENT) result = false; else error("Items of sequence must be mappings, %d", state->event.type ); //log_debug2("Sequence of mappings, with %d, result %d", state->event.type, result); yaml_event_delete(&(state->event)); return result; }
static void wb_read_list_of_string(wb_config_parser_state *state, char ***list, int *n) { bool done = false; if (!wb_expect_sequence(state)) error("Expecting a sequence of strings"); *n = 0; while (!done) { if (!yaml_parser_parse(&(state->parser), &(state->event))) { state->done = true; return; } if (state->event.type == YAML_SCALAR_EVENT) { if (*n) { *n += 1; *list = rewballoc(*list, sizeof(char**)*(*n)); } else { *n = 1; *list = wballoc(sizeof(char**)); } (*list)[*n-1] = wb_str_value(state); } else if (state->event.type == YAML_SEQUENCE_END_EVENT) { done = true; } else error("Invalid value for a list of strings"); yaml_event_delete(&(state->event)); } }