nsz Git - libfirm/blob - ir/tr/tpop.c

   1 /*
   2  * Project:     libFIRM
   3  * File name:   ir/tr/tpop.c
   4  * Purpose:     Opcode of types.
   5  * Author:      Goetz Lindenmaier
   6  * Modified by:
   7  * Created:
   8  * CVS-ID:      $Id$
   9  * Copyright:   (c) 2001-2003 Universität Karlsruhe
  10  * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
  11  */
  12 #ifdef HAVE_CONFIG_H
  13 # include "config.h"
  14 #endif
  15
  16 # include "xmalloc.h"
  17 # include "tpop_t.h"
  18 # include "type_t.h"
  19
  20 tp_op *type_class;         tp_op *get_tpop_class      (void) { return type_class;       }
  21 tp_op *type_struct;        tp_op *get_tpop_struct     (void) { return type_struct;      }
  22 tp_op *type_method;        tp_op *get_tpop_method     (void) { return type_method;      }
  23 tp_op *type_union;         tp_op *get_tpop_union      (void) { return type_union;       }
  24 tp_op *type_array;         tp_op *get_tpop_array      (void) { return type_array;       }
  25 tp_op *type_enumeration;   tp_op *get_tpop_enumeration(void) { return type_enumeration; }
  26 tp_op *type_pointer;       tp_op *get_tpop_pointer    (void) { return type_pointer;     }
  27 tp_op *type_primitive;     tp_op *get_tpop_primitive  (void) { return type_primitive;   }
  28 tp_op *type_id;            tp_op *get_tpop_id         (void) { return type_id;          }
  29 tp_op *tpop_none;          tp_op *get_tpop_none       (void) { return tpop_none;        }
  30 tp_op *tpop_unknown;       tp_op *get_tpop_unknown    (void) { return tpop_unknown;     }
  31
  32 tp_op *
  33 new_tpop(tp_opcode code, ident *name, unsigned flags, size_t attr_size,
  34          const tp_op_ops *ops)
  35 {
  36   tp_op *res;
  37
  38   res = xmalloc(sizeof(*res));
  39   res->code          = code;
  40   res->name          = name;
  41   res->flags         = flags;
  42   res->attr_size     = attr_size;
  43
  44   if (ops)
  45     memcpy(&res->ops, ops, sizeof(res->ops));
  46   else
  47     memset(&res->ops, 0, sizeof(res->ops));
  48
  49   return res;
  50 }
  51
  52 void
  53 free_tpop(tp_op *tpop) {
  54   free(tpop);
  55 }
  56
  57 static const tp_op_ops
  58   /** tpop operations for class types */
  59   class_ops = {
  60     free_class_attrs,
  61     free_class_entities,
  62     NULL,
  63     set_class_mode,
  64     set_class_size_bits,
  65     get_class_n_members,
  66     get_class_member,
  67     get_class_member_index
  68   },
  69   /** tpop operations for struct types */
  70   struct_ops = {
  71     free_struct_attrs,
  72     free_struct_entities,
  73     NULL,
  74     set_struct_mode,
  75     set_struct_size_bits,
  76     get_struct_n_members,
  77     get_struct_member,
  78     get_struct_member_index
  79   },
  80   /** tpop operations for method types */
  81   method_ops = {
  82     free_method_attrs,
  83     free_method_entities,
  84     NULL,
  85     NULL,
  86     NULL,
  87     NULL,
  88     NULL,
  89     NULL
  90   },
  91   /** tpop operations for union types */
  92   union_ops = {
  93     free_union_attrs,
  94     free_union_entities,
  95     NULL,
  96     NULL,
  97     set_union_size_bits,
  98     get_union_n_members,
  99     get_union_member,
 100     get_union_member_index
 101   },
 102   /** tpop operations for array types */
 103   array_ops = {
 104     free_array_attrs,
 105     free_array_entities,
 106     free_array_automatic_entities,
 107     NULL,
 108     set_array_size_bits,
 109     NULL,
 110     NULL,
 111     NULL
 112   },
 113   /** tpop operations for enumeration types */
 114   enum_ops = {
 115     free_enumeration_attrs,
 116     free_enumeration_entities,
 117     NULL,
 118     set_enumeration_mode,
 119     NULL,
 120     NULL,
 121     NULL,
 122     NULL
 123   },
 124   /** tpop operations for pointer types */
 125   pointer_ops = {
 126     free_pointer_attrs,
 127     free_pointer_entities,
 128     NULL,
 129     set_pointer_mode,
 130     NULL,
 131     NULL,
 132     NULL,
 133     NULL
 134   },
 135   /** tpop operations for pseudo types */
 136   pseudo_ops = {
 137     NULL,
 138     NULL,
 139     NULL,
 140     NULL,
 141     set_default_size_bits,
 142     NULL,
 143     NULL,
 144     NULL
 145   },
 146   /** tpop operations for primitive types */
 147   null_ops = {
 148     NULL,
 149     NULL,
 150     NULL,
 151     NULL,
 152     NULL,
 153     NULL,
 154     NULL,
 155     NULL
 156   };
 157
 158 #define C     TP_OP_FLAG_COMPOUND
 159 #define ID(s) new_id_from_chars(s, sizeof(s) - 1)
 160 void
 161 init_tpop(void)
 162 {
 163   type_class       = new_tpop(tpo_class      , ID("class"),       C, sizeof (cls_attr), &class_ops);
 164   type_struct      = new_tpop(tpo_struct     , ID("struct"),      C, sizeof (stc_attr), &struct_ops);
 165   type_method      = new_tpop(tpo_method     , ID("method"),      0, sizeof (mtd_attr), &method_ops);
 166   type_union       = new_tpop(tpo_union      , ID("union"),       C, sizeof (uni_attr), &union_ops);
 167   type_array       = new_tpop(tpo_array      , ID("array"),       C, sizeof (arr_attr), &array_ops);
 168   type_enumeration = new_tpop(tpo_enumeration, ID("enumeration"), 0, sizeof (enm_attr), &enum_ops);
 169   type_pointer     = new_tpop(tpo_pointer    , ID("pointer"),     0, sizeof (ptr_attr), &pointer_ops);
 170   type_primitive   = new_tpop(tpo_primitive  , ID("primitive"),   0, /* sizeof (pri_attr) */ 0, &null_ops);
 171   type_id          = new_tpop(tpo_id         , ID("type_id"),     0, /* sizeof (id_attr)  */ 0, &null_ops);
 172   tpop_none        = new_tpop(tpo_none       , ID("None"),        0, /* sizeof (non_attr) */ 0, &pseudo_ops);
 173   tpop_unknown     = new_tpop(tpo_unknown    , ID("Unknown"),     0, /* sizeof (ukn_attr) */ 0, &pseudo_ops);
 174 }
 175 #undef ID
 176 #undef C
 177
 178 /* Finalize the tpop module.
 179  * Frees all type opcodes.  */
 180 void finish_tpop(void) {
 181   free_tpop(type_class      ); type_class       = NULL;
 182   free_tpop(type_struct     ); type_struct      = NULL;
 183   free_tpop(type_method     ); type_method      = NULL;
 184   free_tpop(type_union      ); type_union       = NULL;
 185   free_tpop(type_array      ); type_array       = NULL;
 186   free_tpop(type_enumeration); type_enumeration = NULL;
 187   free_tpop(type_pointer    ); type_pointer     = NULL;
 188   free_tpop(type_primitive  ); type_primitive   = NULL;
 189   free_tpop(type_id         ); type_id          = NULL;
 190   free_tpop(tpop_none       ); tpop_none        = NULL;
 191   free_tpop(tpop_unknown    ); tpop_unknown     = NULL;
 192 }
 193
 194 /* Returns the string for the tp_opcode. */
 195 const char  *get_tpop_name(const tp_op *op) {
 196   return get_id_str(op->name);
 197 }
 198
 199 tp_opcode (get_tpop_code)(const tp_op *op) {
 200   return _get_tpop_code(op);
 201 }
 202
 203 ident *(get_tpop_ident)(const tp_op *op) {
 204   return _get_tpop_ident(op);
 205 }
 206
 207 /* returns the attribute size of the operator. */
 208 int (get_tpop_attr_size)(const tp_op *op) {
 209   return _get_tpop_attr_size(op);
 210 }