5 * File name: ir/external/read.c
6 * Purpose: Read descriptions of external effects
11 * Copyright: (c) 1999-2004 Universität Karlsruhe
12 * Licence: This file is protected by GPL - GNU GENERAL PUBLIC LICENSE.
18 static type_t *types = NULL;
19 static entity_t *entities = NULL;
20 static effs_t *effs = NULL;
22 static int _ent_id = 0;
23 /* static int _node_id = 0; */
26 getNodeModule (xmlNodePtr node)
28 const char *mod_str = (const char*) xmlGetProp (node, BAD_CAST "module");
30 if (NULL == mod_str) {
33 const char *res = strdup (mod_str);
40 getNodeProcName (xmlNodePtr node)
42 char *proc_str = (char*) xmlGetProp (node, BAD_CAST "procname");
46 return (strdup (proc_str));
50 getNodeId (xmlNodePtr node)
52 char *id_str = (char*) xmlGetProp (node, BAD_CAST "id");
61 getNodeRefId (xmlNodePtr node)
63 char *refid_str = (char*) xmlGetProp (node, BAD_CAST "refid");
66 refid = atoi (refid_str+1);
72 getNodeTypeId (xmlNodePtr node)
74 char *type_str = (char*) xmlGetProp (node, BAD_CAST "type");
77 type_id = atoi (type_str+1);
83 *getNodeTypeStr (xmlNodePtr node)
85 const char *type_str = (char*) xmlGetProp (node, BAD_CAST "type");
92 *getNodeEntityStr (xmlNodePtr node)
94 const char *ent_str = (char*) xmlGetProp (node, BAD_CAST "entity");
101 parseArg (xmlDocPtr doc, xmlNodePtr argelm)
108 CHECK_NAME (argelm, arg);
109 /* fprintf (stdout, "arg node \t0x%08x\n", (int) argelm); */
111 id = getNodeId (argelm);
112 /* fprintf (stdout, "arg->id = \"%d\"\n", id); */
113 num_str = (char*) xmlGetProp (argelm, BAD_CAST "number");
114 num = atoi (num_str);
115 /* fprintf (stdout, "arg->no = \"%d\"\n", no); */
126 *parseValref (xmlDocPtr doc, xmlNodePtr valelm)
130 CHECK_NAME (valelm, valref);
131 /* fprintf (stdout, "valref node \t0x%08x\n", (int) valelm); */
133 ref_id = getNodeRefId (valelm);
134 /* fprintf (stdout, "val->refid = \"%d\"\n", ref_id); */
136 valref = NEW (valref_t);
137 valref->kind = eff_valref;
138 valref->refid = ref_id;
144 *parseSelect (xmlDocPtr doc, xmlNodePtr selelm)
146 char *entity_str = (char*) xmlGetProp (selelm, BAD_CAST "entity");
147 const int entity_id = atoi (entity_str+1);
150 valref_t *valref = NULL;
151 select_t *sel = NEW (select_t);
152 sel->kind = eff_select;
154 CHECK_NAME (selelm, select);
155 /* fprintf (stdout, "select node \t0x%08x\n", (int) selelm); */
157 ent = getEntityById (entity_id);
159 child = selelm->xmlChildrenNode;
162 valref = parseValref (doc, child);
165 sel->valrefid = valref ? valref->refid : -1;
176 *parseLoad (xmlDocPtr doc, xmlNodePtr loadelm)
181 load_t *load = NEW (load_t);
182 load->kind = eff_load;
184 CHECK_NAME (loadelm, load);
185 /* fprintf (stdout, "load node \t0x%08x\n", (int) loadelm); */
186 id = getNodeId (loadelm);
188 child = loadelm->xmlChildrenNode;
190 sel = parseSelect (doc, child);
193 load->ptrrefid = sel->valrefid;
194 load->ent = sel->ent;
202 *parseStore (xmlDocPtr doc, xmlNodePtr storeelm)
207 store_t *store = NEW (store_t);
208 store->kind = eff_store;
210 CHECK_NAME (storeelm, store);
211 /* fprintf (stdout, "store node \t0x%08x\n", (int) storeelm); */
213 child = storeelm->xmlChildrenNode;
215 sel = parseSelect (doc, child);
219 valref = parseValref (doc, child);
221 store->ent = sel->ent;
222 store->ptrrefid = sel->valrefid;
223 store->valrefid = valref->refid;
232 *parseAlloc (xmlDocPtr doc, xmlNodePtr allocelm)
236 alloc_t *alloc = NEW (alloc_t); /* ...! */
237 alloc->kind = eff_alloc;
239 CHECK_NAME (allocelm, alloc);
240 /* fprintf (stdout, "alloc node \t0x%08x\n", (int) allocelm); */
241 id = getNodeId (allocelm);
242 /* fprintf (stdout, "alloc->id = \"%d\"\n", id); */
243 type_id = getNodeTypeId (allocelm);
244 /* fprintf (stdout, "alloc->type_id = \"%d\"\n", type_id); */
247 alloc->tp_id = type_id;
253 *parseCall (xmlDocPtr doc, xmlNodePtr callelm)
260 call_t *call = NEW (call_t);
261 call->kind = eff_call;
263 CHECK_NAME (callelm, call);
264 /* fprintf (stdout, "call node \t0x%08x\n", (int) callelm); */
265 id = getNodeId (callelm);
266 /* fprintf (stdout, "call->id = \"%d\"\n", id); */
268 child = callelm->xmlChildrenNode;
270 sel = parseSelect (doc, child);
272 arg = child = child->next;
276 while (NULL != child) {
283 call->valrefid = sel->valrefid;
284 call->ent = sel->ent;
285 call->n_args = n_args;
291 int *args = (int*) malloc (n_args * sizeof (int) );
294 while (NULL != arg) {
295 valref_t *valref = parseValref (doc, arg);
296 args [i ++] = valref->refid;
309 *parseJoin (xmlDocPtr doc, xmlNodePtr joinelm)
316 join_t *join = NEW (join_t);
317 join->kind = eff_join;
319 CHECK_NAME (joinelm, join);
320 /* fprintf (stdout, "join node \t0x%08x\n", (int) joinelm); */
321 id = getNodeId (joinelm);
322 /* fprintf (stdout, "join->id = \"%d\"\n", id); */
324 child = joinelm->xmlChildrenNode;
328 while (NULL != child) {
333 ins = (int*) malloc (n_ins * sizeof (int) );
336 child = joinelm->xmlChildrenNode;
338 while (NULL != child) {
339 valref_t *valref = parseValref (doc, child);
340 ins [i ++] = valref->refid;
353 *parseUnknown (xmlDocPtr doc, xmlNodePtr unknownelm)
356 unknown_t *unknown = NEW (unknown_t);
357 unknown->kind = eff_unknown;
359 CHECK_NAME (unknownelm, unknown);
360 /* fprintf (stdout, "unknown node \t0x%08x\n", (int) unknownelm); */
361 id = getNodeId (unknownelm);
369 *parseReturn (xmlDocPtr doc, xmlNodePtr retelm)
372 ret_t *ret = NEW (ret_t);
375 CHECK_NAME (retelm, ret);
376 /* fprintf (stdout, "ret node \t0x%08x\n", (int) retelm); */
378 child = retelm->xmlChildrenNode;
381 valref_t *valref = parseValref (doc, child);
382 ret->ret_id = valref->refid;
392 *parseRaise (xmlDocPtr doc, xmlNodePtr raiseelm)
397 raise_t *raise = NEW (raise_t);
398 raise->kind = eff_raise;
400 CHECK_NAME (raiseelm, raise);
401 /* fprintf (stdout, "raise node \t0x%08x\n", (int) raiseelm); */
403 tp_id = getNodeTypeId (raiseelm);
404 /* fprintf (stdout, "raise->type = \"%d\"\n", tp_id); */
406 child = raiseelm->xmlChildrenNode;
408 assert (NULL != child);
410 valref = parseValref (doc, child);
412 raise->valref = valref->refid;
413 raise->tp_id = tp_id;
424 /** parse a type node and insert it into the list */
426 parseType (xmlDocPtr doc, xmlNodePtr typeelm)
429 const int tp_id = getNodeId (typeelm);
430 /* fprintf (stdout, "type node \t0x%08x (%d)\n", (int) typeelm, tp_id); */
431 fprintf (stdout, "type = \"%s\"\n", getNodeTypeStr (typeelm));
433 type = (type_t*) malloc (sizeof (type_t));
435 type->name = (char*) strdup (getNodeTypeStr (typeelm));
441 if (_ent_id <= tp_id) {
446 /** parse an entity node and insert it into the list */
448 parseEntity (xmlDocPtr doc, xmlNodePtr entelm)
450 entity_t *ent = NEW (entity_t);
453 const int ent_id = getNodeId (entelm);
454 /* fprintf (stdout, "entity node \t0x%08x (%d)\n", (int) entelm, ent_id); */
455 fprintf (stdout, "ent = \"%s.%s\"\n",
456 getNodeTypeStr (entelm),
457 getNodeEntityStr (entelm));
460 ent->name = (char*) strdup (getNodeEntityStr (entelm));
461 ent->tp_name = (char*) strdup (getNodeTypeStr (entelm));
464 ent->prev = entities;
467 if (_ent_id <= ent_id) {
472 /** parse any effect, and turn it into an eff_t (TODO) */
474 parseEffect (xmlDocPtr doc, xmlNodePtr effelm)
476 xmlNodePtr cur = effelm->xmlChildrenNode;
477 char *procname = getNodeProcName (effelm);
478 effs_t *curr_effs = NULL;
482 fprintf (stdout, "effect for \"%s\"\n", procname);
484 while (NULL != cur) {
489 curr_effs = NEW (effs_t);
490 curr_effs->procname = procname;
491 curr_effs->n_effs = n_effs;
492 curr_effs->effs = (eff_t**) malloc (n_effs * sizeof (eff_t*));
494 while (NULL != cur) {
497 if (NODE_NAME (cur, arg)) {
498 eff = (eff_t*) parseArg (doc, cur);
499 } else if (NODE_NAME (cur, load)) {
500 eff = (eff_t*) parseLoad (doc, cur);
501 } else if (NODE_NAME (cur, store)) {
502 eff = (eff_t*) parseStore (doc, cur);
503 } else if (NODE_NAME (cur, alloc)) {
504 eff = (eff_t*) parseAlloc (doc, cur);
505 } else if (NODE_NAME (cur, call)) {
506 eff = (eff_t*) parseCall (doc, cur);
507 } else if (NODE_NAME (cur, join)) {
508 eff = (eff_t*) parseJoin (doc, cur);
509 } else if (NODE_NAME (cur, unknown)) {
510 eff = (eff_t*) parseUnknown (doc, cur);
511 } else if (NODE_NAME (cur, ret)) {
512 eff = (eff_t*) parseReturn (doc, cur);
513 } else if (NODE_NAME (cur, raise)) {
514 eff = (eff_t*) parseRaise (doc, cur);
515 } else if (NODE_NAME (cur, comment)) {
518 fprintf (stderr, "wrong element \"%s\"\n", BAD_CAST cur->name);
524 curr_effs->effs [i ++] = eff;
527 curr_effs->next = effs;
534 type_t *getTypeByName (const char *name)
536 type_t *curr = types;
538 while (NULL != curr) {
539 if (0 == strcmp (name, curr->name)) {
549 type_t *getTypeById (const int id)
551 type_t *curr = types;
553 while (NULL != curr) {
554 if (id == curr->id) {
564 entity_t *getEntityByNames (const char *name, const char *tp_name)
566 entity_t *curr = entities;
568 while (NULL != curr) {
569 if ((0 == strcmp (name, curr->name)) && (0 == strcmp (tp_name, curr->tp_name))) {
579 entity_t *getEntityById (const int id)
581 entity_t *curr = entities;
583 while (NULL != curr) {
584 if (id == curr->id) {
594 effs_t *getEffectByName (const char *procname)
596 effs_t *curr_effs = effs;
598 while (NULL != curr_effs) {
599 if (0 == strcmp (procname, curr_effs->procname)) {
603 curr_effs = curr_effs->next;
614 void extern_read (const char *filename)
616 /* xmlNsPtr ns = NULL; */ /* no namespace for us */
617 xmlDocPtr doc; /* whole document */
618 xmlNodePtr cur; /* current node */
620 /* i've got no idea what the VERSION cast is all about. voodoo
621 programming at its finest. */
622 LIBXML_TEST_VERSION xmlKeepBlanksDefault (0);
623 doc = xmlParseFile (filename);
624 CHECK (doc, "xmlParseFile");
626 cur = xmlDocGetRootElement (doc);
627 CHECK (cur, "xmlDocGetRootElement");
629 if (! NODE_NAME (cur, effects)) {
630 fprintf (stderr,"root node \"%s\" != \"effects\"\n", BAD_CAST cur->name);
636 if (EXTERN_VERBOSE) {
637 const char *mod_str = getNodeModule (cur);
639 if (NULL != mod_str) {
640 fprintf (stdout, "effects for \"%s\"\n", mod_str);
641 free ((char*) mod_str);
643 fprintf (stdout, "effects \t0x%08x\n", (int) cur);
648 cur = cur->xmlChildrenNode;
649 while (cur != NULL) {
650 if (NODE_NAME (cur, type)) {
651 parseType (doc, cur);
652 } else if (NODE_NAME (cur, entity)) {
653 parseEntity (doc, cur);
654 } else if (NODE_NAME (cur, effect)) {
655 parseEffect (doc, cur);
656 } else if ((NODE_NAME (cur, comment))) {
659 fprintf (stderr, "wrong element \"%s\"\n", BAD_CAST cur->name);
667 /** clean up our mess */
668 void extern_cleanup ()
678 free ((char*) curr->name);
679 memset (curr, 0x00, sizeof (type_t));
688 entity_t *ent = entities;
690 while (NULL != ent) {
691 entity_t *curr = ent;
694 free ((char*) curr->name);
695 free ((char*) curr->tp_name);
696 memset (curr, 0x00, sizeof (entity_t));
707 while (NULL != eff) {
712 for (i = 0; i < curr->n_effs; i ++) {
713 free (curr->effs [i]);
724 void test_getEffectByName (void)
726 /* test getEffectByName */
728 "store_unknown_proc",
735 "no_this_doesn't_really_exist",
742 while (NULL != names [i]) {
743 effs_t *the_eff = getEffectByName (names [i]);
746 fprintf (stdout, "Effect for \"%s\" is at 0x%08x\n",
747 names [i], (int) the_eff);
749 fprintf (stdout, "Effect for \"%s\" not found\n",
761 * Revision 1.6 2004/10/21 11:12:11 liekweg
764 * Revision 1.5 2004/10/18 12:48:20 liekweg
767 * Revision 1.4 2004/10/14 11:31:53 liekweg
770 * Revision 1.3 2004/10/13 13:36:28 rubino
773 * Revision 1.2 2004/10/11 15:56:09 liekweg
774 * Cleanup, comments ...
775 * Added init func --flo
777 * Revision 1.1 2004/10/11 09:31:06 liekweg
778 * First Import of XML reading procs --flo