# ifndef _TYPE_H_
# define _TYPE_H_
-# include <stdbool.h>
+#include <stdbool.h>
# include "tpop.h"
# include "firm_common.h"
* that refers to this type. */
void free_type(type *tp);
-tp_op* get_type_tpop(const type *tp);
+const tp_op*get_type_tpop(const type *tp);
ident* get_type_tpop_nameid(const type *tp);
const char* get_type_tpop_name(const type *tp);
tp_opcode get_type_tpop_code(const type *tp);
/** Returns the alignment of a type in bits. If the alignment of a type is
* not set, it is calculated here according to the following rules:
- * 1.) if a type has a mode, the aligment is the mode size.
+ * 1.) if a type has a mode, the alignment is the mode size.
* 2.) compound types have the alignment of it's biggest member.
* 3.) array types have the alignment of its element type.
* 4.) method types return 0 here.
* This is to avoid endless recursions; with pointer types circlic
* type graphs are possible.)
*/
-bool equal_type(type *tpy1, type *typ2);
+int equal_type(type *tpy1, type *typ2);
/**
* Checks whether two types are structural comparable.
* @return smaller than the points_to type of lt.
*
*/
-bool smaller_type (type *st, type *lt);
+int smaller_type (type *st, type *lt);
/**
* @page class_type Representation of a class type
* - supertypes: A list of direct superclasses.
*
* - peculiarity: The peculiarity of this class. If the class is of peculiarity
- * "description" it only is a description of requirememts to a class,
+ * "description" it only is a description of requirements to a class,
* as, e.g., a Java interface. The class will never be allocated.
- * Peculiatity inherited is only possible for entities. An entity
+ * Peculiarity inherited is only possible for entities. An entity
* is of peculiarity inherited if the compiler generated the entity
* to explicitly resolve inheritance. An inherited method entity has
* no value for irg.
/** 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.
+/** Sets the subtype at position 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);
/** 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.
+/** Sets the supertype at position 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);
typedef enum peculiarity {
peculiarity_description, /**< Represents only a description. The entity/type is never
allocated, no code/data exists for this entity/type.
- @@@ eventually rename to descriptive (adjectiv as the others!)*/
+ @@@ eventually rename to descriptive (adjective as the others!)*/
peculiarity_inherited, /**< Describes explicitly that other entities are
inherited to the owner of this entity.
Overwrites must refer to at least one other
int get_class_dfn (const type *clss);
/** Returns true if a type is a class type. */
-int is_class_type(const type *clss);
+int is_Class_type(const type *clss);
/** Returns true if low is subclass of high. */
-bool is_subclass_of(type *low, type *high);
+int is_subclass_of(type *low, type *high);
/**
* @page struct_type Representation of a struct type
void remove_struct_member (type *strct, entity *member);
/** Returns true if a type is a struct type. */
-int is_struct_type(const type *strct);
+int is_Struct_type(const type *strct);
/**
* @page method_type Representation of a method type
* method type) that represent results passed by value.
*/
-/* These makros define the suffixes for the types and entities used
+/* These macros define the suffixes for the types and entities used
to represent value parameters / results. */
#define VALUE_PARAMS_SUFFIX "val_param"
#define VALUE_RESS_SUFFIX "val_res"
void set_method_first_variadic_param_index(type *method, int index);
/** Returns true if a type is a method type. */
-int is_method_type (const type *method);
+int is_Method_type (const type *method);
/**
* @page union_type Representation of a union type.
void remove_union_member (type *uni, entity *member);
/** Returns true if a type is a union type. */
-int is_union_type (const type *uni);
+int is_Union_type (const type *uni);
/**
* @page array_type Representation of an array type
* element selection with Sel.
* @todo
* Do we need several entities? One might want
- * to select a dimension and not a single element in case of multidim arrays.
+ * to select a dimension and not a single element in case of multi
+ * dimensional arrays.
*/
/** Create a new type array.
/** Returns the number of array dimensions of this type. */
int get_array_n_dimensions (const type *array);
-/** Allocates Const nodes of mode_I for the array dimensions */
+/**
+ * Allocates Const nodes of mode_I for one array dimension.
+ * Upper bound in Firm is the element next to the last, ie [lower,upper[
+ */
void set_array_bounds_int (type *array, int dimension, int lower_bound,
int upper_bound);
+/**
+ * Sets the bounds for one array dimension.
+ * Upper bound in Firm is the element next to the last, ie [lower,upper[
+ */
void set_array_bounds (type *array, int dimension, ir_node *lower_bound,
ir_node *upper_bound);
+/** Sets the lower bound for one array dimension, ie [lower,upper[ */
void set_array_lower_bound (type *array, int dimension, ir_node *lower_bound);
+
+/** Allocates Const nodes of mode_I for the lower bound of an array
+ dimension, ie [lower,upper[ */
void set_array_lower_bound_int (type *array, int dimension, int lower_bound);
+
+/** Sets the upper bound for one array dimension, ie [lower,upper[ */
void set_array_upper_bound (type *array, int dimension, ir_node *upper_bound);
-void set_array_upper_bound_int (type *array, int dimension, int lower_bound);
+
+/** Allocates Const nodes of mode_I for the upper bound of an array
+ dimension, ie [lower,upper[ */
+void set_array_upper_bound_int (type *array, int dimension, int upper_bound);
+
/** returns true if lower bound != Unknown */
int has_array_lower_bound (const type *array, int dimension);
ir_node * get_array_lower_bound (const type *array, int dimension);
entity *get_array_element_entity (const type *array);
/** Returns true if a type is an array type. */
-int is_array_type(const type *array);
+int is_Array_type(const type *array);
/**
* @page enumeration_type Representation of an enumeration type
* - *enum: The target values representing the constants used to
* represent individual enumerations.
* - *enum_nameid: Idents containing the source program name of the enumeration
- * constants
+ * constants
*/
/** Create a new type enumeration -- set the enumerators independently. */
type *new_type_enumeration (ident *name, int n_enums);
const char *get_enumeration_name(const type *enumeration, int pos);
/** Returns true if a type is a enumeration type. */
-int is_enumeration_type (const type *enumeration);
+int is_Enumeration_type (const type *enumeration);
/**
* @page pointer_type Representation of a pointer type
type *get_pointer_points_to_type (type *pointer);
/** Returns true if a type is a pointer type. */
-int is_pointer_type (const type *pointer);
+int is_Pointer_type (const type *pointer);
/** Returns the first pointer type that has as points_to tp.
* Not efficient: O(#types).
type *new_d_type_primitive (ident *name, ir_mode *mode, dbg_info* db);
/** Returns true if a type is a primitive type. */
-int is_primitive_type (const type *primitive);
+int is_Primitive_type (const type *primitive);
/**
* size: 0
*/
/* A variable that contains the only none type. */
-extern type *none_type;
+extern type *firm_none_type;
/* Returns the none type */
type *get_none_type(void);
* size: 0
*/
/* A variable that contains the only unknown type. */
-extern type *unknown_type;
+extern type *firm_unknown_type;
/* Returns the unknown type */
type *get_unknown_type(void);
/**
* Gets the number of elements in a firm compound type.
*
- * This is just a comforability function, because structs and
+ * This is just a comfortability function, because structs and
* classes can often be treated be the same code, but they have
* different access functions to their members.
*