# ifndef _TYPE_H_
# define _TYPE_H_
-# include <stdbool.h>
+#include <stdbool.h>
# include "tpop.h"
# include "firm_common.h"
* - name: An identifier specifying the name of the type. To be
* set by the frontend.
* - size: The size of the type, i.e. an entity of this type will
- * occupy size bytes in memory. In several cases this is
+ * occupy size bits in memory. In several cases this is
* determined when fixing the layout of this type (class,
* struct, union, array, enumeration).
+ * - alignment The alignment of the type, i.e. an entity of this type will
+ * be allocated an an address in memory with this alignment.
+ * In several cases this is determined when fixing the layout
+ * of this type (class, struct, union, array)
* - state: The state of the type. The state represents whether the
* layout of the type is undefined or fixed (values: layout_undefined
* or layout_fixed). Compound types can have an undefined
* 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 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
* 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"
* 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.
* - *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);
* 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;
-/* Returns the none 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.
*