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