new access routines, some documentation/comments,

some new fields.

[r219]

diff --git a/ir/tr/entity.h b/ir/tr/entity.h
index c153a81..43b3558 100644 (file)
--- a/ir/tr/entity.h
+++ b/ir/tr/entity.h
@@ -66,6 +66,24 @@ void init_entity (void);
 typedef struct ir_graph ir_graph;
 #endif
 
+/****s* entity/entity
+ *
+ * NAME
+ *   entity - An abstract data type to represent program entites.
+ * NOTE
+ *
+ *   ... not documented ...
+ *
+ * ATTRIBUTES
+ *
+ *
+ *  These fields can only be accessed via access functions.
+ *
+ * SEE ALSO
+ *   type
+ * SOURCE
+ */
+
 #ifndef _ENTITY_TYPEDEF_
 #define _ENTITY_TYPEDEF_
 /* to resolve recursion between entity.h and type.h */
@@ -84,7 +102,8 @@ entity     *copy_entity_own (entity *old, type *new_owner);
    Automatically inserts the new entity as a member of owner.
    The mangled name ld_name is set to NULL. */
 entity     *copy_entity_name (entity *old, ident *new_name);
-/* manipulate fields of entity */
+
+/** manipulate fields of entity **/
 const char *get_entity_name     (entity *ent);
 ident      *get_entity_ident    (entity *ent);
 /* returns the mangled name of the entity.  If the mangled name is
@@ -134,10 +153,23 @@ void           set_entity_visibility (entity *ent, ent_visibility vis);
 int       get_entity_offset (entity *ent);
 void      set_entity_offset (entity *ent, int offset);
 
+/* Overwrites is a field that specifies that an access to the overwritten
+   entity in the supertype must use this entity.  It's a list as with
+   multiple inheritance several enitites can be overwritten.  This field
+   is mostly useful for method entities. */
+void    add_entity_overwrites   (entity *ent, entity *overwritten);
+int     get_entity_n_overwrites (entity *ent);
+entity *get_entity_overwrites   (entity *ent, int pos);
+void    set_entity_overwrites   (entity *ent, int pos, entity *overwritten);
+/* Do we need a second relation "overwritten"? */
+
 /* The entity knows the corresponding irg if the entity is a method.
    This allows to get from a Call to the called irg. */
 ir_graph *get_entity_irg(entity *ent);
 void      set_entity_irg(entity *ent, ir_graph *irg);
 
 
+
+/*****/
+
 # endif /* _ENTITY_H_ */

diff --git a/ir/tr/type.c b/ir/tr/type.c
index 08b53f2..d7b2127 100644 (file)
--- a/ir/tr/type.c
+++ b/ir/tr/type.c
@@ -183,10 +183,20 @@ void    set_class_member   (type *clss, entity *member, int pos) {
   assert(clss && (clss->type_op == type_class));
   clss->attr.ca.members[pos+1] = member;
 }
