X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Ftpop.c;h=d7a92d3b162dc33b16f4b6c88e522399265e91a0;hb=0064ee54b41c007b5d33b557d053e602ac3be2cc;hp=015d1cd4f514633ae1583a7f3e2d2684d106afa4;hpb=2120cb6ad7ec660f4d2528d8d448a3198c53d571;p=libfirm diff --git a/ir/tr/tpop.c b/ir/tr/tpop.c index 015d1cd4f..d7a92d3b1 100644 --- a/ir/tr/tpop.c +++ b/ir/tr/tpop.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved. + * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. * * This file is part of libFirm. * @@ -23,33 +23,29 @@ * @author Goetz Lindenmaier, Michael Beck * @version $Id$ */ -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif +#include "config.h" #include "xmalloc.h" #include "tpop_t.h" #include "type_t.h" - -tp_op *type_class; tp_op *get_tpop_class (void) { return type_class; } -tp_op *type_struct; tp_op *get_tpop_struct (void) { return type_struct; } -tp_op *type_method; tp_op *get_tpop_method (void) { return type_method; } -tp_op *type_union; tp_op *get_tpop_union (void) { return type_union; } -tp_op *type_array; tp_op *get_tpop_array (void) { return type_array; } -tp_op *type_enumeration; tp_op *get_tpop_enumeration(void) { return type_enumeration; } -tp_op *type_pointer; tp_op *get_tpop_pointer (void) { return type_pointer; } -tp_op *type_primitive; tp_op *get_tpop_primitive (void) { return type_primitive; } -tp_op *type_id; tp_op *get_tpop_id (void) { return type_id; } -tp_op *tpop_none; tp_op *get_tpop_none (void) { return tpop_none; } -tp_op *tpop_unknown; tp_op *get_tpop_unknown (void) { return tpop_unknown; } - -tp_op * -new_tpop(tp_opcode code, ident *name, unsigned flags, size_t attr_size, - const tp_op_ops *ops) +#include "ident.h" + +const tp_op *type_class; const tp_op *get_tpop_class (void) { return type_class; } +const tp_op *type_struct; const tp_op *get_tpop_struct (void) { return type_struct; } +const tp_op *type_method; const tp_op *get_tpop_method (void) { return type_method; } +const tp_op *type_union; const tp_op *get_tpop_union (void) { return type_union; } +const tp_op *type_array; const tp_op *get_tpop_array (void) { return type_array; } +const tp_op *type_enumeration; const tp_op *get_tpop_enumeration(void) { return type_enumeration; } +const tp_op *type_pointer; const tp_op *get_tpop_pointer (void) { return type_pointer; } +const tp_op *type_primitive; const tp_op *get_tpop_primitive (void) { return type_primitive; } +const tp_op *tpop_code; const tp_op *get_tpop_code_type (void) { return tpop_code; } +const tp_op *tpop_none; const tp_op *get_tpop_none (void) { return tpop_none; } +const tp_op *tpop_unknown; const tp_op *get_tpop_unknown (void) { return tpop_unknown; } + +const tp_op * +new_tpop(tp_opcode code, ident *name, unsigned flags, size_t attr_size, const tp_op_ops *ops) { - tp_op *res; - - res = xmalloc(sizeof(*res)); + tp_op *res = XMALLOC(tp_op); res->code = code; res->name = name; res->flags = flags; @@ -63,9 +59,9 @@ new_tpop(tp_opcode code, ident *name, unsigned flags, size_t attr_size, return res; } -void -free_tpop(tp_op *tpop) { - free(tpop); +void free_tpop(const tp_op *tpop) +{ + xfree((void *)tpop); } static const tp_op_ops @@ -75,7 +71,7 @@ static const tp_op_ops free_class_entities, NULL, set_class_mode, - set_class_size_bits, + set_class_size, get_class_n_members, get_class_member, get_class_member_index @@ -86,7 +82,7 @@ static const tp_op_ops free_struct_entities, NULL, set_struct_mode, - set_struct_size_bits, + set_struct_size, get_struct_n_members, get_struct_member, get_struct_member_index @@ -108,7 +104,7 @@ static const tp_op_ops free_union_entities, NULL, NULL, - set_union_size_bits, + set_union_size, get_union_n_members, get_union_member, get_union_member_index @@ -119,7 +115,7 @@ static const tp_op_ops free_array_entities, free_array_automatic_entities, NULL, - set_array_size_bits, + set_array_size, NULL, NULL, NULL @@ -152,7 +148,7 @@ static const tp_op_ops NULL, NULL, NULL, - set_default_size_bits, + set_default_size, NULL, NULL, NULL @@ -169,28 +165,27 @@ static const tp_op_ops NULL }; -#define C TP_OP_FLAG_COMPOUND +void init_tpop(void) +{ #define ID(s) new_id_from_chars(s, sizeof(s) - 1) - -void init_tpop(void) { - type_class = new_tpop(tpo_class , ID("class"), C, sizeof (cls_attr), &class_ops); - type_struct = new_tpop(tpo_struct , ID("struct"), C, sizeof (stc_attr), &struct_ops); - type_method = new_tpop(tpo_method , ID("method"), 0, sizeof (mtd_attr), &method_ops); - type_union = new_tpop(tpo_union , ID("union"), C, sizeof (uni_attr), &union_ops); - type_array = new_tpop(tpo_array , ID("array"), C, sizeof (arr_attr), &array_ops); - type_enumeration = new_tpop(tpo_enumeration, ID("enumeration"), 0, sizeof (enm_attr), &enum_ops); - type_pointer = new_tpop(tpo_pointer , ID("pointer"), 0, sizeof (ptr_attr), &pointer_ops); - type_primitive = new_tpop(tpo_primitive , ID("primitive"), 0, sizeof (pri_attr), &null_ops); - type_id = new_tpop(tpo_id , ID("type_id"), 0, /* sizeof (id_attr) */ 0, &null_ops); - tpop_none = new_tpop(tpo_none , ID("None"), 0, /* sizeof (non_attr) */ 0, &pseudo_ops); - tpop_unknown = new_tpop(tpo_unknown , ID("Unknown"), 0, /* sizeof (ukn_attr) */ 0, &pseudo_ops); -} + type_class = new_tpop(tpo_class , ID("class"), TP_OP_FLAG_COMPOUND, sizeof(cls_attr), &class_ops); + type_struct = new_tpop(tpo_struct , ID("struct"), TP_OP_FLAG_COMPOUND, sizeof(stc_attr), &struct_ops); + type_method = new_tpop(tpo_method , ID("method"), 0, sizeof(mtd_attr), &method_ops); + type_union = new_tpop(tpo_union , ID("union"), TP_OP_FLAG_COMPOUND, sizeof(uni_attr), &union_ops); + type_array = new_tpop(tpo_array , ID("array"), 0, sizeof(arr_attr), &array_ops); + type_enumeration = new_tpop(tpo_enumeration, ID("enumeration"), 0, sizeof(enm_attr), &enum_ops); + type_pointer = new_tpop(tpo_pointer , ID("pointer"), 0, sizeof(ptr_attr), &pointer_ops); + type_primitive = new_tpop(tpo_primitive , ID("primitive"), 0, sizeof(pri_attr), &null_ops); + tpop_code = new_tpop(tpo_code , ID("code"), 0, 0, &null_ops); + tpop_none = new_tpop(tpo_none , ID("None"), 0, 0, &pseudo_ops); + tpop_unknown = new_tpop(tpo_unknown , ID("Unknown"), 0, 0, &pseudo_ops); #undef ID -#undef C +} /* Finalize the tpop module. * Frees all type opcodes. */ -void finish_tpop(void) { +void finish_tpop(void) +{ free_tpop(type_class ); type_class = NULL; free_tpop(type_struct ); type_struct = NULL; free_tpop(type_method ); type_method = NULL; @@ -199,25 +194,24 @@ void finish_tpop(void) { free_tpop(type_enumeration); type_enumeration = NULL; free_tpop(type_pointer ); type_pointer = NULL; free_tpop(type_primitive ); type_primitive = NULL; - free_tpop(type_id ); type_id = NULL; + free_tpop(tpop_code ); tpop_code = NULL; free_tpop(tpop_none ); tpop_none = NULL; free_tpop(tpop_unknown ); tpop_unknown = NULL; - } +} /* Returns the string for the tp_opcode. */ -const char *get_tpop_name(const tp_op *op) { +const char *get_tpop_name(const tp_op *op) +{ return get_id_str(op->name); } -tp_opcode (get_tpop_code)(const tp_op *op) { +tp_opcode (get_tpop_code)(const tp_op *op) +{ return _get_tpop_code(op); } -ident *(get_tpop_ident)(const tp_op *op) { - return _get_tpop_ident(op); -} - /* returns the attribute size of the operator. */ -int (get_tpop_attr_size)(const tp_op *op) { +int (get_tpop_attr_size)(const tp_op *op) +{ return _get_tpop_attr_size(op); }