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, var_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 var_t *type_function_get_retval(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->retval;
 100 }
 101
 102 static inline type_t *type_function_get_rettype(const type_t *type)
 103 {
 104     return type_function_get_retval(type)->type;
 105 }
 106
 107 static inline var_list_t *type_enum_get_values(const type_t *type)
 108 {
 109     type = type_get_real_type(type);
 110     assert(type_get_type(type) == TYPE_ENUM);
 111     return type->details.enumeration->enums;
 112 }
 113
 114 static inline var_t *type_union_get_switch_value(const type_t *type)
 115 {
 116     type = type_get_real_type(type);
 117     assert(type_get_type(type) == TYPE_ENCAPSULATED_UNION);
 118     return LIST_ENTRY(list_head(type->details.structure->fields), var_t, entry);
 119 }
 120
 121 static inline var_list_t *type_encapsulated_union_get_fields(const type_t *type)
 122 {
 123     type = type_get_real_type(type);
 124     assert(type_get_type(type) == TYPE_ENCAPSULATED_UNION);
 125     return type->details.structure->fields;
 126 }
 127
 128 static inline var_list_t *type_union_get_cases(const type_t *type)
 129 {
 130     enum type_type type_type;
 131
 132     type = type_get_real_type(type);
 133     type_type = type_get_type(type);
 134
 135     assert(type_type == TYPE_UNION || type_type == TYPE_ENCAPSULATED_UNION);
 136     if (type_type == TYPE_ENCAPSULATED_UNION)
 137     {
 138         const var_t *uv = LIST_ENTRY(list_tail(type->details.structure->fields), const var_t, entry);
 139         return uv->type->details.structure->fields;
 140     }
 141     else
 142         return type->details.structure->fields;
 143 }
 144
 145 static inline statement_list_t *type_iface_get_stmts(const type_t *type)
 146 {
 147     type = type_get_real_type(type);
 148     assert(type_get_type(type) == TYPE_INTERFACE);
 149     return type->details.iface->stmts;
 150 }
 151
 152 static inline type_t *type_iface_get_inherit(const type_t *type)
 153 {
 154     type = type_get_real_type(type);
 155     assert(type_get_type(type) == TYPE_INTERFACE);
 156     return type->details.iface->inherit;
 157 }
 158
 159 static inline var_list_t *type_dispiface_get_props(const type_t *type)
 160 {
 161     type = type_get_real_type(type);
 162     assert(type_get_type(type) == TYPE_INTERFACE);
 163     return type->details.iface->disp_props;
 164 }
 165
 166 static inline var_list_t *type_dispiface_get_methods(const type_t *type)
 167 {
 168     type = type_get_real_type(type);
 169     assert(type_get_type(type) == TYPE_INTERFACE);
 170     return type->details.iface->disp_methods;
 171 }
 172
 173 static inline int type_is_defined(const type_t *type)
 174 {
 175     return type->defined;
 176 }
 177
 178 static inline int type_is_complete(const type_t *type)
 179 {
 180     switch (type_get_type_detect_alias(type))
 181     {
 182     case TYPE_FUNCTION:
 183         return (type->details.function != NULL);
 184     case TYPE_INTERFACE:
 185         return (type->details.iface != NULL);
 186     case TYPE_ENUM:
 187         return (type->details.enumeration != NULL);
 188     case TYPE_UNION:
 189     case TYPE_ENCAPSULATED_UNION:
 190     case TYPE_STRUCT:
 191         return (type->details.structure != NULL);
 192     case TYPE_VOID:
 193     case TYPE_BASIC:
 194     case TYPE_ALIAS:
 195     case TYPE_MODULE:
 196     case TYPE_COCLASS:
 197     case TYPE_POINTER:
 198     case TYPE_ARRAY:
 199     case TYPE_BITFIELD:
 200         return TRUE;
 201     }
 202     return FALSE;
 203 }
 204
 205 static inline int type_array_has_conformance(const type_t *type)
 206 {
 207     type = type_get_real_type(type);
 208     assert(type_get_type(type) == TYPE_ARRAY);
 209     return (type->details.array.size_is != NULL);
 210 }
 211
 212 static inline int type_array_has_variance(const type_t *type)
 213 {
 214     type = type_get_real_type(type);
 215     assert(type_get_type(type) == TYPE_ARRAY);
 216     return (type->details.array.length_is != NULL);
 217 }
 218
 219 static inline unsigned int type_array_get_dim(const type_t *type)
 220 {
 221     type = type_get_real_type(type);
 222     assert(type_get_type(type) == TYPE_ARRAY);
 223     return type->details.array.dim;
 224 }
 225
 226 static inline expr_t *type_array_get_conformance(const type_t *type)
 227 {
 228     type = type_get_real_type(type);
 229     assert(type_get_type(type) == TYPE_ARRAY);
 230     return type->details.array.size_is;
 231 }
 232
 233 static inline expr_t *type_array_get_variance(const type_t *type)
 234 {
 235     type = type_get_real_type(type);
 236     assert(type_get_type(type) == TYPE_ARRAY);
 237     return type->details.array.length_is;
 238 }
 239
 240 static inline type_t *type_array_get_element(const type_t *type)
 241 {
 242     type = type_get_real_type(type);
 243     assert(type_get_type(type) == TYPE_ARRAY);
 244     return type->details.array.elem;
 245 }
 246
 247 static inline int type_array_is_decl_as_ptr(const type_t *type)
 248 {
 249     type = type_get_real_type(type);
 250     assert(type_get_type(type) == TYPE_ARRAY);
 251     return type->details.array.declptr;
 252 }
 253
 254 static inline unsigned char type_array_get_ptr_default_fc(const type_t *type)
 255 {
 256     type = type_get_real_type(type);
 257     assert(type_get_type(type) == TYPE_ARRAY);
 258     return type->details.array.ptr_def_fc;
 259 }
 260
 261 static inline int type_is_alias(const type_t *type)
 262 {
 263     return type->is_alias;
 264 }
 265
 266 static inline type_t *type_alias_get_aliasee(const type_t *type)
 267 {
 268     assert(type_is_alias(type));
 269     return type->orig;
 270 }
 271
 272 static inline ifref_list_t *type_coclass_get_ifaces(const type_t *type)
 273 {
 274     type = type_get_real_type(type);
 275     assert(type_get_type(type) == TYPE_COCLASS);
 276     return type->details.coclass.ifaces;
 277 }
 278
 279 static inline type_t *type_pointer_get_ref(const type_t *type)
 280 {
 281     type = type_get_real_type(type);
 282     assert(type_get_type(type) == TYPE_POINTER);
 283     return type->details.pointer.ref;
 284 }
 285
 286 static inline unsigned char type_pointer_get_default_fc(const type_t *type)
 287 {
 288     type = type_get_real_type(type);
 289     assert(type_get_type(type) == TYPE_POINTER);
 290     return type->details.pointer.def_fc;
 291 }
 292
 293 static inline type_t *type_bitfield_get_field(const type_t *type)
 294 {
 295     type = type_get_real_type(type);
 296     assert(type_get_type(type) == TYPE_BITFIELD);
 297     return type->details.bitfield.field;
 298 }
 299
 300 static inline const expr_t *type_bitfield_get_bits(const type_t *type)
 301 {
 302     type = type_get_real_type(type);
 303     assert(type_get_type(type) == TYPE_BITFIELD);
 304     return type->details.bitfield.bits;
 305 }
 306
 307 #endif /* WIDL_TYPE_TREE_H */