void set_type_ident(type *tp, ident* id);
const char* get_type_name(type *tp);
-/** The state of a type layout. */
+/** The state of the type layout. */
typedef enum {
layout_undefined, /**< The layout of this type is not defined.
Address computation to access fields is not
void set_type_visited(type *tp, unsigned long num);
/* Sets visited field in type to type_visited. */
void mark_type_visited(type *tp);
-/* @@@ name clash!! bool type_visited(type *tp); */
-bool type_not_visited(type *tp);
+/* @@@ name clash!! int type_visited(type *tp); */
+int type_not_visited(type *tp);
void* get_type_link(type *tp);
void set_type_link(type *tp, void *l);
/** Returns index of mem in clss, -1 if not contained. */
int get_class_member_index(type *clss, entity *mem);
+/** Finds the member with name 'name'. If several members with the same
+ name returns one of them. Returns NULL if no member found. */
+entity *get_class_member_by_name(type *clss, ident *name);
+
/** Overwrites the member at position pos, 0 <= pos < n_member with
the passed entity. */
void set_class_member (type *clss, entity *member, int pos);
/** This enumeration flags the peculiarity of entities and types. */
typedef enum peculiarity {
peculiarity_description, /**< Represents only a description. The entity/type is never
- allocated, no code/data exists for this entity/type. */
+ allocated, no code/data exists for this entity/type.
+ @@@ eventually rename to descriptive (adjectiv 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
no irg for this entity, only for one of the
overwritten ones.
Only for entity. */
- peculiarity_existent /**< The entity/type (can) exist. */
+ peculiarity_existent /**< The entity/type (can) exist.
+ @@@ eventually rename to 'real' i.e., 'echt'
+ This serves better as opposition to description _and_ inherited.*/
} peculiarity;
char *get_peculiarity_string(peculiarity p);
/* The peculiarity of the class. The enumeration peculiarity is defined
in entity.h */
-INLINE peculiarity get_class_peculiarity (type *clss);
-INLINE void set_class_peculiarity (type *clss, peculiarity pec);
+peculiarity get_class_peculiarity (type *clss);
+void set_class_peculiarity (type *clss, peculiarity pec);
/* Set and get a class' dfn --
@todo This is an undocumented field, subject to change! */
int get_class_dfn (type *clss);
/** Returns true if a type is a class type. */
-bool is_class_type(type *clss);
+int is_class_type(type *clss);
/** Returns true if low is subclass of high. */
bool is_subclass_of(type *low, type *high);
/** Creates a new type struct with debug information. */
type *new_d_type_struct (ident *name, dbg_info* db);
-/* manipulate private fields of struct */
+/* --- manipulate private fields of struct --- */
+
+/** Adds the entity as member of the struct. */
void add_struct_member (type *strct, entity *member);
+
+/** Returns the number of members of this struct. */
int get_struct_n_members (type *strct);
+
+/** Returns the member at position pos, 0 <= pos < n_member */
entity *get_struct_member (type *strct, int pos);
+
+/** Returns index of member in strct, -1 if not contained. */
+int get_struct_member_index(type *strct, entity *member);
+
+/** Overwrites the member at position pos, 0 <= pos < n_member with
+ the passed entity. */
void set_struct_member (type *strct, int pos, entity *member);
/** Finds member in the list of members and removes it. */
void remove_struct_member (type *strct, entity *member);
/** Returns true if a type is a struct type. */
-bool is_struct_type(type *strct);
+int is_struct_type(type *strct);
/**
* @page method_type Representation of a method type
Also changes the type in the pass-by-value representation by just
changing the type of the corresponding entity if the representation is constructed. */
void set_method_param_type(type *method, int pos, type* tp);
-/* Returns an entity that represents the copied value argument. Only necessary
+/** Returns an entity that represents the copied value argument. Only necessary
for compounds passed by value. This information is constructed only on demand. */
entity *get_method_value_param_ent(type *method, int pos);
+/**
+ * Returns a type that represents the copied value arguments.
+ */
+type *get_method_value_param_type(type *method);
int get_method_n_ress (type *method);
type *get_method_res_type(type *method, int pos);
Also changes the type in the pass-by-value representation by just
changing the type of the corresponding entity if the representation is constructed. */
void set_method_res_type(type *method, int pos, type* tp);
-/* Returns an entity that represents the copied value result. Only necessary
+/** Returns an entity that represents the copied value result. Only necessary
for compounds passed by value. This information is constructed only on demand. */
entity *get_method_value_res_ent(type *method, int pos);
-/*
+/**
+ * Returns a type that represents the copied value results.
*/
type *get_method_value_res_type(type *method);
/** Sets the variadicity of a method. */
void set_method_variadicity(type *method, variadicity vari);
+/**
+ * Returns the first variadic parameter index of a type.
+ * If this index was NOT set, the index of the last parameter
+ * of the method type plus one is returned for variadic functions.
+ * Non-variadic function types always return -1 here.
+ */
+int get_method_first_variadic_param_index(type *method);
+
+/**
+ * Sets the first variadic parameter index. This allows to specify
+ * a complete call type (containing the type of all parameters)
+ * but still have the knowledge, which parameter must be passed as
+ * variadic one.
+ */
+void set_method_first_variadic_param_index(type *method, int index);
+
/** Returns true if a type is a method type. */
-bool is_method_type (type *method);
+int is_method_type (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. */
-bool is_union_type (type *uni);
+int is_union_type (type *uni);
/**
* @page array_type Representation of an array type
entity *get_array_element_entity (type *array);
/** Returns true if a type is an array type. */
-bool is_array_type (type *array);
+int is_array_type(type *array);
/**
* @page enumeration_type Representation of an enumeration type
const char *get_enumeration_name(type *enumeration, int pos);
/** Returns true if a type is a enumeration type. */
-bool is_enumeration_type (type *enumeration);
+int is_enumeration_type (type *enumeration);
/**
* @page pointer_type Representation of a pointer type
*/
/** Creates a new type pointer with mode mode_p. */
-#define new_type_pointer(N, P) new_type_pointer_mode(N, P, mode_P)
-/* type *new_type_pointer (ident *name, type *points_to); */
+#define new_type_pointer(N, P) new_type_pointer_mode(N, P, mode_P_mach)
/** Creates a new type pointer with given pointer mode. */
type *new_type_pointer_mode (ident *name, type *points_to, ir_mode *ptr_mode);
type *get_pointer_points_to_type (type *pointer);
/** Returns true if a type is a pointer type. */
-bool is_pointer_type (type *pointer);
+int is_pointer_type (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. */
-bool is_primitive_type (type *primitive);
+int is_primitive_type (type *primitive);
/**
* debugging, (configure with --enable-debug) else returns the address
* of the type cast to long.
*/
-INLINE long get_type_nr(type *tp);
+long get_type_nr(type *tp);
+
+/*******************************************************************/
+/** Debug aides **/
+/*******************************************************************/
+
+
+/** Write the type and all its attributes to stdout.
+ *
+ * Writes the type and all its attributes to stdout if DEBUG_libfirm
+ * is set. Else does nothing. */
+void dump_type (type *tp);
+
# endif /* _TYPE_H_ */