all the autoconfig stuff

[libfirm] / ir / tr / type.c

diff --git a/ir/tr/type.c b/ir/tr/type.c
index d1d6dc4..1020e9c 100644 (file)
--- a/ir/tr/type.c
+++ b/ir/tr/type.c
@@ -1,3 +1,4 @@
+
 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
 ** All rights reserved.
 **
@@ -7,6 +8,10 @@
 ** type.c: datastructures to hold type information.
 */
 
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
 # include "type.h"
 # include "irprog.h"  /* So that constructors can add the type to global
                         data structure. */
@@ -25,7 +30,7 @@ init (void)
 /*******************************************************************/
 
 type_class *
-new_type_class (ident *name)//, int members)
+new_type_class (ident *name) /*, int members) */
 {
   type_class *res;
 
@@ -45,113 +50,126 @@ new_type_class (ident *name)//, int members)
 
 /* manipulate fields of type_class */
 const char *
-get_class_name  (type_class *class) {
-  assert(class);
-  return id_to_str(class->name);
+get_class_name  (type_class *clss) {
+  assert(clss);
+  return id_to_str(clss->name);
 }
 
 /* field: ident */
 ident *
-get_class_ident (type_class *class) {
-  assert(class);
-  return class->name;
+get_class_ident (type_class *clss) {
+  assert(clss);
+  return clss->name;
 }
 
 /*
-void   set_class_name  (type_class *class, char *name);
-void   set_class_ident (type_class *class, ident* ident);
+void   set_class_name  (type_class *clss, char *name);
+void   set_class_ident (type_class *clss, ident* ident);
 */
 
 /* field: member */
 void
-add_class_member (type_class *class, entity *member)
+add_class_member (type_class *clss, entity *member)
 {
-  ARR_APP1 (entity *, class->members, member);
+  ARR_APP1 (entity *, clss->members, member);
 }
 
 entity *
-get_class_member (type_class *class, int pos)
+get_class_member (type_class *clss, int pos)
 {
-  assert (class);
-  return class->members[pos+1];
+  assert (clss);
+  return clss->members[pos+1];
 }
 
 void
-set_class_member (type_class *class, entity *member, int pos)
+set_class_member (type_class *clss, entity *member, int pos)
 {
-  class->members[pos+1] = member;
+  clss->members[pos+1] = member;
 }
 
 int
-get_class_n_member (type_class *class)
+get_class_n_member (type_class *clss)
 {
   int res;
 
-  assert(class);
-  res = (ARR_LEN (class->members))-1;
+  assert(clss);
+  res = (ARR_LEN (clss->members))-1;
   return res;
 }
 
 /* field: subtype */
 void
-add_class_subtype (type_class *class,  type_class *subtype)
+add_class_subtype (type_class *clss,  type_class *subtype)
 {
-  ARR_APP1 (type_class *, class->subtypes, subtype);
+  ARR_APP1 (type_class *, clss->subtypes, subtype);
 }
 
 type_class *
-get_class_subtype (type_class *class, int pos)
+get_class_subtype (type_class *clss, int pos)
 {
-  assert (class);
-  return class->subtypes[pos+1];
+  assert (clss);
+  return clss->subtypes[pos+1];
 }
 
 void
-set_class_subtype (type_class *class, type_class *subtype, int pos)
+set_class_subtype (type_class *clss, type_class *subtype, int pos)
 {
-  class->subtypes[pos+1] = subtype;
+  clss->subtypes[pos+1] = subtype;
 }
 
 int
-get_class_n_subtype (type_class *class)
+get_class_n_subtype (type_class *clss)
 {
-  assert(class);
-  return (ARR_LEN (class->subtypes))-1;
+  assert(clss);
+  return (ARR_LEN (clss->subtypes))-1;
 }
 
 /* field: supertype */
 void
-add_class_supertype (type_class *class, type_class *supertype)
+add_class_supertype (type_class *clss, type_class *supertype)
 {
-  ARR_APP1 (type_class *, class->supertypes, supertype);
+  ARR_APP1 (type_class *, clss->supertypes, supertype);
 }
 
 type_class *
-get_class_supertype (type_class *class, int pos)
+get_class_supertype (type_class *clss, int pos)
 {
-  assert (class);
-  return class->supertypes[pos+1];
+  assert (clss);
+  return clss->supertypes[pos+1];
 }
 
 void
-set_class_supertype (type_class *class, type_class *supertype, int pos)
+set_class_supertype (type_class *clss, type_class *supertype, int pos)
 {
-  class->supertypes[pos+1] = supertype;
+  clss->supertypes[pos+1] = supertype;
 }
 
 int
-get_class_n_supertype (type_class *class)
+get_class_n_supertype (type_class *clss)
 {
-  assert(class);
-  return (ARR_LEN (class->supertypes))-1;
+  assert(clss);
+  return (ARR_LEN (clss->supertypes))-1;
+}
+
+int
+get_class_size (type_class *clss) {
+  assert(clss);
+  return clss->size;
 }
 
+void
+set_class_size (type_class *clss, int size) {
+  assert(clss);
+  clss->size = size;
+}
+
+
 /*******************************************************************/
 /** TYPE_STRCT                                                   **/
 /*******************************************************************/
 
 type_strct *
-new_type_strct (ident *name)//, int members)
+new_type_strct (ident *name) /*, int members) */
 {
   type_strct *res;
 
@@ -229,7 +247,8 @@ new_type_method (ident *name, int arity, int n_res)
   res = (type_method *) xmalloc (sizeof (type_method));
   add_irp_type((type *) res);   /* Remember the new type global. */
   res->kind = k_type_method;
-  res->name = name;   // do I need the name, or is the name in entity sufficient?
+
+  res->name = name;   /* do I need the name, or is the name in entity sufficient? */
   res->arity = arity;
   res->param_type = (type **) xmalloc (sizeof (type *) * arity);
   res->n_res  = n_res;
@@ -324,7 +343,7 @@ new_type_union (ident *name, int n_types)
   res = (type_union *) xmalloc (sizeof (type_union));
   add_irp_type((type *) res);   /* Remember the new type global. */
   res->kind = k_type_union;
-  res->name = name;   // do I need a name?
+  res->name = name;   /* do I need a name? */
   res->n_types = n_types;
   /*
   res->unioned_type = (int *) xmalloc (sizeof (int) * n_types);
@@ -577,14 +596,13 @@ new_type_primitive (ident *name, ir_mode *mode)
 }
 
 /* manipulate fields of type_primitive */
-/*
 
-char  *
+const char  *
 get_primitive_name  (type_primitive *primitive) {
   assert(primitive);
   return ID_TO_STR(primitive->name);
 }
-*/
+
 
 ident *
 get_primitive_ident (type_primitive *primitive) {
@@ -631,3 +649,51 @@ is_type(void *thing) {
   else
     return 0;
 }
+
+int
+is_type_class(void *thing) {
+  if (get_kind(thing) == k_type_class) return 1;
+  else return 0;
+}
+
+int
+is_type_strct(void *thing) {
+  if (get_kind(thing) == k_type_strct) return 1;
+  else return 0;
+}
+
+int
+is_type_method(void *thing) {
+  if (get_kind(thing) == k_type_method) return 1;
+  else return 0;
+}
+
+int
+is_type_union(void *thing) {
+  if (get_kind(thing) == k_type_union) return 1;
+  else return 0;
+}
+
+int
+is_type_array(void *thing) {
+  if (get_kind(thing) == k_type_array) return 1;
+  else return 0;
+}
+
+int
+is_type_pointer(void *thing) {
+  if (get_kind(thing) == k_type_pointer) return 1;
+  else return 0;
+}
+
+int
+is_type_enumeration(void *thing) {
+  if (get_kind(thing) == k_type_enumeration) return 1;
+  else return 0;
+}
+
+int
+is_type_primitive(void *thing) {
+  if (get_kind(thing) == k_type_primitive) return 1;
+  else return 0;
+}