tools/widl/typetree.h

   1 /*
   2  * IDL Type Tree
   3  *
   4  * Copyright 2008 Robert Shearman
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "widltypes.h"
  22 #include <assert.h>
  23
  24 #ifndef WIDL_TYPE_TREE_H
  25 #define WIDL_TYPE_TREE_H
  26
  27 type_t *type_new_function(var_list_t *args);
  28 type_t *type_new_pointer(unsigned char pointer_default, type_t *ref, attr_list_t *attrs);
  29 type_t *type_new_alias(type_t *t, const char *name);
  30 type_t *type_new_module(char *name);
  31 type_t *type_new_array(const char *name, type_t *element, int declptr,
  32                        unsigned int dim, expr_t *size_is, expr_t *length_is,
  33                        unsigned char ptr_default_fc);
  34 type_t *type_new_basic(enum type_basic_type basic_type);
  35 type_t *type_new_int(enum type_basic_type basic_type, int sign);
  36 type_t *type_new_void(void);
  37 type_t *type_new_coclass(char *name);
  38 type_t *type_new_enum(const char *name, int defined, var_list_t *enums);
  39 type_t *type_new_struct(char *name, int defined, var_list_t *fields);
  40 type_t *type_new_nonencapsulated_union(const char *name, int defined, var_list_t *fields);
  41 type_t *type_new_encapsulated_union(char *name, var_t *switch_field, var_t *union_field, var_list_t *cases);
  42 type_t *type_new_bitfield(type_t *field_type, const expr_t *bits);
  43 void type_interface_define(type_t *iface, type_t *inherit, statement_list_t *stmts);
  44 void type_dispinterface_define(type_t *iface, var_list_t *props, func_list_t *methods);
  45 void type_dispinterface_define_from_iface(type_t *dispiface, type_t *iface);
  46 void type_module_define(type_t *module, statement_list_t *stmts);
  47 type_t *type_coclass_define(type_t *coclass, ifref_list_t *ifaces);
  48 int type_is_equal(const type_t *type1, const type_t *type2);
  49
  50 /* FIXME: shouldn't need to export this */
  51 type_t *duptype(type_t *t, int dupname);
  52
  53 /* un-alias the type until finding the non-alias type */
  54 static inline type_t *type_get_real_type(const type_t *type)
  55 {
  56     if (type->is_alias)
  57         return type_get_real_type(type->orig);
  58     else
  59         return (type_t *)type;
  60 }
  61
  62 static inline enum type_type type_get_type(const type_t *type)
  63 {
  64     return type_get_type_detect_alias(type_get_real_type(type));
  65 }
  66
  67 static inline enum type_basic_type type_basic_get_type(const type_t *type)
  68 {
  69     type = type_get_real_type(type);
  70     assert(type_get_type(type) == TYPE_BASIC);
  71     return type->details.basic.type;
  72 }
  73
  74 static inline int type_basic_get_sign(const type_t *type)
  75 {
  76     type = type_get_real_type(type);
  77     assert(type_get_type(type) == TYPE_BASIC);
  78     return type->details.basic.sign;
  79 }
  80
  81 static inline var_list_t *type_struct_get_fields(const type_t *type)
  82 {
  83     type = type_get_real_type(type);
  84     assert(type_get_type(type) == TYPE_STRUCT);
  85     return type->details.structure->fields;
  86 }
  87
  88 static inline var_list_t *type_function_get_args(const type_t *type)
  89 {
  90     type = type_get_real_type(type);
  91     assert(type_get_type(type) == TYPE_FUNCTION);
  92     return type->details.function->args;
  93 }
  94
  95 static inline type_t *type_function_get_rettype(const type_t *type)
  96 {
  97     type = type_get_real_type(type);
  98     assert(type_get_type(type) == TYPE_FUNCTION);
  99     return type->details.function->rettype;
 100 }
 101
 102 static inline var_list_t *type_enum_get_values(const type_t *type)
 103 {
 104     type = type_get_real_type(type);
 105     assert(type_get_type(type) == TYPE_ENUM);
 106     return type->details.enumeration->enums;
 107 }
 108
 109 static inline var_t *type_union_get_switch_value(const type_t *type)
 110 {
 111     type = type_get_real_type(type);
 112     assert(type_get_type(type) == TYPE_ENCAPSULATED_UNION);
 113     return LIST_ENTRY(list_head(type->details.structure->fields), var_t, entry);
 114 }
 115
 116 static inline var_list_t *type_encapsulated_union_get_fields(const type_t *type)
 117 {
 118     type = type_get_real_type(type);
 119     assert(type_get_type(type) == TYPE_ENCAPSULATED_UNION);
 120     return type->details.structure->fields;
 121 }
 122
 123 static inline var_list_t *type_union_get_cases(const type_t *type)
 124 {
 125     enum type_type type_type;
 126
 127     type = type_get_real_type(type);
 128     type_type = type_get_type(type);
 129
 130     assert(type_type == TYPE_UNION || type_type == TYPE_ENCAPSULATED_UNION);
 131     if (type_type == TYPE_ENCAPSULATED_UNION)
 132     {
 133         const var_t *uv = LIST_ENTRY(list_tail(type->details.structure->fields), const var_t, entry);
 134         return uv->type->details.structure->fields;
 135     }
 136     else
 137         return type->details.structure->fields;
 138 }
 139
 140 static inline statement_list_t *type_iface_get_stmts(const type_t *type)
 141 {
 142     type = type_get_real_type(type);
 143     assert(type_get_type(type) == TYPE_INTERFACE);
 144     return type->details.iface->stmts;
 145 }
 146
 147 static inline type_t *type_iface_get_inherit(const type_t *type)
 148 {
 149     type = type_get_real_type(type);
 150     assert(type_get_type(type) == TYPE_INTERFACE);
 151     return type->details.iface->inherit;
 152 }
 153
 154 static inline var_list_t *type_dispiface_get_props(const type_t *type)
 155 {
 156     type = type_get_real_type(type);
 157     assert(type_get_type(type) == TYPE_INTERFACE);
 158     return type->details.iface->disp_props;
 159 }
 160
 161 static inline var_list_t *type_dispiface_get_methods(const type_t *type)
 162 {
 163     type = type_get_real_type(type);
 164     assert(type_get_type(type) == TYPE_INTERFACE);
 165     return type->details.iface->disp_methods;
 166 }
 167
 168 static inline int type_is_defined(const type_t *type)
 169 {
 170     return type->defined;
 171 }
 172
 173 static inline int type_is_complete(const type_t *type)
 174 {
 175     switch (type_get_type_detect_alias(type))
 176     {
 177     case TYPE_FUNCTION:
 178         return (type->details.function != NULL);
 179     case TYPE_INTERFACE:
 180         return (type->details.iface != NULL);
 181     case TYPE_ENUM:
 182         return (type->details.enumeration != NULL);
 183     case TYPE_UNION:
 184     case TYPE_ENCAPSULATED_UNION:
 185     case TYPE_STRUCT:
 186         return (type->details.structure != NULL);
 187     case TYPE_VOID:
 188     case TYPE_BASIC:
 189     case TYPE_ALIAS:
 190     case TYPE_MODULE:
 191     case TYPE_COCLASS:
 192     case TYPE_POINTER:
 193     case TYPE_ARRAY:
 194     case TYPE_BITFIELD:
 195         return TRUE;
 196     }
 197     return FALSE;
 198 }
 199
 200 static inline int type_array_has_conformance(const type_t *type)
 201 {
 202     type = type_get_real_type(type);
 203     assert(type_get_type(type) == TYPE_ARRAY);
 204     return (type->details.array.size_is != NULL);
 205 }
 206
 207 static inline int type_array_has_variance(const type_t *type)
 208 {
 209     type = type_get_real_type(type);
 210     assert(type_get_type(type) == TYPE_ARRAY);
 211     return (type->details.array.length_is != NULL);
 212 }
 213
 214 static inline unsigned int type_array_get_dim(const type_t *type)
 215 {
 216     type = type_get_real_type(type);
 217     assert(type_get_type(type) == TYPE_ARRAY);
 218     return type->details.array.dim;
 219 }
 220
 221 static inline expr_t *type_array_get_conformance(const type_t *type)
 222 {
 223     type = type_get_real_type(type);
 224     assert(type_get_type(type) == TYPE_ARRAY);
 225     return type->details.array.size_is;
 226 }
 227
 228 static inline expr_t *type_array_get_variance(const type_t *type)
 229 {
 230     type = type_get_real_type(type);
 231     assert(type_get_type(type) == TYPE_ARRAY);
 232     return type->details.array.length_is;
 233 }
 234
 235 static inline type_t *type_array_get_element(const type_t *type)
 236 {
 237     type = type_get_real_type(type);
 238     assert(type_get_type(type) == TYPE_ARRAY);
 239     return type->details.array.elem;
 240 }
 241
 242 static inline int type_array_is_decl_as_ptr(const type_t *type)
 243 {
 244     type = type_get_real_type(type);
 245     assert(type_get_type(type) == TYPE_ARRAY);
 246     return type->details.array.declptr;
 247 }
 248
 249 static inline unsigned char type_array_get_ptr_default_fc(const type_t *type)
 250 {
 251     type = type_get_real_type(type);
 252     assert(type_get_type(type) == TYPE_ARRAY);
 253     return type->details.array.ptr_def_fc;
 254 }
 255
 256 static inline int type_is_alias(const type_t *type)
 257 {
 258     return type->is_alias;
 259 }
 260
 261 static inline type_t *type_alias_get_aliasee(const type_t *type)
 262 {
 263     assert(type_is_alias(type));
 264     return type->orig;
 265 }
 266
 267 static inline ifref_list_t *type_coclass_get_ifaces(const type_t *type)
 268 {
 269     type = type_get_real_type(type);
 270     assert(type_get_type(type) == TYPE_COCLASS);
 271     return type->details.coclass.ifaces;
 272 }
 273
 274 static inline type_t *type_pointer_get_ref(const type_t *type)
 275 {
 276     type = type_get_real_type(type);
 277     assert(type_get_type(type) == TYPE_POINTER);
 278     return type->details.pointer.ref;
 279 }
 280
 281 static inline unsigned char type_pointer_get_default_fc(const type_t *type)
 282 {
 283     type = type_get_real_type(type);
 284     assert(type_get_type(type) == TYPE_POINTER);
 285     return type->details.pointer.def_fc;
 286 }
 287
 288 static inline type_t *type_bitfield_get_field(const type_t *type)
 289 {
 290     type = type_get_real_type(type);
 291     assert(type_get_type(type) == TYPE_BITFIELD);
 292     return type->details.bitfield.field;
 293 }
 294
 295 static inline const expr_t *type_bitfield_get_bits(const type_t *type)
 296 {
 297     type = type_get_real_type(type);
 298     assert(type_get_type(type) == TYPE_BITFIELD);
 299     return type->details.bitfield.bits;
 300 }
 301
 302 #endif /* WIDL_TYPE_TREE_H */