+void    remove_class_member(type *clss, entity *member) {
+  int i;
+  assert(clss && (clss->type_op == type_class));
+  for (i = 1; i < (ARR_LEN (clss->attr.ca.members))-1; i++)
+    if (clss->attr.ca.members[i+1] == member) {
+      clss->attr.ca.members[i+1] = NULL;
+      break;
+    }
+}
 
 void    add_class_subtype   (type *clss, type *subtype) {
   assert(clss && (clss->type_op == type_class));
   ARR_APP1 (type *, clss->attr.ca.subtypes, subtype);
+  ARR_APP1 (type *, subtype->attr.ca.supertypes, clss);
 }
 int     get_class_n_subtype (type *clss) {
   assert(clss && (clss->type_op == type_class));
@@ -200,10 +210,20 @@ void    set_class_subtype   (type *clss, type *subtype, int pos) {
   assert(clss && (clss->type_op == type_class));
   clss->attr.ca.subtypes[pos+1] = subtype;
 }
+void    remove_class_subtype(type *clss, type *subtype) {
+  int i;
+  assert(clss && (clss->type_op == type_class));
+  for (i = 1; i < (ARR_LEN (clss->attr.ca.subtypes))-1; i++)
+    if (clss->attr.ca.subtypes[i+1] == subtype) {
+      clss->attr.ca.subtypes[i+1] = NULL;
+      break;
+    }
+}
 
 void    add_class_supertype   (type *clss, type *supertype) {
   assert(clss && (clss->type_op == type_class));
   ARR_APP1 (type *, clss->attr.ca.supertypes, supertype);
+  ARR_APP1 (type *, supertype->attr.ca.subtypes, clss);
 }
 int     get_class_n_supertype (type *clss) {
   assert(clss && (clss->type_op == type_class));
@@ -217,6 +237,15 @@ void    set_class_supertype   (type *clss, type *supertype, int pos) {
   assert(clss && (clss->type_op == type_class));
   clss->attr.ca.supertypes[pos+1] = supertype;
 }
+void    remove_class_supertype(type *clss, type *supertype) {
+  int i;
+  assert(clss && (clss->type_op == type_class));
+  for (i = 1; i < (ARR_LEN (clss->attr.ca.supertypes))-1; i++)
+    if (clss->attr.ca.supertypes[i+1] == supertype) {
+      clss->attr.ca.supertypes[i+1] = NULL;
+      break;
+    }
+}
 /* typecheck */
 bool    is_class_type(type *clss) {
   assert(clss);
@@ -251,6 +280,15 @@ void    set_struct_member   (type *strct, int pos, entity *member) {
   assert(strct && (strct->type_op == type_struct));
   strct->attr.sa.members[pos+1] = member;
 }
+void    remove_struct_member(type *strct, entity *member) {
+  int i;
+  assert(strct && (strct->type_op == type_struct));
+  for (i = 1; i < (ARR_LEN (strct->attr.ca.members))-1; i++)
+    if (strct->attr.ca.members[i+1] == member) {
+      strct->attr.ca.members[i+1] = NULL;
+      break;
+    }
+}
 /* typecheck */
 bool    is_struct_type(type *strct) {
   assert(strct);
@@ -363,6 +401,15 @@ void   set_union_member (type *uni, int pos, entity *member) {
   assert(uni && (uni->type_op == type_union));
   uni->attr.ua.members[pos+1] = member;
 }
+void   remove_union_member(type *uni, entity *member) {
+  int i;
+  assert(uni && (uni->type_op == type_union));
+  for (i = 1; i < (ARR_LEN (uni->attr.ca.members))-1; i++)
+    if (uni->attr.ca.members[i+1] == member) {
+      uni->attr.ca.members[i+1] = NULL;
+      break;
+    }
+}
 
 /* typecheck */
 bool   is_union_type         (type *uni) {

diff --git a/ir/tr/type.h b/ir/tr/type.h
index 44a7f50..2f62c4e 100644 (file)
--- a/ir/tr/type.h
+++ b/ir/tr/type.h
@@ -190,21 +190,48 @@ int is_type            (void *thing);
 /* create a new class type */
 type   *new_type_class (ident *name);
 
-/* manipulate private fields of class type  */
+/** manipulate private fields of class type  **/
+/* Adds the entity as member of the class.  */
 void    add_class_member   (type *clss, entity *member);
+/* Returns the number of members of this class. */
 int     get_class_n_member (type *clss);
+/* Returns the member at position pos, 0 <= pos < n_member */
 entity *get_class_member   (type *clss, int pos);
+/* Overwrites the member at position pos, 0 <= pos < n_member with
+   the passed entity. */
 void    set_class_member   (type *clss, entity *member, int pos);
+/* Finds member in the list of members and overwrites it with NULL */
+void    remove_class_member(type *clss, entity *member);
 
+
+/* Adds subtype as subtype to clss and also
+   clss as supertype to subtype */
 void    add_class_subtype   (type *clss, type *subtype);
+/* Returns the number of subtypes */
 int     get_class_n_subtype (type *clss);
+/* Gets the subtype at position pos, 0 <= pos < n_subtype. */
 type   *get_class_subtype   (type *clss, int pos);
+/* Sets the subtype at positioin pos, 0 <= pos < n_subtype.  Does not
+   set the corresponding supertype relation for subtype: this might
+   be a different position! */
 void    set_class_subtype   (type *clss, type *subtype, int pos);
+/* Finds subtype in the list of subtypes and overwrites it with NULL */
+void    remove_class_subtype(type *clss, type *subtype);
+
 
+/* Adds supertype as supertype to class and also
+   class as subtype to supertype. */
 void    add_class_supertype   (type *clss, type *supertype);
+/* Returns the number of supertypes */
 int     get_class_n_supertype (type *clss);
+/* Gets the supertype at position pos,  0 <= pos < n_supertype. */
 type   *get_class_supertype   (type *clss, int pos);
+/* Sets the supertype at postition pos, 0 <= pos < n_subtype.  Does not
+   set the corresponding subtype relation for supertype: this might
+   be a different position! */
 void    set_class_supertype   (type *clss, type *supertype, int pos);
+/* Finds supertype in the list of supertypes and overwrites it with NULL */
+void    remove_class_supertype(type *clss, type *supertype);
 
 /* typecheck */
 bool    is_class_type(type *clss);
@@ -235,6 +262,8 @@ void    add_struct_member   (type *strct, entity *member);
 int     get_struct_n_member (type *strct);
 entity *get_struct_member   (type *strct, int pos);
 void    set_struct_member   (type *strct, int pos, entity *member);
+/* Finds member in the list of memberss and overwrites it with NULL */
+void    remove_struct_member (type *strct, entity *member);
 
 /* typecheck */
 bool    is_struct_type(type *strct);
@@ -307,6 +336,7 @@ int     get_union_n_members      (type *uni);
 void    add_union_member (type *uni, entity *member);
 entity *get_union_member (type *uni, int pos);
 void    set_union_member (type *uni, int pos, entity *member);
+void    remove_union_member (type *uni, entity *member);
 
 /* typecheck */
 bool    is_union_type          (type *uni);

diff --git a/ir/tr/typewalk.h b/ir/tr/typewalk.h
index 6b023f6..f6f67aa 100644 (file)
--- a/ir/tr/typewalk.h
+++ b/ir/tr/typewalk.h
@@ -19,12 +19,15 @@
 # include "type_or_entity.h"
 
 
-/** dumps all type information reachable from global roots **/
+/** Walks over all type information reachable from global roots.
+    Touches every type and entity in unspecified order.  If new
+    types/entities are created during the traversal these will
+    be visited, too. **/
 void type_walk(void (pre)(type_or_ent*, void*),
               void (post)(type_or_ent*, void*),
               void *env);
 
-/** dumps all type information reachable from irg **/
+/** walks over all type information reachable from irg **/
 void type_walk_irg(ir_graph *irg,
                   void (pre)(type_or_ent*, void*),
                   void (post)(type_or_ent*, void*),