static elemstyle_t *parse_rule(xmlNode *a_node) {
xmlNode *cur_node = NULL;
elemstyle_t *elemstyle = g_new0(elemstyle_t, 1);
elemstyle_condition_t **lastcond = &elemstyle->condition;
for (cur_node = a_node->children; cur_node; cur_node = cur_node->next) {
if (cur_node->type == XML_ELEMENT_NODE) {
if(strcasecmp((char*)cur_node->name, "condition") == 0) {
/* ------ parse condition ------ */
elemstyle_condition_t *newcond = g_new0(elemstyle_condition_t, 1);
newcond->key = xmlGetProp(cur_node, BAD_CAST "k");
newcond->value = xmlGetProp(cur_node, BAD_CAST "v");
*lastcond = newcond;
lastcond = &newcond->next;
/* todo: add support for "b" (boolean) value */
} else if(strcasecmp((char*)cur_node->name, "line") == 0) {
/* ------ parse line ------ */
g_assert(elemstyle->type == ES_TYPE_NONE);
elemstyle->type = ES_TYPE_LINE;
elemstyle->line = parse_line(cur_node);
} else if(strcasecmp((char*)cur_node->name, "linemod") == 0) {
/* ------ parse linemod ------ */
g_assert(elemstyle->type == ES_TYPE_NONE);
elemstyle->type = ES_TYPE_LINE_MOD;
elemstyle->line_mod = parse_line_mod(cur_node);
} else if(strcasecmp((char*)cur_node->name, "area") == 0) {
/* ------ parse area ------ */
g_assert(elemstyle->type == ES_TYPE_NONE);
elemstyle->type = ES_TYPE_AREA;
elemstyle->area = parse_area(cur_node);
} else if(strcasecmp((char*)cur_node->name, "icon") == 0) {
elemstyle->icon = parse_icon(cur_node);
} else if(strcasecmp((char*)cur_node->name, "scale_min") == 0) {
/* scale_min is currently ignored */
} else if(strcasecmp((char*)cur_node->name, "scale_max") == 0) {
switch (elemstyle->type) {
case ES_TYPE_LINE:
parse_scale_max(cur_node, &elemstyle->line->zoom_max);
break;
case ES_TYPE_AREA:
parse_scale_max(cur_node, &elemstyle->area->zoom_max);
break;
default:
if (elemstyle->icon) {
parse_scale_max(cur_node, &elemstyle->icon->zoom_max);
}
else {
printf("scale_max for unhandled elemstyletype=0x02%x\n",
elemstyle->type);
}
break;
}
} else {
printf("found unhandled rules/rule/%s\n", cur_node->name);
}
}
}
return elemstyle;
}
int parse_data_module( DATAModule *module ) {
int data_count;
bool fatalError = TRUE; // if true, catch leads to exit(-1)
try {
data_count = module->datas_count;
for ( int i = 0; i < module->datas_count; i++ ) {
DataContext ctx; data_context = &ctx;
const char *tagName = module->datas[i]->tag->image;
const int tagId = find_tag( tagName );
if ( DATA_VERBOSE > 4 ) {
printf("tagName: %s tagId: %d\n\r", tagName, tagId );
}
switch ( tagId ) {
case TAG_Prereq: parse_prerequisite( module->datas[i] ); break;
case TAG_BrewFormula:
create_brew_formula_table( module->datas_count );
parse_brew_formula( module->datas[i] );
break;
case TAG_Ban: parse_ban( module->datas[i] ); break;
case TAG_Command:
create_command_table( module->datas_count );
parse_command( module->datas[i] );
break;
case TAG_Unique: parse_unique( module->datas[i] ); break;
case TAG_Disable: parse_disabled( module->datas[i] ); break;
case TAG_Material:
create_material_table( module->datas_count );
parse_material( module->datas[i] );
break;
case TAG_Liquid:
create_liquid_table( module->datas_count );
parse_liquid( module->datas[i] );
break;
case TAG_God:
create_god_table( module->datas_count );
parse_god( module->datas[i] );
break;
case TAG_Clan: parse_clan( module->datas[i] ); break;
case TAG_Faction:
create_faction_table( module->datas_count, module );
parse_faction( module->datas[i] );
break;
case TAG_Race:
create_races_table( module->datas_count );
parse_race( module->datas[i] );
break;
case TAG_PCRace:
create_pcraces_table( module->datas_count );
parse_pcrace( module->datas[i] );
break;
case TAG_Sphere:
create_spheres_table( module->datas_count );
parse_sphere( module->datas[i] );
break;
case TAG_Group:
create_groups_table( module->datas_count );
parse_groups( module->datas[i] );
break;
case TAG_Ability: parse_abilities( module->datas[i] ); break;
case TAG_Class:
create_classes_table( module->datas_count );
parse_classes( module->datas[i] );
break;
case TAG_Player:
fatalError = FALSE;
parse_player( module->datas[i] );
fatalError = TRUE;
break;
case TAG_Area: parse_area( module->datas[i] ); break;
case TAG_Config:
if ( parse_config( module->datas[i] ) ) // once we have found the right config: skip others
return data_count;
break;
case TAG_AreaState: parse_area_state( module->datas[i] ); break;
case TAG_Time: parse_time( module->datas[i] ); break;
case TAG_Hometown:
create_hometown_table( module->datas_count );
parse_hometown( module->datas[i] );
break;
case TAG_School:
create_school_table( module->datas_count );
parse_school( module->datas[i] );
break;
case TAG_Super_Race:
create_super_race_table( module->datas_count );
parse_super_race( module->datas[i] );
break;
default: p_error("Invalid Tag: %s", tagName ); break;
}
}
} catch (ScriptException e) {
bug("Error while parsing datas. %s", e.msg );
if ( fatalError ) {
bug("FATAL error. Bye!");
exit(-1);
}
else
return -1;
}
dump_GC_info();
return data_count;
}
void rrd_graph_script(
int argc,
char *argv[],
image_desc_t *const im,
int optno)
{
int i;
/* and now handle the things*/
parsedargs_t pa;
initParsedArguments(&pa);
/* loop arguments */
for (i = optno; i < argc; i++) {
/* release parsed args - avoiding late cleanups*/
freeParsedArguments(&pa);
/* processed parsed args */
if (parseArguments(argv[i],&pa)) {
return; }
/* dumpArguments(&pa); */
/* now let us handle the field based on the first command or cmd=...*/
char*cmd=NULL;
/* and try to get via cmd */
char* t=getKeyValueArgument("cmd",255,&pa);
if (t) {
cmd=t;
} else if ((t=getKeyValueArgument("pos0",255,&pa))) {
cmd=t;
} else {
rrd_set_error("no command set in argument %s",pa.arg_orig);
freeParsedArguments(&pa);
return;
}
/* convert to enum but handling LINE special*/
enum gf_en gf = (enum gf_en) -1;
gf=gf_conv(cmd);
if ((int)gf == -1) {
if (strncmp("LINE",cmd,4)==0) {
gf=GF_LINE;
addToArguments(&pa,NULL,"linewidth",cmd+4,0);
} else {
rrd_set_error("'%s' is not a valid function name in %s", cmd,pa.arg_orig );
return;
}
}
/* now we can handle the commands */
int r=0;
switch (gf) {
case GF_XAXIS: r=parse_axis(gf,&pa,im); break;
case GF_YAXIS: r=parse_axis(gf,&pa,im); break;
case GF_DEF: r=parse_def(gf,&pa,im); break;
case GF_CDEF: r=parse_cvdef(gf,&pa,im); break;
case GF_VDEF: r=parse_cvdef(gf,&pa,im); break;
case GF_LINE: r=parse_line(gf,&pa,im); break;
case GF_AREA: r=parse_area(gf,&pa,im); break;
case GF_PRINT: r=parse_gprint(gf,&pa,im); break;
case GF_GPRINT: r=parse_gprint(gf,&pa,im); break;
case GF_COMMENT: r=parse_comment(gf,&pa,im); break;
case GF_HRULE: r=parse_hvrule(gf,&pa,im); break;
case GF_VRULE: r=parse_hvrule(gf,&pa,im); break;
case GF_STACK: r=parse_stack(gf,&pa,im); break;
case GF_TICK: r=parse_tick(gf,&pa,im); break;
case GF_TEXTALIGN: r=parse_textalign(gf,&pa,im); break;
case GF_SHIFT: r=parse_shift(gf,&pa,im); break;
case GF_XPORT: r=parse_xport(gf,&pa,im); break;
/* unsupported types right now */
}
/* handle the return error case */
if (r) { freeParsedArguments(&pa); return;}
/* check for unprocessed keyvalue args */
char *s;
if ((s=checkUnusedValues(&pa))) {
/* set error message */
rrd_set_error("Unused Arguments \"%s\" in command : %s",s,pa.arg_orig);
free(s);
/* exit early */
freeParsedArguments(&pa);
return;
}
}
/* finally free arguments */
freeParsedArguments(&pa);
}
