Modi umbenannt

[libfirm] / ir / tr / type.c

diff --git a/ir/tr/type.c b/ir/tr/type.c
index 8cef725..9aaab6a 100644 (file)
--- a/ir/tr/type.c
+++ b/ir/tr/type.c
@@ -764,9 +764,9 @@ bool    is_struct_type(type *strct) {
    N_param is the number of parameters, n_res the number of results.  */
 INLINE type *new_type_method (ident *name, int n_param, int n_res) {
   type *res;
-  res = new_type(type_method, mode_p, name);
+  res = new_type(type_method, mode_P, name);
   res->state = layout_fixed;
-  res->size = get_mode_size(mode_p);
+  res->size = get_mode_size(mode_P);
   res->attr.ma.n_params   = n_param;
   res->attr.ma.param_type = (type **) xmalloc (sizeof (type *) * n_param);
   res->attr.ma.n_res      = n_res;
@@ -793,10 +793,10 @@ type *get_method_param_type(type *method, int pos) {
   assert(pos >= 0 && pos < get_method_n_params(method));
   return method->attr.ma.param_type[pos] = skip_tid(method->attr.ma.param_type[pos]);
 }
-void  set_method_param_type(type *method, int pos, type* type) {
+void  set_method_param_type(type *method, int pos, type* tp) {
   assert(method && (method->type_op == type_method));
   assert(pos >= 0 && pos < get_method_n_params(method));
-  method->attr.ma.param_type[pos] = type;
+  method->attr.ma.param_type[pos] = tp;
 }
 
 int   get_method_n_ress   (type *method) {
@@ -808,10 +808,10 @@ type *get_method_res_type(type *method, int pos) {
   assert(pos >= 0 && pos < get_method_n_ress(method));
   return method->attr.ma.res_type[pos] = skip_tid(method->attr.ma.res_type[pos]);
 }
-void  set_method_res_type(type *method, int pos, type* type) {
+void  set_method_res_type(type *method, int pos, type* tp) {
   assert(method && (method->type_op == type_method));
   assert(pos >= 0 && pos < get_method_n_ress(method));
-  method->attr.ma.res_type[pos] = type;
+  method->attr.ma.res_type[pos] = tp;
 }
 
 /* typecheck */
@@ -826,7 +826,7 @@ bool  is_method_type     (type *method) {
 /*******************************************************************/
 
 /* create a new type uni */
-INLINE type  *new_type_uni (ident *name) {
+INLINE type  *new_type_union (ident *name) {
   type *res;
   res = new_type(type_union, NULL, name);
   /*res->attr.ua.unioned_type = (type **)  xmalloc (sizeof (type *)  * n_types);
@@ -834,8 +834,8 @@ INLINE type  *new_type_uni (ident *name) {
   res->attr.ua.members = NEW_ARR_F (entity *, 1);
   return res;
 }
-type  *new_d_type_uni (ident *name, dbg_info* db) {
-  type *res = new_type_uni (name);
+type  *new_d_type_union (ident *name, dbg_info* db) {
+  type *res = new_type_union (name);
   set_type_dbg_info(res, db);
   return res;
 }
@@ -854,10 +854,10 @@ type  *get_union_unioned_type (type *uni, int pos) {
   assert(pos >= 0 && pos < get_union_n_types(uni));
   return uni->attr.ua.unioned_type[pos] = skip_tid(uni->attr.ua.unioned_type[pos]);
 }
-void   set_union_unioned_type (type *uni, int pos, type *type) {
+void   set_union_unioned_type (type *uni, int pos, type *tp) {
   assert(uni && (uni->type_op == type_union));
   assert(pos >= 0 && pos < get_union_n_types(uni));
-  uni->attr.ua.unioned_type[pos] = type;
+  uni->attr.ua.unioned_type[pos] = tp;
 }
 ident *get_union_delim_nameid (type *uni, int pos) {
   assert(uni && (uni->type_op == type_union));
@@ -969,8 +969,8 @@ set_array_bounds_int (type *array, int dimension, int lower_bound,
   ir_graph *rem = current_ir_graph;
   current_ir_graph = get_const_code_irg();
   set_array_bounds (array, dimension,
-                   new_Const(mode_I, tarval_from_long (mode_I, lower_bound)),
-                   new_Const(mode_I, tarval_from_long (mode_I, upper_bound)));
+                   new_Const(mode_Iu, tarval_from_long (mode_Iu, lower_bound)),
+                   new_Const(mode_Iu, tarval_from_long (mode_Iu, upper_bound)));
   current_ir_graph = rem;
 }
 INLINE void
@@ -982,7 +982,7 @@ void  set_array_lower_bound_int (type *array, int dimension, int lower_bound) {
   ir_graph *rem = current_ir_graph;
   current_ir_graph = get_const_code_irg();
   set_array_lower_bound  (array, dimension,
-                         new_Const(mode_I, tarval_from_long (mode_I, lower_bound)));
+                         new_Const(mode_Iu, tarval_from_long (mode_Iu, lower_bound)));
   current_ir_graph = rem;
 }
 INLINE void
@@ -994,7 +994,7 @@ void  set_array_upper_bound_int (type *array, int dimension, int upper_bound) {
   ir_graph *rem = current_ir_graph;
   current_ir_graph = get_const_code_irg();
   set_array_upper_bound  (array, dimension,
-                         new_Const(mode_I, tarval_from_long (mode_I, upper_bound)));
+                         new_Const(mode_Iu, tarval_from_long (mode_Iu, upper_bound)));
   current_ir_graph = rem;
 }
 ir_node * get_array_lower_bound  (type *array, int dimension) {
@@ -1015,10 +1015,10 @@ int  get_array_order (type *array, int dimension) {
   return array->attr.aa.order[dimension];
 }
 
-void  set_array_element_type (type *array, type *type) {
+void  set_array_element_type (type *array, type *tp) {
   assert(array && (array->type_op == type_array));
-  assert(!is_method_type(type));
-  array->attr.aa.element_type = type;
+  assert(!is_method_type(tp));
+  array->attr.aa.element_type = tp;
 }
 type *get_array_element_type (type *array) {
   assert(array && (array->type_op == type_array));
@@ -1116,7 +1116,7 @@ bool    is_enumeration_type     (type *enumeration) {
 /* Create a new type pointer */
 INLINE type *new_type_pointer           (ident *name, type *points_to) {
   type *res;
-  res = new_type(type_pointer, mode_p, name);
+  res = new_type(type_pointer, mode_P, name);
   res->attr.pa.points_to = points_to;
   res->size = get_mode_size(res->mode);
   res->state = layout_fixed;
@@ -1131,9 +1131,9 @@ INLINE void free_pointer_attrs (type *pointer) {
   assert(pointer && (pointer->type_op == type_pointer));
 }
 /* manipulate fields of type_pointer */
-void  set_pointer_points_to_type (type *pointer, type *type) {
+void  set_pointer_points_to_type (type *pointer, type *tp) {
   assert(pointer && (pointer->type_op == type_pointer));
-  pointer->attr.pa.points_to = type;
+  pointer->attr.pa.points_to = tp;
 }
 type *get_pointer_points_to_type (type *pointer) {
   assert(pointer && (pointer->type_op == type_pointer));
@@ -1154,7 +1154,7 @@ bool  is_pointer_type            (type *pointer) {
 /* create a new type primitive */
 INLINE type *new_type_primitive (ident *name, ir_mode *mode) {
   type *res;
-  /* @@@ assert( mode_is_data(mode) && (!mode == mode_p)); */
+  /* @@@ assert( mode_is_data(mode) && (!mode == mode_P)); */
   res = new_type(type_primitive, mode, name);
   res->size = get_mode_size(mode);
   res->state = layout_fixed;