-void add_class_member (type *clss, entity *member) {
- assert(clss && (clss->type_op == type_class));
- ARR_APP1 (entity *, clss->attr.ca.members, member);
-}
-
-int (get_class_n_members) (const type *clss) {
- return __get_class_n_members(clss);
-}
-
-int get_class_member_index(type *clss, entity *mem) {
- int i;
- assert(clss && (clss->type_op == type_class));
- for (i = 0; i < get_class_n_members(clss); i++)
- if (get_class_member(clss, i) == mem)
- return i;
- return -1;
-}
-
-entity *(get_class_member) (const type *clss, int pos) {
- return __get_class_member(clss, pos);
-}
-
-entity *get_class_member_by_name(type *clss, ident *name) {
- int i, n_mem;
- assert(clss && (clss->type_op == type_class));
- n_mem = get_class_n_members(clss);
- for (i = 0; i < n_mem; ++i) {
- entity *mem = get_class_member(clss, i);
- if (get_entity_ident(mem) == name) return mem;
- }
- return NULL;
-}
-
-void set_class_member (type *clss, entity *member, int pos) {
- assert(clss && (clss->type_op == type_class));
- assert(pos >= 0 && pos < get_class_n_members(clss));
- clss->attr.ca.members[pos] = member;
-}
-void set_class_members (type *clss, entity **members, int arity) {
- int i;
- assert(clss && (clss->type_op == type_class));
- DEL_ARR_F(clss->attr.ca.members);
- clss->attr.ca.members = NEW_ARR_F (entity *, 0);
- for (i = 0; i < arity; i++) {
- set_entity_owner(members[i], clss);
- ARR_APP1 (entity *, clss->attr.ca.members, members[i]);
- }
-}
-void remove_class_member(type *clss, entity *member) {
- int i;
- assert(clss && (clss->type_op == type_class));
- for (i = 0; i < (ARR_LEN (clss->attr.ca.members)); i++) {
- if (clss->attr.ca.members[i] == member) {
- for(; i < (ARR_LEN (clss->attr.ca.members)) - 1; i++)
- clss->attr.ca.members[i] = clss->attr.ca.members[i + 1];
- ARR_SETLEN(entity*, clss->attr.ca.members, ARR_LEN(clss->attr.ca.members) - 1);
- break;
- }
- }
-}
-
-void add_class_subtype (type *clss, type *subtype) {
- int i;
- assert(clss && (clss->type_op == type_class));
- ARR_APP1 (type *, clss->attr.ca.subtypes, subtype);
- for (i = 0; i < get_class_n_supertypes(subtype); i++)
- if (get_class_supertype(subtype, i) == clss)
- /* Class already registered */
- return;
- ARR_APP1 (type *, subtype->attr.ca.supertypes, clss);
-}
-int get_class_n_subtypes (const type *clss) {
- assert(clss && (clss->type_op == type_class));
- return (ARR_LEN (clss->attr.ca.subtypes));
-}
-type *get_class_subtype (type *clss, int pos) {
- assert(clss && (clss->type_op == type_class));
- assert(pos >= 0 && pos < get_class_n_subtypes(clss));
- return clss->attr.ca.subtypes[pos] = skip_tid(clss->attr.ca.subtypes[pos]);
-}
-void set_class_subtype (type *clss, type *subtype, int pos) {
- assert(clss && (clss->type_op == type_class));
- assert(pos >= 0 && pos < get_class_n_subtypes(clss));
- clss->attr.ca.subtypes[pos] = subtype;
-}
-void remove_class_subtype(type *clss, type *subtype) {
- int i;
- assert(clss && (clss->type_op == type_class));
- for (i = 0; i < (ARR_LEN (clss->attr.ca.subtypes)); i++)
- if (clss->attr.ca.subtypes[i] == subtype) {
- for(; i < (ARR_LEN (clss->attr.ca.subtypes))-1; i++)
- clss->attr.ca.subtypes[i] = clss->attr.ca.subtypes[i+1];
- ARR_SETLEN(entity*, clss->attr.ca.subtypes, ARR_LEN(clss->attr.ca.subtypes) - 1);
- break;
- }
-}
-
-void add_class_supertype (type *clss, type *supertype) {
- int i;
- assert(clss && (clss->type_op == type_class));
- assert(supertype && (supertype -> type_op == type_class));
- ARR_APP1 (type *, clss->attr.ca.supertypes, supertype);
- for (i = 0; i < get_class_n_subtypes(supertype); i++)
- if (get_class_subtype(supertype, i) == clss)
- /* Class already registered */
- return;
- ARR_APP1 (type *, supertype->attr.ca.subtypes, clss);
-}
-int get_class_n_supertypes (const type *clss) {
- assert(clss && (clss->type_op == type_class));
- return (ARR_LEN (clss->attr.ca.supertypes));
-}
-int get_class_supertype_index(type *clss, type *super_clss) {
- int i;
- assert(clss && (clss->type_op == type_class));
- assert(super_clss && (super_clss->type_op == type_class));
- for (i = 0; i < get_class_n_supertypes(clss); i++)
- if (get_class_supertype(clss, i) == super_clss)
- return i;
- return -1;
-}
-type *get_class_supertype (type *clss, int pos) {
- assert(clss && (clss->type_op == type_class));
- assert(pos >= 0 && pos < get_class_n_supertypes(clss));
- return clss->attr.ca.supertypes[pos] = skip_tid(clss->attr.ca.supertypes[pos]);
-}
-void set_class_supertype (type *clss, type *supertype, int pos) {
- assert(clss && (clss->type_op == type_class));
- assert(pos >= 0 && pos < get_class_n_supertypes(clss));
- clss->attr.ca.supertypes[pos] = supertype;
-}
-void remove_class_supertype(type *clss, type *supertype) {
- int i;
- assert(clss && (clss->type_op == type_class));
- for (i = 0; i < (ARR_LEN (clss->attr.ca.supertypes)); i++)
- if (clss->attr.ca.supertypes[i] == supertype) {
- for(; i < (ARR_LEN (clss->attr.ca.supertypes))-1; i++)
- clss->attr.ca.supertypes[i] = clss->attr.ca.supertypes[i+1];
- ARR_SETLEN(entity*, clss->attr.ca.supertypes, ARR_LEN(clss->attr.ca.supertypes) - 1);
- break;
- }
-}
-
-const char *get_peculiarity_string(peculiarity p) {
- switch (p) {
- case peculiarity_description:
- return "peculiarity_description";
- case peculiarity_inherited:
- return "peculiarity_inherited";
- default:
- return "peculiarity_existent";
- }
-}
-
-peculiarity get_class_peculiarity (const type *clss) {
- assert(clss && (clss->type_op == type_class));
- return clss->attr.ca.peculiarity;
-}
-
-void set_class_peculiarity (type *clss, peculiarity pec) {
- assert(clss && (clss->type_op == type_class));
- assert(pec != peculiarity_inherited); /* There is no inheritance of types in libFirm. */
- clss->attr.ca.peculiarity = pec;
-}
-
-void set_class_dfn (type *clss, int dfn)
-{
- clss->attr.ca.dfn = dfn;
-}
-
-int get_class_dfn (const type *clss)
-{
- return (clss->attr.ca.dfn);
+void add_class_member(ir_type *clss, ir_entity *member) {
+ assert(clss && (clss->type_op == type_class));
+ assert(clss != get_entity_type(member) && "recursive type");
+ assert(get_type_state(clss) != layout_fixed);
+ ARR_APP1 (ir_entity *, clss->attr.ca.members, member);
+}
+
+int (get_class_n_members)(const ir_type *clss) {
+ return _get_class_n_members(clss);
+}
+
+int get_class_member_index(const ir_type *clss, ir_entity *mem) {
+ int i, n;
+ assert(clss && (clss->type_op == type_class));
+ for (i = 0, n = get_class_n_members(clss); i < n; ++i)
+ if (get_class_member(clss, i) == mem)
+ return i;
+ return -1;
+}
+
+ir_entity *(get_class_member)(const ir_type *clss, int pos) {
+ return _get_class_member(clss, pos);
+}
+
+ir_entity *get_class_member_by_name(ir_type *clss, ident *name) {
+ int i, n_mem;
+ assert(clss && (clss->type_op == type_class));
+ n_mem = get_class_n_members(clss);
+ for (i = 0; i < n_mem; ++i) {
+ ir_entity *mem = get_class_member(clss, i);
+ if (get_entity_ident(mem) == name) return mem;
+ }
+ return NULL;
+}
+
+void set_class_member(ir_type *clss, ir_entity *member, int pos) {
+ assert(clss && (clss->type_op == type_class));
+ assert(pos >= 0 && pos < get_class_n_members(clss));
+ clss->attr.ca.members[pos] = member;
+}
+
+void set_class_members(ir_type *clss, ir_entity **members, int arity) {
+ int i;
+ assert(clss && (clss->type_op == type_class));
+ DEL_ARR_F(clss->attr.ca.members);
+ clss->attr.ca.members = NEW_ARR_F(ir_entity *, 0);
+ for (i = 0; i < arity; ++i) {
+ set_entity_owner(members[i], clss);
+ ARR_APP1(ir_entity *, clss->attr.ca.members, members[i]);
+ }
+}
+
+void remove_class_member(ir_type *clss, ir_entity *member) {
+ int i;
+ assert(clss && (clss->type_op == type_class));
+ for (i = 0; i < (ARR_LEN (clss->attr.ca.members)); i++) {
+ if (clss->attr.ca.members[i] == member) {
+ for (; i < (ARR_LEN (clss->attr.ca.members)) - 1; i++)
+ clss->attr.ca.members[i] = clss->attr.ca.members[i + 1];
+ ARR_SETLEN(ir_entity*, clss->attr.ca.members, ARR_LEN(clss->attr.ca.members) - 1);
+ break;
+ }
+ }
+}
+
+void add_class_subtype(ir_type *clss, ir_type *subtype) {
+ int i;
+ assert(clss && (clss->type_op == type_class));
+ ARR_APP1 (ir_type *, clss->attr.ca.subtypes, subtype);
+ for (i = 0; i < get_class_n_supertypes(subtype); i++)
+ if (get_class_supertype(subtype, i) == clss)
+ /* Class already registered */
+ return;
+ ARR_APP1(ir_type *, subtype->attr.ca.supertypes, clss);
+}
+
+int get_class_n_subtypes(const ir_type *clss) {
+ assert(clss && (clss->type_op == type_class));
+ return (ARR_LEN (clss->attr.ca.subtypes));
+}
+
+ir_type *get_class_subtype(ir_type *clss, int pos) {
+ assert(clss && (clss->type_op == type_class));
+ assert(pos >= 0 && pos < get_class_n_subtypes(clss));
+ return clss->attr.ca.subtypes[pos] = skip_tid(clss->attr.ca.subtypes[pos]);
+}
+
+int get_class_subtype_index(ir_type *clss, const ir_type *subclass) {
+ int i, n_subtypes = get_class_n_subtypes(clss);
+ assert(is_Class_type(subclass));
+ for (i = 0; i < n_subtypes; ++i) {
+ if (get_class_subtype(clss, i) == subclass) return i;
+ }
+ return -1;
+}
+
+void set_class_subtype(ir_type *clss, ir_type *subtype, int pos) {
+ assert(clss && (clss->type_op == type_class));
+ assert(pos >= 0 && pos < get_class_n_subtypes(clss));
+ clss->attr.ca.subtypes[pos] = subtype;
+}
+
+void remove_class_subtype(ir_type *clss, ir_type *subtype) {
+ int i;
+ assert(clss && (clss->type_op == type_class));
+ for (i = 0; i < (ARR_LEN (clss->attr.ca.subtypes)); i++)
+ if (clss->attr.ca.subtypes[i] == subtype) {
+ for (; i < (ARR_LEN (clss->attr.ca.subtypes))-1; i++)
+ clss->attr.ca.subtypes[i] = clss->attr.ca.subtypes[i+1];
+ ARR_SETLEN(ir_entity*, clss->attr.ca.subtypes, ARR_LEN(clss->attr.ca.subtypes) - 1);
+ break;
+ }
+}
+
+void add_class_supertype(ir_type *clss, ir_type *supertype) {
+ int i;
+ assert(clss && (clss->type_op == type_class));
+ assert(supertype && (supertype -> type_op == type_class));
+ ARR_APP1 (ir_type *, clss->attr.ca.supertypes, supertype);
+ for (i = get_class_n_subtypes(supertype) - 1; i >= 0; --i)
+ if (get_class_subtype(supertype, i) == clss)
+ /* Class already registered */
+ return;
+ ARR_APP1(ir_type *, supertype->attr.ca.subtypes, clss);
+}
+
+int get_class_n_supertypes(const ir_type *clss) {
+ assert(clss && (clss->type_op == type_class));
+ return ARR_LEN(clss->attr.ca.supertypes);
+}
+
+int get_class_supertype_index(ir_type *clss, ir_type *super_clss) {
+ int i, n_supertypes = get_class_n_supertypes(clss);
+ assert(super_clss && (super_clss->type_op == type_class));
+ for (i = 0; i < n_supertypes; i++)
+ if (get_class_supertype(clss, i) == super_clss)
+ return i;
+ return -1;
+}
+
+ir_type *get_class_supertype(ir_type *clss, int pos) {
+ assert(clss && (clss->type_op == type_class));
+ assert(pos >= 0 && pos < get_class_n_supertypes(clss));
+ return clss->attr.ca.supertypes[pos] = skip_tid(clss->attr.ca.supertypes[pos]);
+}
+
+void set_class_supertype(ir_type *clss, ir_type *supertype, int pos) {
+ assert(clss && (clss->type_op == type_class));
+ assert(pos >= 0 && pos < get_class_n_supertypes(clss));
+ clss->attr.ca.supertypes[pos] = supertype;
+}
+
+void remove_class_supertype(ir_type *clss, ir_type *supertype) {
+ int i;
+ assert(clss && (clss->type_op == type_class));
+ for (i = 0; i < (ARR_LEN(clss->attr.ca.supertypes)); i++)
+ if (clss->attr.ca.supertypes[i] == supertype) {
+ for(; i < (ARR_LEN(clss->attr.ca.supertypes))-1; i++)
+ clss->attr.ca.supertypes[i] = clss->attr.ca.supertypes[i+1];
+ ARR_SETLEN(ir_entity*, clss->attr.ca.supertypes, ARR_LEN(clss->attr.ca.supertypes) - 1);
+ break;
+ }
+}
+
+ir_entity *get_class_type_info(const ir_type *clss) {
+ return clss->attr.ca.type_info;
+}
+
+void set_class_type_info(ir_type *clss, ir_entity *ent) {
+ clss->attr.ca.type_info = ent;
+ if (ent)
+ ent->repr_class = clss;
+}
+
+const char *get_peculiarity_name(ir_peculiarity p) {
+#define X(a) case a: return #a
+ switch (p) {
+ X(peculiarity_description);
+ X(peculiarity_inherited);
+ X(peculiarity_existent);
+ }
+#undef X
+ return "invalid peculiarity";
+}
+
+ir_peculiarity get_class_peculiarity(const ir_type *clss) {
+ assert(clss && (clss->type_op == type_class));
+ return clss->attr.ca.peculiarity;
+}
+
+void set_class_peculiarity(ir_type *clss, ir_peculiarity pec) {
+ assert(clss && (clss->type_op == type_class));
+ assert(pec != peculiarity_inherited); /* There is no inheritance of types in libFirm. */
+ clss->attr.ca.peculiarity = pec;
+}
+
+/* Returns the size of the virtual function table. */
+unsigned (get_class_vtable_size)(const ir_type *clss) {
+ return _get_class_vtable_size(clss);
+}
+
+/* Sets a new size of the virtual function table. */
+void (set_class_vtable_size)(ir_type *clss, unsigned size) {
+ _set_class_vtable_size(clss, size);
+}
+
+/* Returns non-zero if a class is final. */
+int (is_class_final)(const ir_type *clss) {
+ return _is_class_final(clss);
+}
+
+/* Sets if a class is final. */
+void (set_class_final)(ir_type *clss, int flag) {
+ _set_class_final(clss, flag);
+}
+
+/* Returns non-zero if a class is an interface. */
+int (is_class_interface)(const ir_type *clss) {
+ return _is_class_interface(clss);
+}
+
+/* Sets the class interface flag. */
+void (set_class_interface)(ir_type *clss, int flag) {
+ _set_class_interface(clss, flag);
+}
+
+/* Returns non-zero if a class is abstract. */
+int (is_class_abstract)(const ir_type *clss) {
+ return _is_class_abstract(clss);
+}
+
+/* Sets the class abstract flag. */
+void (set_class_abstract)(ir_type *clss, int final) {
+ _set_class_abstract(clss, final);
+}
+
+void set_class_dfn(ir_type *clss, int dfn) {
+ clss->attr.ca.dfn = dfn;
+}
+
+int get_class_dfn(const ir_type *clss) {
+ return (clss->attr.ca.dfn);