};
#endif /* defined VERBOSE_PRINTING */
-static const ident*
+static ident*
getNodeModuleIdent (xmlNodePtr node)
{
const char *mod_str = (const char*) xmlGetProp (node, BAD_CAST "module");
if (NULL == mod_str) {
return (NULL);
} else {
- const ident *res = new_id_from_str (mod_str);
+ ident *res = new_id_from_str (mod_str);
return (res);
}
}
*/
# ifdef NEEDED
static
-type_t *getTypeByIdent (const ident *id)
+type_t *getTypeByIdent (ident *id)
{
type_t *curr = types; // @@@ TODO module -> types
# ifdef NEEDED
static
-type_t *getTypeById (const ident *id)
+type_t *getTypeById (ident *id)
{
type_t *curr = types; // which ones?
# ifdef NEEDED
static
-entity_t *getEntityByIdents (const ident *name, const ident *tp_ident)
+entity_t *getEntityByIdents (ident *name, ident *tp_ident)
{
entity_t *curr = entities; // TODO module -> entities
# endif /* defined NEEDED */
static
-entity_t *getEntityById (const ident *id)
+entity_t *getEntityById (ident *id)
{
entity_t *curr = entities;
# ifdef NEEDED
static
-proc_t *getEffectByName (const ident *proc_ident)
+proc_t *getEffectByName (ident *proc_ident)
{
proc_t *curr_effs = procs;
static eff_t*
parseSelect (xmlDocPtr doc, xmlNodePtr selelm)
{
- const ident *entity_id = new_id_from_str(getNodeEntityStr (selelm));
+ ident *entity_id = new_id_from_str(getNodeEntityStr (selelm));
entity_t *ent;
xmlNodePtr child;
eff_t *valref = NULL;
static eff_t*
parseLoad (xmlDocPtr doc, xmlNodePtr loadelm)
{
- const ident *id;
+ ident *id;
xmlNodePtr child;
eff_t *sel;
eff_t *load = NEW (eff_t);
static eff_t*
parseAlloc (xmlDocPtr doc, xmlNodePtr allocelm)
{
- const ident *id;
- const ident *type_id;
+ ident *id;
+ ident *type_id;
eff_t *alloc = NEW (eff_t); /* ...! */
alloc->kind = eff_alloc;
static eff_t*
parseCall (xmlDocPtr doc, xmlNodePtr callelm)
{
- const ident *id;
+ ident *id;
xmlNodePtr child;
eff_t *sel;
xmlNodePtr arg;
free (sel);
if (0 != n_args) {
- const ident **args = (const ident**) xmalloc(n_args * sizeof(const ident*));
+ ident **args = (ident**) xmalloc(n_args * sizeof(ident*));
int i = 0;
while (NULL != arg) {
static eff_t*
parseJoin (xmlDocPtr doc, xmlNodePtr joinelm)
{
- const ident *id;
+ ident *id;
int n_ins;
- const ident **ins;
+ ident **ins;
int i;
xmlNodePtr child;
eff_t *join = NEW (eff_t);
child = child->next;
}
- ins = (const ident **) xmalloc (n_ins * sizeof (const ident *) );
+ ins = (ident **) xmalloc (n_ins * sizeof (ident *) );
i = 0;
child = get_valid_child(joinelm);
static eff_t*
parseUnknown (xmlDocPtr doc, xmlNodePtr unknownelm)
{
- const ident *id;
+ ident *id;
eff_t *unknown = NEW (eff_t);
unknown->kind = eff_unknown;
/********************************************************************/
static
-type_t *find_type_in_module(module_t *module, const ident *typeid)
+type_t *find_type_in_module(module_t *module, ident *typeid)
{
type_t *type;
}
-eff_t *find_valueid_in_proc_effects(const ident *id, proc_t *proc)
+eff_t *find_valueid_in_proc_effects(ident *id, proc_t *proc)
{
eff_t *val;
\f
/*
* $Log$
+ * Revision 1.26 2006/12/15 12:37:40 matze
+ * fix warnings
+ *
* Revision 1.25 2006/06/09 11:26:35 firm
* renamed type to ir_type
*
typedef struct type_str
{
- const ident *type_ident;
- const ident *id; /* id for references */
+ ident *type_ident;
+ ident *id; /* id for references */
ir_type *f_tp; /* firm type */
struct type_str *prev;
} type_t;
typedef struct entity_str
{
- const ident *ent_ident; /* name of entity */
- const ident *tp_ident; /* name of type/class */
- const ident *id; /* id for references */
- const ident *owner; /* id of owner */
- entity *f_ent; /* firm entity */
+ ident *ent_ident; /* name of entity */
+ ident *tp_ident; /* name of type/class */
+ ident *id; /* id for references */
+ ident *owner; /* id of owner */
+ entity *f_ent; /* firm entity */
struct entity_str *prev;
} entity_t;
typedef struct arg_str
{
- const ident *type_ident;
+ ident *type_ident;
int num;
} arg_t;
typedef struct load_str
{
- const ident *ptrrefid; /* id of valref node enclosed in select, or -1 */
+ ident *ptrrefid; /* id of valref node enclosed in select, or -1 */
entity_t *ent;
} load_t;
typedef struct store_str
{
- const ident *ptrrefid; /* id of ptr valref node enclosed in select, or -1 */
- const ident *valrefid; /* id of val valref node enclosed in select, or -1 */
+ ident *ptrrefid; /* id of ptr valref node enclosed in select, or -1 */
+ ident *valrefid; /* id of val valref node enclosed in select, or -1 */
entity_t *ent;
} store_t;
typedef struct alloc_str
{
- const ident *tp_id;
+ ident *tp_id;
} alloc_t;
typedef struct call_str
{
- const ident *valrefid; /* id of enclosed valref node, or -1 */
- entity_t *ent; /* called entity */
+ ident *valrefid; /* id of enclosed valref node, or -1 */
+ entity_t *ent; /* called entity */
int n_args;
- const ident **args;
+ ident **args;
} call_t;
typedef struct unknown_str
typedef struct join_str
{
int n_ins;
- const ident **ins;
+ ident **ins;
} join_t;
typedef struct ret_str
{
- const ident *ret_id;
+ ident *ret_id;
} ret_t; /* returned value, or NO_ID */
typedef struct raise_str
{
- const ident *valref; /* what was that one for? */
- const ident *tp_id;
+ ident *valref; /* what was that one for? */
+ ident *tp_id;
} raise_t;
/* dummy type for all other effects */
typedef struct eff_str
{
eff_node_kind_t kind;
- const ident *id; /* identifier to access this node */
+ ident *id; /* identifier to access this node */
union {
arg_t arg;
valref_t valref;
typedef struct proc_str
{
- const ident *proc_ident; /* name of procedure */
- const ident *ownerid;
+ ident *proc_ident; /* name of procedure */
+ ident *ownerid;
int n_effs;
eff_t **effs;
struct proc_str *next;
typedef struct mod_str
{
- const ident *id;
+ ident *id;
type_t *types; /* types in module *//* @@@ TODO hash set */
entity_t *entities; /* entities in module *//* @@@ TODO hash set */
proc_t *procs; /* methods with effects */
/*
$Log$
+ Revision 1.4 2006/12/15 12:37:40 matze
+ fix warnings
+
Revision 1.3 2006/06/09 11:26:35 firm
renamed type to ir_type