自学教程：C++ yaml_parser_parse函数代码示例

static intyaml_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 intyaml_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 intyaml_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;}

SEXPprocessYAMLStream(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 intevent_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 boolwb_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_tconf_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;}

boolYamlDocument::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 intwb_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 boolwb_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 boolyaml_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 boolwb_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 voidwb_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));	}}