-void add_class_member (type *clss, entity *member) {
- assert(clss && (clss->type_op == type_class));
- assert(clss != get_entity_type(member) && "recursive type");
- 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]);
-}
-int get_class_subtype_index(type *clss, const 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 (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, 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;
-}
-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) {
+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) {