more access functions

[r5743]

diff --git a/ir/tr/type.c b/ir/tr/type.c
index b913925..01c50ed 100644 (file)
--- a/ir/tr/type.c
+++ b/ir/tr/type.c
@@ -826,6 +826,14 @@ type   *get_class_subtype   (type *clss, int pos) {
   assert(pos >= 0 && pos < get_class_n_subtypes(clss));
   return clss->attr.ca.subtypes[pos] = skip_tid(clss->attr.ca.subtypes[pos]);
 }
+int     get_class_subtype_index(type *clss, const type *subclass) {
+  int i, n_subtypes = get_class_n_subtypes(clss);
+  assert(is_Class_type(subclass));
+  for (i = 0; i < n_subtypes; ++i) {
+    if (get_class_subtype(clss, i) == subclass) return i;
+  }
+  return -1;
+}
 void    set_class_subtype   (type *clss, type *subtype, int pos) {
   assert(clss && (clss->type_op == type_class));
   assert(pos >= 0 && pos < get_class_n_subtypes(clss));
@@ -859,10 +867,9 @@ int     get_class_n_supertypes (const type *clss) {
   return (ARR_LEN (clss->attr.ca.supertypes));
 }
 int get_class_supertype_index(type *clss, type *super_clss) {
-  int i;
-  assert(clss && (clss->type_op == type_class));
+  int i, n_supertypes = get_class_n_supertypes(clss);
   assert(super_clss && (super_clss->type_op == type_class));
-  for (i = 0; i < get_class_n_supertypes(clss); i++)
+  for (i = 0; i < n_supertypes; i++)
     if (get_class_supertype(clss, i) == super_clss)
       return i;
   return -1;
@@ -890,14 +897,14 @@ void    remove_class_supertype(type *clss, type *supertype) {
 }
 
 const char *get_peculiarity_string(peculiarity p) {
+#define X(a)    case a: return #a
   switch (p) {
-  case peculiarity_description:
-    return "peculiarity_description";
-  case peculiarity_inherited:
-    return "peculiarity_inherited";
-  default:
-    return "peculiarity_existent";
+    X(peculiarity_description);
+    X(peculiarity_inherited);
+    X(peculiarity_existent);
   }
+#undef X
+  return "invalid peculiarity";
 }
 
 peculiarity get_class_peculiarity (const type *clss) {

diff --git a/ir/tr/type.h b/ir/tr/type.h
index ce5e1ed..1be0a49 100644 (file)
--- a/ir/tr/type.h
+++ b/ir/tr/type.h
@@ -432,6 +432,12 @@ int     get_class_n_subtypes (const type *clss);
 /** Gets the subtype at position pos, 0 <= pos < n_subtype. */
 type   *get_class_subtype   (type *clss, int pos);
 
+/** Returns the index to access subclass as subtype of class.
+ *
+ *  If subclass is no direct subtype of class returns -1.
+ */
+int get_class_subtype_index(type *clss, const type *subclass);
+
 /** Sets the subtype at position pos, 0 <= pos < n_subtype.
  *
  *  Does not set the corresponding supertype relation for subtype: this might
@@ -451,7 +457,10 @@ void    add_class_supertype   (type *clss, type *supertype);
 /** Returns the number of supertypes */
 int     get_class_n_supertypes (const type *clss);
 
-/** Returns the index of an supertype in a type. */
+/** Returns the index to access superclass as supertype of class.
+ *
+ *  If superclass is no direct supertype of class returns -1.
+ */
 int     get_class_supertype_index(type *clss, type *super_clss);
 
 /** Gets the supertype at position pos,  0 <= pos < n_supertype. */