From: Florian Liekweg Date: Mon, 11 Oct 2004 09:31:06 +0000 (+0000) Subject: First Import of XML reading procs --flo X-Git-Url: http://nsz.repo.hu/git/?a=commitdiff_plain;h=722704ea8f23bd2ffe846ee065f405ba99f07a71;p=libfirm First Import of XML reading procs --flo [r4093] --- diff --git a/ir/external/Makefile.in b/ir/external/Makefile.in new file mode 100644 index 000000000..498120cc9 --- /dev/null +++ b/ir/external/Makefile.in @@ -0,0 +1,36 @@ +# +# Project: libFIRM +# File name: ir/external/Makefile.in +# Purpose: +# Author: Florian Liekweg +# Modified by: +# Created: +# CVS-ID: $Id$ +# Copyright: (c) 1999-2003 Universität Karlsruhe +# Licence: This file is protected by GPL - GNU GENERAL PUBLIC LICENSE. +# + +# set LIBXML2 to the installation directory of libxml2 +# temporary fix until libxml is integrated: +LIBXML2 ?= invalid + +top_srcdir := @top_srcdir@ +srcdir = @srcdir@ +topdir = ../.. +subdir := ir/external + +INSTALL_HEADERS = read.h + +SOURCES = $(INSTALL_HEADERS) + +SOURCES += Makefile.in \ + read.c + +include $(topdir)/MakeRules + +CPPFLAGS += -I$(top_srcdir)/ir/tr \ + -I$(LIBXML2)/include/libxml2 + +include $(top_srcdir)/MakeTargets + +all: subdir.o diff --git a/ir/external/read.c b/ir/external/read.c new file mode 100644 index 000000000..cca73ac39 --- /dev/null +++ b/ir/external/read.c @@ -0,0 +1,790 @@ +/* -*- c -*- */ + +/* + configure libxml2 (default Linux libxml2.rpm doesn't cut it) + + ./configure --prefix=/afs/info.uni-karlsruhe.de/user//src/C/xml --with-gnu-ld --with-pic --with-output --with-tree --with-reader --with-pattern --with-writer --with-push --with-valid --with-catalog --with-xpath--with-xptr --with-c14n --with-xinclude --with-schemas --with-regexps --with-debug --with-mem-debug + + + gcc -g read.c -I../include/libxml2 -L../lib -lxml2 -o read + ./read .xml +*/ + +# include "read.h" + +static type_t *types = NULL; +static entity_t *entities = NULL; +static effs_t *effs = NULL; + +static int _ent_id = 0; +/* static int _node_id = 0; */ + +static const char* +getNodeModule (xmlNodePtr node) +{ + char *mod_str = (char*) xmlGetProp (node, BAD_CAST "module"); + + if (NULL == mod_str) { + return (NULL); + } else { + const char *res = strdup (mod_str); + + return (res); + } +} + +static char* +getNodeProcName (xmlNodePtr node) +{ + char *proc_str = (char*) xmlGetProp (node, BAD_CAST "procname"); + + assert (proc_str); + + return (strdup (proc_str)); +} + +static const int +getNodeId (xmlNodePtr node) +{ + char *id_str = (char*) xmlGetProp (node, BAD_CAST "id"); + int id; + assert (id_str); + id = atoi (id_str+1); + + return (id); +} + +static const int +getNodeRefId (xmlNodePtr node) +{ + char *refid_str = (char*) xmlGetProp (node, BAD_CAST "refid"); + int refid; + assert (refid_str); + refid = atoi (refid_str+1); + + return (refid); +} + +static const int +getNodeTypeId (xmlNodePtr node) +{ + char *type_str = (char*) xmlGetProp (node, BAD_CAST "type"); + int type_id; + assert (type_str); + type_id = atoi (type_str+1); + + return (type_id); +} + +static const char +*getNodeTypeStr (xmlNodePtr node) +{ + const char *type_str = (char*) xmlGetProp (node, BAD_CAST "type"); + assert (type_str); + + return (type_str); +} + +static const char +*getNodeEntityStr (xmlNodePtr node) +{ + const char *ent_str = (char*) xmlGetProp (node, BAD_CAST "entity"); + assert (ent_str); + + return (ent_str); +} + +static arg_t * +parseArg (xmlDocPtr doc, xmlNodePtr argelm) +{ + int id; + int num; + char *num_str; + arg_t *arg; + + CHECK_NAME (argelm, arg); + /* fprintf (stdout, "arg node \t0x%08x\n", (int) argelm); */ + + id = getNodeId (argelm); + /* fprintf (stdout, "arg->id = \"%d\"\n", id); */ + num_str = (char*) xmlGetProp (argelm, BAD_CAST "number"); + num = atoi (num_str); + /* fprintf (stdout, "arg->no = \"%d\"\n", no); */ + + arg = NEW (arg_t); + arg->kind = eff_arg; + arg->id = id; + arg->num = num; + + return (arg); +} + +static valref_t +*parseValref (xmlDocPtr doc, xmlNodePtr valelm) +{ + int ref_id; + valref_t *valref; + CHECK_NAME (valelm, valref); + /* fprintf (stdout, "valref node \t0x%08x\n", (int) valelm); */ + + ref_id = getNodeRefId (valelm); + /* fprintf (stdout, "val->refid = \"%d\"\n", ref_id); */ + + valref = NEW (valref_t); + valref->kind = eff_valref; + valref->refid = ref_id; + + return (valref); +} + +static select_t +*parseSelect (xmlDocPtr doc, xmlNodePtr selelm) +{ + char *entity_str = (char*) xmlGetProp (selelm, BAD_CAST "entity"); + const int entity_id = atoi (entity_str+1); + entity_t *ent; + xmlNodePtr child; + valref_t *valref = NULL; + select_t *sel = NEW (select_t); + sel->kind = eff_select; + + CHECK_NAME (selelm, select); + /* fprintf (stdout, "select node \t0x%08x\n", (int) selelm); */ + + ent = getEntityById (entity_id); + + child = selelm->xmlChildrenNode; + + if (child) { + valref = parseValref (doc, child); + } + + sel->valrefid = valref ? valref->refid : -1; + sel->ent = ent; + + if (valref) { + free (valref); + } + + return (sel); +} + +static load_t +*parseLoad (xmlDocPtr doc, xmlNodePtr loadelm) +{ + int id; + xmlNodePtr child; + select_t *sel; + load_t *load = NEW (load_t); + load->kind = eff_load; + + CHECK_NAME (loadelm, load); + /* fprintf (stdout, "load node \t0x%08x\n", (int) loadelm); */ + id = getNodeId (loadelm); + + child = loadelm->xmlChildrenNode; + + sel = parseSelect (doc, child); + + load->id = id; + load->ptrrefid = sel->valrefid; + load->ent = sel->ent; + + free (sel); + + return (load); +} + +static store_t +*parseStore (xmlDocPtr doc, xmlNodePtr storeelm) +{ + xmlNodePtr child; + select_t *sel; + valref_t *valref; + store_t *store = NEW (store_t); + store->kind = eff_store; + + CHECK_NAME (storeelm, store); + /* fprintf (stdout, "store node \t0x%08x\n", (int) storeelm); */ + + child = storeelm->xmlChildrenNode; + + sel = parseSelect (doc, child); + + child = child->next; + + valref = parseValref (doc, child); + + store->ent = sel->ent; + store->ptrrefid = sel->valrefid; + store->valrefid = valref->refid; + + free (sel); + free (valref); + + return (store); +} + +static alloc_t +*parseAlloc (xmlDocPtr doc, xmlNodePtr allocelm) +{ + int id; + int type_id; + alloc_t *alloc = NEW (alloc_t); /* ...! */ + alloc->kind = eff_alloc; + + CHECK_NAME (allocelm, alloc); + /* fprintf (stdout, "alloc node \t0x%08x\n", (int) allocelm); */ + id = getNodeId (allocelm); + /* fprintf (stdout, "alloc->id = \"%d\"\n", id); */ + type_id = getNodeTypeId (allocelm); + /* fprintf (stdout, "alloc->type_id = \"%d\"\n", type_id); */ + + alloc->id = id; + alloc->tp_id = type_id; + + return (alloc); +} + +static call_t +*parseCall (xmlDocPtr doc, xmlNodePtr callelm) +{ + int id; + xmlNodePtr child; + select_t *sel; + xmlNodePtr arg; + int n_args; + call_t *call = NEW (call_t); + call->kind = eff_call; + + CHECK_NAME (callelm, call); + /* fprintf (stdout, "call node \t0x%08x\n", (int) callelm); */ + id = getNodeId (callelm); + /* fprintf (stdout, "call->id = \"%d\"\n", id); */ + + child = callelm->xmlChildrenNode; + + sel = parseSelect (doc, child); + + arg = child = child->next; + + n_args = 0; + + while (NULL != child) { + n_args ++; + + child = child->next; + } + + call->id = id; + call->valrefid = sel->valrefid; + call->ent = sel->ent; + call->n_args = n_args; + call->args = NULL; + + free (sel); + + if (0 != n_args) { + int *args = (int*) malloc (n_args * sizeof (int) ); + int i = 0; + + while (NULL != arg) { + valref_t *valref = parseValref (doc, arg); + args [i ++] = valref->refid; + free (valref); + + arg = arg->next; + } + + call->args = args; + } + + return (call); +} + +static join_t +*parseJoin (xmlDocPtr doc, xmlNodePtr joinelm) +{ + int id; + int n_ins; + int *ins; + int i; + xmlNodePtr child; + join_t *join = NEW (join_t); + join->kind = eff_join; + + CHECK_NAME (joinelm, join); + /* fprintf (stdout, "join node \t0x%08x\n", (int) joinelm); */ + id = getNodeId (joinelm); + /* fprintf (stdout, "join->id = \"%d\"\n", id); */ + + child = joinelm->xmlChildrenNode; + + n_ins = 0; + + while (NULL != child) { + n_ins ++; + child = child->next; + } + + ins = (int*) malloc (n_ins * sizeof (int) ); + i = 0; + + child = joinelm->xmlChildrenNode; + + while (NULL != child) { + valref_t *valref = parseValref (doc, child); + ins [i ++] = valref->refid; + + child = child->next; + } + + join->id = id; + join->n_ins = n_ins; + join->ins = ins; + + return (join); +} + +static unknown_t +*parseUnknown (xmlDocPtr doc, xmlNodePtr unknownelm) +{ + int id; + unknown_t *unknown = NEW (unknown_t); + unknown->kind = eff_unknown; + + CHECK_NAME (unknownelm, unknown); + /* fprintf (stdout, "unknown node \t0x%08x\n", (int) unknownelm); */ + id = getNodeId (unknownelm); + + unknown->id = id; + + return (unknown); +} + +static ret_t +*parseReturn (xmlDocPtr doc, xmlNodePtr retelm) +{ + xmlNodePtr child; + ret_t *ret = NEW (ret_t); + ret->kind = eff_ret; + + CHECK_NAME (retelm, ret); + /* fprintf (stdout, "ret node \t0x%08x\n", (int) retelm); */ + + child = retelm->xmlChildrenNode; + + if (child) { + valref_t *valref = parseValref (doc, child); + ret->ret_id = valref->refid; + free (valref); + } else { + ret->ret_id = -1; + } + + return (ret); +} + +static raise_t +*parseRaise (xmlDocPtr doc, xmlNodePtr raiseelm) +{ + int tp_id; + valref_t *valref; + xmlNodePtr child; + raise_t *raise = NEW (raise_t); + raise->kind = eff_raise; + + CHECK_NAME (raiseelm, raise); + /* fprintf (stdout, "raise node \t0x%08x\n", (int) raiseelm); */ + + tp_id = getNodeTypeId (raiseelm); + /* fprintf (stdout, "raise->type = \"%d\"\n", tp_id); */ + + child = raiseelm->xmlChildrenNode; + + assert (NULL != child); + + valref = parseValref (doc, child); + + raise->valref = valref->refid; + raise->tp_id = tp_id; + + free (valref); + + return (raise); +} + +/* + Types and Entities +*/ + +/** parse a type node and insert it into the list */ +static void +parseType (xmlDocPtr doc, xmlNodePtr typeelm) +{ + type_t *type; + const int tp_id = getNodeId (typeelm); + /* fprintf (stdout, "type node \t0x%08x (%d)\n", (int) typeelm, tp_id); */ + fprintf (stdout, "type = \"%s\"\n", getNodeTypeStr (typeelm)); + + type = (type_t*) malloc (sizeof (type_t)); + + type->name = (char*) strdup (getNodeTypeStr (typeelm)); + type->id = tp_id; + + type->prev = types; + types = type; + + if (_ent_id <= tp_id) { + _ent_id = tp_id+1; + } +} + +/** parse an entity node and insert it into the list */ +static void +parseEntity (xmlDocPtr doc, xmlNodePtr entelm) +{ + entity_t *ent = NEW (entity_t); + + /* parse it */ + const int ent_id = getNodeId (entelm); + /* fprintf (stdout, "entity node \t0x%08x (%d)\n", (int) entelm, ent_id); */ + fprintf (stdout, "ent = \"%s.%s\"\n", + getNodeTypeStr (entelm), + getNodeEntityStr (entelm)); + + + ent->name = (char*) strdup (getNodeEntityStr (entelm)); + ent->tp_name = (char*) strdup (getNodeTypeStr (entelm)); + ent->id = ent_id; + + ent->prev = entities; + entities = ent; + + if (_ent_id <= ent_id) { + _ent_id = ent_id+1; + } +} + +/** parse any effect, and turn it into an eff_t (TODO) */ +static void +parseEffect (xmlDocPtr doc, xmlNodePtr effelm) +{ + xmlNodePtr cur = effelm->xmlChildrenNode; + char *procname = getNodeProcName (effelm); + effs_t *curr_effs = NULL; + int i = 0; + int n_effs = 0; + + fprintf (stdout, "effect for \"%s\"\n", procname); + + while (NULL != cur) { + n_effs ++; + cur = cur->next; + } + + curr_effs = NEW (effs_t); + curr_effs->procname = procname; + curr_effs->n_effs = n_effs; + curr_effs->effs = (eff_t**) malloc (n_effs * sizeof (eff_t*)); + + while (NULL != cur) { + eff_t *eff = NULL; + + if (NODE_NAME (cur, arg)) { + eff = (eff_t*) parseArg (doc, cur); + } else if (NODE_NAME (cur, load)) { + eff = (eff_t*) parseLoad (doc, cur); + } else if (NODE_NAME (cur, store)) { + eff = (eff_t*) parseStore (doc, cur); + } else if (NODE_NAME (cur, alloc)) { + eff = (eff_t*) parseAlloc (doc, cur); + } else if (NODE_NAME (cur, call)) { + eff = (eff_t*) parseCall (doc, cur); + } else if (NODE_NAME (cur, join)) { + eff = (eff_t*) parseJoin (doc, cur); + } else if (NODE_NAME (cur, unknown)) { + eff = (eff_t*) parseUnknown (doc, cur); + } else if (NODE_NAME (cur, ret)) { + eff = (eff_t*) parseReturn (doc, cur); + } else if (NODE_NAME (cur, raise)) { + eff = (eff_t*) parseRaise (doc, cur); + } else if (NODE_NAME (cur, comment)) { + /* comment */ + } else { + fprintf (stderr, "wrong element \"%s\"\n", BAD_CAST cur->name); + exit (EXIT_FAILURE); + } + + cur = cur->next; + + curr_effs->effs [i ++] = eff; + } + + curr_effs->next = effs; + effs = curr_effs; +} + +/* + Public Interface +*/ +type_t *getTypeByName (const char *name) +{ + type_t *curr = types; + + while (NULL != curr) { + if (0 == strcmp (name, curr->name)) { + return (curr); + } + + curr = curr->prev; + } + + return (NULL); +} + +type_t *getTypeById (const int id) +{ + type_t *curr = types; + + while (NULL != curr) { + if (id == curr->id) { + return (curr); + } + + curr = curr->prev; + } + + return (NULL); +} + +entity_t *getEntityByNames (const char *name, const char *tp_name) +{ + entity_t *curr = entities; + + while (NULL != curr) { + if ((0 == strcmp (name, curr->name)) && (0 == strcmp (tp_name, curr->tp_name))) { + return (curr); + } + + curr = curr->prev; + } + + return (NULL); +} + +entity_t *getEntityById (const int id) +{ + entity_t *curr = entities; + + while (NULL != curr) { + if (id == curr->id) { + return (curr); + } + + curr = curr->prev; + } + + return (NULL); +} + +effs_t *getEffectByName (const char *procname) +{ + effs_t *curr_effs = effs; + + while (NULL != curr_effs) { + if (0 == strcmp (procname, curr_effs->procname)) { + return (curr_effs); + } + + curr_effs = curr_effs->next; + } + + return (NULL); +} + +void read_extern (const char *filename) +{ + /* xmlNsPtr ns = NULL; */ /* no namespace for us */ + xmlDocPtr doc; /* whole document */ + xmlNodePtr cur; /* current node */ + /* i've got no idea what the VERSION cast is all about. voodoo + programming at its finest. */ + LIBXML_TEST_VERSION xmlKeepBlanksDefault (0); + doc = xmlParseFile (filename); + CHECK (doc, "xmlParseFile"); + + cur = xmlDocGetRootElement (doc); + CHECK (cur, "xmlDocGetRootElement"); + + if (! NODE_NAME (cur, effects)) { + fprintf (stderr,"root node \"%s\" != \"effects\"\n", BAD_CAST cur->name); + xmlFreeDoc (doc); + + exit (EXIT_FAILURE); + } + + { + const char *mod_str = getNodeModule (cur); + + if (NULL != mod_str) { + fprintf (stdout, "effects for \"%s\"\n", mod_str); + } else { + fprintf (stdout, "effects \t0x%08x\n", (int) cur); + } + } + + /* parse entities */ + cur = cur->xmlChildrenNode; + while (cur != NULL) { + if (NODE_NAME (cur, type)) { + parseType (doc, cur); + } else if (NODE_NAME (cur, entity)) { + parseEntity (doc, cur); + } else if (NODE_NAME (cur, effect)) { + parseEffect (doc, cur); + } else if ((NODE_NAME (cur, comment))) { + /* comment */ + } else { + fprintf (stderr, "wrong element \"%s\"\n", BAD_CAST cur->name); + exit (EXIT_FAILURE); + } + + cur = cur->next; + } +} + +void test_getEffectByName () +{ + /* test getEffectByName */ + char *names [] = { + "store_unknown_proc", + "rise_something", + "other_fake_proc", + "ret_alloc", + "mash_args", + "ret_arg", + "empty_external", + "no_this_doesn't_really_exist", + "my_fake_proc", + NULL + }; + + int i = 0; + + while (NULL != names [i]) { + effs_t *the_eff = getEffectByName (names [i]); + + if (the_eff) { + fprintf (stdout, "Effect for \"%s\" is at 0x%08x\n", + names [i], (int) the_eff); + } else { + fprintf (stdout, "Effect for \"%s\" not found\n", + names [i]); + } + i ++; + } +} + + +int +main (int argc, char **argv) +{ + /* xmlNsPtr ns = NULL; */ /* no namespace for us */ + xmlDocPtr doc; /* whole document */ + xmlNodePtr cur; /* current node */ + char *name; + + if (2 != argc) { + fprintf (stderr, "no filename\n"); + exit (EXIT_FAILURE); + } + + /* i've got no idea what the VERSION cast is all about. voodoo + programming at its finest. */ + LIBXML_TEST_VERSION xmlKeepBlanksDefault (0); + name = argv [1]; + doc = xmlParseFile (name); + + CHECK (doc, "xmlParseFile"); + + cur = xmlDocGetRootElement (doc); + CHECK (cur, "xmlDocGetRootElement"); + + if (! NODE_NAME (cur, effects)) { + fprintf (stderr,"root node \"%s\" != \"effects\"\n", BAD_CAST cur->name); + xmlFreeDoc (doc); + + exit (EXIT_FAILURE); + } + + { + const char *mod_str = getNodeModule (cur); + + if (NULL != mod_str) { + fprintf (stdout, "effects for \"%s\"\n", mod_str); + } else { + fprintf (stdout, "effects \t0x%08x\n", (int) cur); + } + } + + /* parse entities */ + cur = cur->xmlChildrenNode; + while (cur != NULL) { + if (NODE_NAME (cur, type)) { + parseType (doc, cur); + } else if (NODE_NAME (cur, entity)) { + parseEntity (doc, cur); + } else if (NODE_NAME (cur, effect)) { + parseEffect (doc, cur); + } else if ((NODE_NAME (cur, comment))) { + /* comment */ + } else { + fprintf (stderr, "wrong element \"%s\"\n", BAD_CAST cur->name); + exit (EXIT_FAILURE); + } + + cur = cur->next; + } + + /* test getEffectByName */ + { + char *names [] = { + "store_unknown_proc", + "rise_something", + "other_fake_proc", + "ret_alloc", + "mash_args", + "ret_arg", + "empty_external", + "no_this_doesn't_really_exist", + "my_fake_proc", + NULL + }; + + int i = 0; + + while (NULL != names [i]) { + effs_t *the_eff = getEffectByName (names [i]); + + if (the_eff) { + fprintf (stdout, "Effect for \"%s\" is at 0x%08x\n", + names [i], (int) the_eff); + } else { + fprintf (stdout, "Effect for \"%s\" not found\n", + names [i]); + } + i ++; + } + } + + exit (EXIT_SUCCESS); +} + + +/* + * $Log$ + * Revision 1.1 2004/10/11 09:31:06 liekweg + * First Import of XML reading procs --flo + * + */ diff --git a/ir/external/read.h b/ir/external/read.h new file mode 100644 index 000000000..042f8c760 --- /dev/null +++ b/ir/external/read.h @@ -0,0 +1,197 @@ +/* -*- c -*- */ + +#ifndef _READ_H_ +#define _READ_H_ + +#include +#include +#include +#include + +#include +#include +#include + +# ifndef _BSD_SOURCE +# define _BSD_SOURCE /* need strdup */ +# endif /* ! defined _BSD_SOURCE */ + +# define MY_ENCODING "ISO-8859-1" + +# define CHECK(ptr,msg) assert (ptr && msg) + +# define NODE_NAME(n, m) (0 == xmlStrcmp (n->name, (const xmlChar*) #m)) +# define CHECK_NAME(n, m) assert (0 == xmlStrcmp (n->name, (const xmlChar*) #m)) + +# define NEW(T) (T*) malloc (sizeof (T)) + +/* first, the xml structures */ + +typedef struct type_str +{ + const char *name; + int id; + void *f_tp; /* firm type */ + struct type_str *prev; +} type_t; + +typedef struct entity_str +{ + const char *name; + const char *tp_name; + int id; + void *f_ent; /* firm entity */ + struct entity_str *prev; +} entity_t; + +/* now the xml nodes */ +typedef enum eff_node_kind { + eff_arg, + eff_valref, + eff_select, + eff_load, + eff_store, + eff_alloc, + eff_call, + eff_unknown, + eff_join, + eff_raise, + eff_ret +} eff_node_kind_t; + +/* dummy type for all other effects */ +typedef struct eff_str +{ + eff_node_kind_t kind; + /* struct eff_str *next; */ +} eff_t; + +typedef struct effs_str +{ + char *procname; + int n_effs; + eff_t **effs; + struct effs_str *next; +} effs_t; + +typedef struct arg_str +{ + eff_node_kind_t kind; + /* struct eff_str *next; */ + int id; + int num; +} arg_t; + +typedef struct valref_str +{ + eff_node_kind_t kind; + /* struct eff_str *next; */ + int refid; +} valref_t; + +typedef struct select_str +{ + eff_node_kind_t kind; + /* struct eff_str *next; */ + int valrefid; /* id of enclosed valref node, or -1 */ + entity_t *ent; +} select_t; + +typedef struct load_str +{ + eff_node_kind_t kind; + /* struct eff_str *next; */ + int id; + int ptrrefid; /* id of valref node enclosed in select, or -1 */ + entity_t *ent; +} load_t; + +typedef struct store_str +{ + eff_node_kind_t kind; + /* struct eff_str *next; */ + int ptrrefid; /* id of ptr valref node enclosed in select, or -1 */ + int valrefid; /* id of val valref node enclosed in select, or -1 */ + entity_t *ent; +} store_t; + +typedef struct alloc_str +{ + eff_node_kind_t kind; + int id; + int tp_id; +} alloc_t; + +typedef struct call_str +{ + eff_node_kind_t kind; + /* struct eff_str *next; */ + int id; + int valrefid; /* id of enclosed valref node, or -1 */ + entity_t *ent; /* called entity */ + int n_args; + int *args; +} call_t; + +typedef struct unknown_str +{ + eff_node_kind_t kind; + /* struct eff_str *next; */ + int id; +} unknown_t; + +typedef struct join_str +{ + eff_node_kind_t kind; + /* struct eff_str *next; */ + int id; + int n_ins; + int *ins; +} join_t; + +typedef struct ret_str +{ + eff_node_kind_t kind; + /* struct eff_str *next; */ + int ret_id; +} ret_t; /* returned value, or -1 */ + +typedef struct raise_str +{ + eff_node_kind_t kind; + /* struct eff_str *next; */ + int valref; /* what was that one for? */ + int tp_id; +} raise_t; + +/* + The public interface +*/ + +/** get the type entry with the given name */ +type_t *getTypeByName (const char*); + +/** get the type entry with the given Id */ +type_t *getTypeById (const int); + +/** get the entity entry that has the given names */ +entity_t *getEntityByNames (const char*, const char*); + +/** get the entity entry that has the given Id */ +entity_t *getEntityById (const int); + +/** get the effect entry for the given name */ +effs_t *getEffectByName (const char*); + +/** read in the file of the given name */ +void read_extern (const char*); + + +#endif /* defined _READ_H_ */ + +/* + $Log$ + Revision 1.1 2004/10/11 09:31:06 liekweg + First Import of XML reading procs --flo + +*/