static struct xmllog_entry *
parse_logentry(struct xml_tree *node)
{
struct xmllog_entry *pe = (struct xmllog_entry*) node;
struct xml_attn *pa;
struct xml_tree *p;
int v, n;
if (!is_empty_text(node)) return 0;
pe->revision = -1;
for (pa = pe->b.first; pa; pa = pa->next) {
if (pa->tag == A_REVISION) {
if (sscanf(pa->text, "%d%n", &v, &n) != 1 || pa->text[n])
return attr_err(pa, "cannot parse attribute value");
if (v < 0)
return attr_err(pa, "invalid attribute value");
pe->revision = v;
} else {
return attr_err(pa, "unexpected attribute");
}
}
if (pe->revision < 0)
return elem_err(node, "attribute revision is undefined");
for (p = pe->b.first_down; p; p = p->right) {
switch (p->tag) {
case T_AUTHOR:
if (p->first) return elem_err(p, "attributes are not allowed");
if (p->first_down)
return elem_err(p, "nested elements are not allowed");
if (pe->author) return elem_err(p, "author already defined");
pe->author = p->text;
p->text = 0;
break;
case T_DATE:
if (p->first) return elem_err(p, "attributes are not allowed");
if (p->first_down)
return elem_err(p, "nested elements are not allowed");
if (pe->date.year) return elem_err(p, "date already defined");
if (parse_date(p, p->text, &pe->date) < 0) return 0;
break;
case T_PATHS:
if (!parse_paths(p, pe)) return 0;
break;
case T_MSG:
if (p->first) return elem_err(p, "attributes are not allowed");
if (p->first_down)
return elem_err(p, "nested elements are not allowed");
if (pe->msg) return elem_err(p, "msg already defined");
pe->msg = p->text;
p->text = 0;
break;
default:
return elem_err(p, "unexpected element");
}
}
if (!pe->author) return elem_err(node, "author is not defined");
return pe;
}
w_query *w_query_parse(w_root_t *root, json_t *query, char **errmsg)
{
w_query *res;
*errmsg = NULL;
res = calloc(1, sizeof(*res));
if (!res) {
*errmsg = strdup("out of memory");
goto error;
}
res->refcnt = 1;
res->case_sensitive = root->case_sensitive;
if (!parse_sync(res, query)) {
goto error;
}
if (!parse_relative_root(root, res, query)) {
goto error;
}
if (!parse_empty_on_fresh_instance(res, query)) {
goto error;
}
/* Look for path generators */
if (!parse_paths(res, query)) {
goto error;
}
/* Look for suffix generators */
if (!parse_suffixes(res, query)) {
goto error;
}
/* Look for since generator */
if (!parse_since(res, query)) {
goto error;
}
if (!parse_query_expression(res, query)) {
goto error;
}
return res;
error:
if (res) {
*errmsg = res->errmsg;
res->errmsg = NULL;
w_query_delref(res);
}
if (!*errmsg) {
*errmsg = strdup("unspecified error");
}
return NULL;
}
/**
* topo: An array of strings, the maximum length is 5000
* edge_num: The number of elements in topo
* demand: The demand
*/
void search_route(char* topo[5000], int edge_num, char* demand) {
struct path* paths;
struct node nodes[MAX_NODE_NUMBERS] = {};
unsigned int start_index, end_index, via_nodes_count;
paths = (struct path*) malloc(edge_num * sizeof(struct path));
parse_paths(topo, (unsigned int) edge_num, paths, nodes);
parse_nodes((unsigned int) edge_num, paths);
parse_demand(demand, nodes, &start_index, &end_index, &via_nodes_count);
perform_actual_search((unsigned int) edge_num, &nodes[start_index], &nodes[end_index], via_nodes_count);
free(paths);
}
std::shared_ptr<w_query> w_query_parse(
const std::shared_ptr<w_root_t>& root,
const json_ref& query) {
auto result = std::make_shared<w_query>();
auto res = result.get();
parse_benchmark(res, query);
parse_case_sensitive(res, root, query);
parse_sync(res, query);
parse_dedup(res, query);
parse_lock_timeout(res, query);
parse_relative_root(root, res, query);
parse_empty_on_fresh_instance(res, query);
/* Look for path generators */
parse_paths(res, query);
/* Look for glob generators */
parse_globs(res, query);
/* Look for suffix generators */
parse_suffixes(res, query);
/* Look for since generator */
parse_since(res, query);
parse_query_expression(res, query);
parse_request_id(res, query);
parse_field_list(query.get_default("fields"), &res->fieldList);
res->query_spec = query;
return result;
}
int read_level(int lev)
{
char filename[MAXFILENAME];
char readline[MAXLINE];
char *data;
int gotPaths = 0, gotShapes = 0, gotDelays = 0;
int elem;
FILE* lf;
static int maxLevel = 1;
snprintf(filename, MAXFILENAME, "%s/levels/level%d.xgl", DATADIR, lev);
filename[MAXFILENAME-1] = '\0';
lf = fopen(filename, "r");
if(!lf) {
/* Dont use recursion, to avoid stack overflow if start level is
* very high (or the game is played for a _very_ long time. :-)
* -- JEH */
for (lev = lev - maxLevel; lev > 0 && ! lf ;lev = lev - maxLevel) {
metaLevel++;
/* real_level_path is already set, so.. */
snprintf(filename, MAXFILENAME, "%s/levels/level%d.xgl", DATADIR, lev);
filename[MAXFILENAME-1] = '\0';
lf = fopen(filename, "r");
}
//fprintf(stderr, "Can't open level file %s\n", filename);
//return read_level(lev - maxLevel);
}
if(lev > maxLevel)
maxLevel = lev;
while(!feof(lf)) {
if(get_line(lf, readline) <= 0) {
if(gotShapes && gotPaths && gotDelays) {
return 1;
}
fprintf(stderr, "Error reading level file %s:\n", filename);
if(!gotShapes)
fprintf(stderr, " Missing shapes\n");
if(!gotPaths)
fprintf(stderr, " Missing paths\n");
if(!gotDelays)
fprintf(stderr, " Missing delays\n");
fclose(lf);
return 0;
}
switch((get_token(readline, &elem, &data))) {
case PF_PATHDEF:
parse_path(elem, data);
break;
case PF_SHAPES:
gotShapes = parse_shapes(data);
break;
case PF_PATHS:
gotPaths = parse_paths(data);
break;
case PF_DELAYS:
gotDelays = parse_delays(data);
break;
default:
break;
}
}
fclose(lf);
if(gotShapes && gotPaths && gotDelays) {
return 1;
}
return 0;
}
