ReactOS  0.4.14-dev-599-g2d4d3f5
typetree.c
Go to the documentation of this file.
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 "config.h"
22 
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 
27 #include "widl.h"
28 #include "utils.h"
29 #include "parser.h"
30 #include "typetree.h"
31 #include "header.h"
32 
33 type_t *duptype(type_t *t, int dupname)
34 {
35  type_t *d = alloc_type();
36 
37  *d = *t;
38  if (dupname && t->name)
39  d->name = xstrdup(t->name);
40 
41  return d;
42 }
43 
45 {
46  type_t *t = alloc_type();
47  t->name = NULL;
48  t->namespace = NULL;
49  t->type_type = type;
50  t->attrs = NULL;
51  t->c_name = NULL;
52  t->orig = NULL;
53  memset(&t->details, 0, sizeof(t->details));
54  t->typestring_offset = 0;
55  t->ptrdesc = 0;
56  t->ignore = (parse_only != 0);
57  t->defined = FALSE;
58  t->written = FALSE;
59  t->user_types_registered = FALSE;
60  t->tfswrite = FALSE;
61  t->checked = FALSE;
62  t->is_alias = FALSE;
63  t->typelib_idx = -1;
64  init_loc_info(&t->loc_info);
65  return t;
66 }
67 
68 static const var_t *find_arg(const var_list_t *args, const char *name)
69 {
70  const var_t *arg;
71 
73  {
74  if (arg->name && !strcmp(name, arg->name))
75  return arg;
76  }
77 
78  return NULL;
79 }
80 
81 const char *type_get_name(const type_t *type, enum name_type name_type)
82 {
83  switch(name_type) {
84  case NAME_DEFAULT:
85  return type->name;
86  case NAME_C:
87  return type->c_name;
88  }
89 
90  assert(0);
91  return NULL;
92 }
93 
94 static char *append_namespace(char *ptr, struct namespace *namespace, const char *separator)
95 {
96  if(is_global_namespace(namespace)) {
98  return ptr;
99  strcpy(ptr, "ABI");
100  strcat(ptr, separator);
101  return ptr + strlen(ptr);
102  }
103 
106  strcat(ptr, separator);
107  return ptr + strlen(ptr);
108 }
109 
110 char *format_namespace(struct namespace *namespace, const char *prefix, const char *separator, const char *suffix)
111 {
112  unsigned len = strlen(prefix) + strlen(suffix);
113  unsigned sep_len = strlen(separator);
114  struct namespace *iter;
115  char *ret, *ptr;
116 
117  if(use_abi_namespace && !is_global_namespace(namespace))
118  len += 3 /* strlen("ABI") */ + sep_len;
119 
120  for(iter = namespace; !is_global_namespace(iter); iter = iter->parent)
121  len += strlen(iter->name) + sep_len;
122 
123  ret = xmalloc(len+1);
124  strcpy(ret, prefix);
125  ptr = append_namespace(ret + strlen(ret), namespace, separator);
126  strcpy(ptr, suffix);
127 
128  return ret;
129 }
130 
132 {
133  var_t *arg;
134  type_t *t;
135  unsigned int i = 0;
136 
137  if (args)
138  {
140  if (list_count(args) == 1 && !arg->name && arg->type && type_get_type(arg->type) == TYPE_VOID)
141  {
142  list_remove(&arg->entry);
143  free(arg);
144  free(args);
145  args = NULL;
146  }
147  }
149  {
150  if (arg->type && type_get_type(arg->type) == TYPE_VOID)
151  error_loc("argument '%s' has void type\n", arg->name);
152  if (!arg->name)
153  {
154  if (i > 26 * 26)
155  error_loc("too many unnamed arguments\n");
156  else
157  {
158  int unique;
159  do
160  {
161  char name[3];
162  name[0] = i > 26 ? 'a' + i / 26 : 'a' + i;
163  name[1] = i > 26 ? 'a' + i % 26 : 0;
164  name[2] = 0;
165  unique = !find_arg(args, name);
166  if (unique)
167  arg->name = xstrdup(name);
168  i++;
169  } while (!unique);
170  }
171  }
172  }
173 
175  t->details.function = xmalloc(sizeof(*t->details.function));
176  t->details.function->args = args;
177  t->details.function->idx = -1;
178  return t;
179 }
180 
182 {
184  t->details.pointer.def_fc = pointer_default;
185  t->details.pointer.ref = ref;
186  t->attrs = attrs;
187  return t;
188 }
189 
191 {
192  type_t *a = duptype(t, 0);
193 
194  a->name = xstrdup(name);
195  a->attrs = NULL;
196  a->orig = t;
197  a->is_alias = TRUE;
198  /* for pointer types */
199  a->details = t->details;
200  init_loc_info(&a->loc_info);
201 
202  return a;
203 }
204 
206 {
208  if (type->type_type != TYPE_MODULE || type->defined)
209  error_loc("%s: redefinition error; original definition was at %s:%d\n",
210  type->name, type->loc_info.input_name, type->loc_info.line_number);
211  type->name = name;
212  return type;
213 }
214 
216 {
218  if (type->type_type != TYPE_COCLASS || type->defined)
219  error_loc("%s: redefinition error; original definition was at %s:%d\n",
220  type->name, type->loc_info.input_name, type->loc_info.line_number);
221  type->name = name;
222  return type;
223 }
224 
225 
226 type_t *type_new_array(const char *name, type_t *element, int declptr,
227  unsigned int dim, expr_t *size_is, expr_t *length_is,
228  unsigned char ptr_default_fc)
229 {
231  if (name) t->name = xstrdup(name);
232  t->details.array.declptr = declptr;
233  t->details.array.length_is = length_is;
234  if (size_is)
235  t->details.array.size_is = size_is;
236  else
237  t->details.array.dim = dim;
238  t->details.array.elem = element;
239  t->details.array.ptr_def_fc = ptr_default_fc;
240  return t;
241 }
242 
244 {
246  t->details.basic.type = basic_type;
247  t->details.basic.sign = 0;
248  return t;
249 }
250 
251 type_t *type_new_int(enum type_basic_type basic_type, int sign)
252 {
253  static type_t *int_types[TYPE_BASIC_INT_MAX+1][3];
254 
255  assert(basic_type <= TYPE_BASIC_INT_MAX);
256 
257  /* map sign { -1, 0, 1 } -> { 0, 1, 2 } */
258  if (!int_types[basic_type][sign + 1])
259  {
260  int_types[basic_type][sign + 1] = type_new_basic(basic_type);
261  int_types[basic_type][sign + 1]->details.basic.sign = sign;
262  }
263  return int_types[basic_type][sign + 1];
264 }
265 
267 {
268  static type_t *void_type = NULL;
269  if (!void_type)
270  void_type = make_type(TYPE_VOID);
271  return void_type;
272 }
273 
274 type_t *type_new_enum(const char *name, struct namespace *namespace, int defined, var_list_t *enums)
275 {
276  type_t *tag_type = name ? find_type(name, namespace, tsENUM) : NULL;
278  t->name = name;
279  t->namespace = namespace;
280 
281  if (tag_type && tag_type->details.enumeration)
282  t->details.enumeration = tag_type->details.enumeration;
283  else if (defined)
284  {
285  t->details.enumeration = xmalloc(sizeof(*t->details.enumeration));
286  t->details.enumeration->enums = enums;
287  t->defined = TRUE;
288  }
289 
290  if (name)
291  {
292  if (defined)
293  reg_type(t, name, namespace, tsENUM);
294  else
295  add_incomplete(t);
296  }
297  return t;
298 }
299 
300 type_t *type_new_struct(char *name, struct namespace *namespace, int defined, var_list_t *fields)
301 {
302  type_t *tag_type = name ? find_type(name, namespace, tsSTRUCT) : NULL;
303  type_t *t;
304 
305  /* avoid creating duplicate typelib type entries */
306  if (tag_type && do_typelib) return tag_type;
307 
309  t->name = name;
310  t->namespace = namespace;
311 
312  if (tag_type && tag_type->details.structure)
313  t->details.structure = tag_type->details.structure;
314  else if (defined)
315  {
316  t->details.structure = xmalloc(sizeof(*t->details.structure));
317  t->details.structure->fields = fields;
318  t->defined = TRUE;
319  }
320  if (name)
321  {
322  if (defined)
323  reg_type(t, name, namespace, tsSTRUCT);
324  else
325  add_incomplete(t);
326  }
327  return t;
328 }
329 
330 type_t *type_new_nonencapsulated_union(const char *name, int defined, var_list_t *fields)
331 {
332  type_t *tag_type = name ? find_type(name, NULL, tsUNION) : NULL;
334  t->name = name;
335  if (tag_type && tag_type->details.structure)
336  t->details.structure = tag_type->details.structure;
337  else if (defined)
338  {
339  t->details.structure = xmalloc(sizeof(*t->details.structure));
340  t->details.structure->fields = fields;
341  t->defined = TRUE;
342  }
343  if (name)
344  {
345  if (defined)
346  reg_type(t, name, NULL, tsUNION);
347  else
348  add_incomplete(t);
349  }
350  return t;
351 }
352 
353 type_t *type_new_encapsulated_union(char *name, var_t *switch_field, var_t *union_field, var_list_t *cases)
354 {
356  if (!union_field) union_field = make_var( xstrdup("tagged_union") );
357  union_field->type = type_new_nonencapsulated_union(NULL, TRUE, cases);
358  t->details.structure = xmalloc(sizeof(*t->details.structure));
359  t->details.structure->fields = append_var( NULL, switch_field );
360  t->details.structure->fields = append_var( t->details.structure->fields, union_field );
361  t->defined = TRUE;
362  return t;
363 }
364 
366 {
367  switch (type_get_type(type))
368  {
369  case TYPE_ENUM:
370  return TRUE;
371  case TYPE_BASIC:
372  switch (type_basic_get_type(type))
373  {
374  case TYPE_BASIC_INT8:
375  case TYPE_BASIC_INT16:
376  case TYPE_BASIC_INT32:
377  case TYPE_BASIC_INT64:
378  case TYPE_BASIC_INT:
379  case TYPE_BASIC_INT3264:
380  case TYPE_BASIC_LONG:
381  case TYPE_BASIC_CHAR:
382  case TYPE_BASIC_HYPER:
383  case TYPE_BASIC_BYTE:
384  case TYPE_BASIC_WCHAR:
386  return TRUE;
387  case TYPE_BASIC_FLOAT:
388  case TYPE_BASIC_DOUBLE:
389  case TYPE_BASIC_HANDLE:
390  return FALSE;
391  }
392  return FALSE;
393  default:
394  return FALSE;
395  }
396 }
397 
399 {
400  type_t *t;
401 
403  error_loc("bit-field has invalid type\n");
404 
405  if (bits->cval < 0)
406  error_loc("negative width for bit-field\n");
407 
408  /* FIXME: validate bits->cval <= memsize(field) * 8 */
409 
411  t->details.bitfield.field = field;
412  t->details.bitfield.bits = bits;
413  return t;
414 }
415 
416 static int compute_method_indexes(type_t *iface)
417 {
418  int idx;
419  statement_t *stmt;
420 
421  if (!iface->details.iface)
422  return 0;
423 
424  if (type_iface_get_inherit(iface))
426  else
427  idx = 0;
428 
430  {
431  var_t *func = stmt->u.var;
432  if (!is_callas(func->attrs))
433  func->type->details.function->idx = idx++;
434  }
435 
436  return idx;
437 }
438 
439 void type_interface_define(type_t *iface, type_t *inherit, statement_list_t *stmts)
440 {
441  iface->details.iface = xmalloc(sizeof(*iface->details.iface));
442  iface->details.iface->disp_props = NULL;
443  iface->details.iface->disp_methods = NULL;
444  iface->details.iface->stmts = stmts;
445  iface->details.iface->inherit = inherit;
446  iface->details.iface->disp_inherit = NULL;
447  iface->details.iface->async_iface = NULL;
448  iface->defined = TRUE;
449  compute_method_indexes(iface);
450 }
451 
453 {
454  iface->details.iface = xmalloc(sizeof(*iface->details.iface));
455  iface->details.iface->disp_props = props;
456  iface->details.iface->disp_methods = methods;
457  iface->details.iface->stmts = NULL;
458  iface->details.iface->inherit = find_type("IDispatch", NULL, 0);
459  if (!iface->details.iface->inherit) error_loc("IDispatch is undefined\n");
460  iface->details.iface->disp_inherit = NULL;
461  iface->details.iface->async_iface = NULL;
462  iface->defined = TRUE;
463  compute_method_indexes(iface);
464 }
465 
467 {
468  dispiface->details.iface = xmalloc(sizeof(*dispiface->details.iface));
469  dispiface->details.iface->disp_props = NULL;
470  dispiface->details.iface->disp_methods = NULL;
471  dispiface->details.iface->stmts = NULL;
472  dispiface->details.iface->inherit = find_type("IDispatch", NULL, 0);
473  if (!dispiface->details.iface->inherit) error_loc("IDispatch is undefined\n");
474  dispiface->details.iface->disp_inherit = iface;
475  dispiface->details.iface->async_iface = NULL;
476  dispiface->defined = TRUE;
477  compute_method_indexes(dispiface);
478 }
479 
481 {
482  if (module->details.module) error_loc("multiple definition error\n");
483  module->details.module = xmalloc(sizeof(*module->details.module));
484  module->details.module->stmts = stmts;
485  module->defined = TRUE;
486 }
487 
489 {
490  coclass->details.coclass.ifaces = ifaces;
491  coclass->defined = TRUE;
492  return coclass;
493 }
494 
495 int type_is_equal(const type_t *type1, const type_t *type2)
496 {
498  return FALSE;
499 
500  if (type1->name && type2->name)
501  return !strcmp(type1->name, type2->name);
502  else if ((!type1->name && type2->name) || (type1->name && !type2->name))
503  return FALSE;
504 
505  /* FIXME: do deep inspection of types to determine if they are equal */
506 
507  return FALSE;
508 }
#define STATEMENTS_FOR_EACH_FUNC(stmt, stmts)
Definition: widltypes.h:596
static size_t double int int int * sign
Definition: printf.c:69
GLenum func
Definition: glext.h:6028
struct func_details * function
Definition: widltypes.h:426
static int is_valid_bitfield_type(const type_t *type)
Definition: typetree.c:365
static int is_global_namespace(const struct namespace *namespace)
Definition: widltypes.h:613
int type_is_equal(const type_t *type1, const type_t *type2)
Definition: typetree.c:495
void type_dispinterface_define_from_iface(type_t *dispiface, type_t *iface)
Definition: typetree.c:466
struct struct_details * structure
Definition: widltypes.h:424
#define TRUE
Definition: types.h:120
static const WCHAR separator[]
Definition: asmname.c:65
type_t * type_new_nonencapsulated_union(const char *name, int defined, var_list_t *fields)
Definition: typetree.c:330
static const var_t * find_arg(const var_list_t *args, const char *name)
Definition: typetree.c:68
char * strcat(char *DstString, const char *SrcString)
Definition: utclib.c:568
var_t * var
Definition: widltypes.h:538
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define TYPE_BASIC_INT_MAX
Definition: widltypes.h:281
type_t * make_type(enum type_type type)
Definition: typetree.c:44
struct coclass_details coclass
Definition: widltypes.h:430
#define free
Definition: debug_ros.c:5
type_t * duptype(type_t *t, int dupname)
Definition: typetree.c:33
static const struct encodedInt enums[]
Definition: encode.c:365
GLdouble GLdouble t
Definition: gl.h:2047
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define assert(x)
Definition: debug.h:53
name_type
Definition: typetree.h:27
void * arg
Definition: msvc.h:10
void add_incomplete(type_t *t)
Definition: parser.tab.c:6026
static enum type_basic_type type_basic_get_type(const type_t *type)
Definition: typetree.h:73
Definition: match.c:390
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: glext.h:10929
Definition: send.c:47
#define tsENUM
Definition: widltypes.h:566
type_type
Definition: widltypes.h:399
type_t * type_new_alias(type_t *t, const char *name)
Definition: typetree.c:190
type_t * type_new_array(const char *name, type_t *element, int declptr, unsigned int dim, expr_t *size_is, expr_t *length_is, unsigned char ptr_default_fc)
Definition: typetree.c:226
type_t * type_new_int(enum type_basic_type basic_type, int sign)
Definition: typetree.c:251
type_t * type_new_struct(char *name, struct namespace *namespace, int defined, var_list_t *fields)
Definition: typetree.c:300
type_basic_type
Definition: widltypes.h:260
__WINE_SERVER_LIST_INLINE struct list * list_head(const struct list *list)
Definition: list.h:131
#define tsUNION
Definition: widltypes.h:568
struct enumeration_details * enumeration
Definition: widltypes.h:425
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
const char * type_get_name(const type_t *type, enum name_type name_type)
Definition: typetree.c:81
void * xmalloc(int size)
Definition: uimain.c:747
type_t * type_new_enum(const char *name, struct namespace *namespace, int defined, var_list_t *enums)
Definition: typetree.c:274
__WINE_SERVER_LIST_INLINE unsigned int list_count(const struct list *list)
Definition: list.h:155
#define a
Definition: ke_i.h:78
GLenum GLint ref
Definition: glext.h:6028
static PVOID ptr
Definition: dispmode.c:27
unsigned int idx
Definition: utils.c:41
#define tsSTRUCT
Definition: widltypes.h:567
void error_loc(const char *s,...)
Definition: utils.c:69
char * format_namespace(struct namespace *namespace, const char *prefix, const char *separator, const char *suffix)
Definition: typetree.c:110
smooth NULL
Definition: ftsmooth.c:416
int do_typelib
Definition: widl.c:117
void init_loc_info(loc_info_t *i)
Definition: parser.tab.c:7200
union _statement_t::@4054 u
type_t * type_new_encapsulated_union(char *name, var_t *switch_field, var_t *union_field, var_list_t *cases)
Definition: typetree.c:353
void type_interface_define(type_t *iface, type_t *inherit, statement_list_t *stmts)
Definition: typetree.c:439
__WINE_SERVER_LIST_INLINE void list_remove(struct list *elem)
Definition: list.h:108
static int compute_method_indexes(type_t *iface)
Definition: typetree.c:416
#define d
Definition: ke_i.h:81
static enum type_type type_get_type(const type_t *type)
Definition: typetree.h:68
type_t * type
Definition: widltypes.h:452
Definition: parser.c:43
unsigned int defined
Definition: widltypes.h:442
union _type_t::@4053 details
char * name
Definition: compiler.c:66
static enum type_type type_get_type_detect_alias(const type_t *type)
Definition: widltypes.h:589
type_t * type_new_pointer(unsigned char pointer_default, type_t *ref, attr_list_t *attrs)
Definition: typetree.c:181
struct iface_details * iface
Definition: widltypes.h:427
type_t * alloc_type(void)
Definition: parser.tab.c:5517
const char * name
Definition: widltypes.h:418
static type_t * type_iface_get_inherit(const type_t *type)
Definition: typetree.h:158
void type_module_define(type_t *module, statement_list_t *stmts)
Definition: typetree.c:480
int ret
uint32_t entry
Definition: isohybrid.c:63
GLenum GLsizei len
Definition: glext.h:6722
Definition: _list.h:228
type_t * type_new_function(var_list_t *args)
Definition: typetree.c:131
int use_abi_namespace
Definition: widl.c:130
type_t * type_new_coclass(char *name)
Definition: typetree.c:215
type_t * type_new_basic(enum type_basic_type basic_type)
Definition: typetree.c:243
static unsigned char pointer_default
Definition: parser.tab.c:114
type_t * find_type(const char *name, struct namespace *namespace, int t)
Definition: parser.tab.c:6139
type_t * type_coclass_define(type_t *coclass, ifref_list_t *ifaces)
Definition: typetree.c:488
type_t * type_new_module(char *name)
Definition: typetree.c:205
var_list_t * append_var(var_list_t *list, var_t *var)
Definition: parser.tab.c:5852
const var_t * is_callas(const attr_list_t *a)
Definition: header.c:943
const char * name
Definition: widltypes.h:392
void type_dispinterface_define(type_t *iface, var_list_t *props, var_list_t *methods)
Definition: typetree.c:452
struct basic_details basic
Definition: widltypes.h:431
#define parse_only
Definition: parser.h:44
Definition: name.c:38
static const WCHAR props[]
Definition: wbemdisp.c:288
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
_ForwardIter unique(_ForwardIter __first, _ForwardIter __last)
Definition: _algo.h:298
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
struct hlsl_type * get_type(struct hlsl_scope *scope, const char *name, BOOL recursive) DECLSPEC_HIDDEN
Definition: utils.c:841
var_t * make_var(char *name)
Definition: parser.tab.c:5876
type_t * type_new_bitfield(type_t *field, const expr_t *bits)
Definition: typetree.c:398
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
static char * append_namespace(char *ptr, struct namespace *namespace, const char *separator)
Definition: typetree.c:94
struct namespace * parent
Definition: widltypes.h:393
char * xstrdup(const char *s)
Definition: uimain.c:768
type_t * type_new_void(void)
Definition: typetree.c:266
#define LIST_ENTRY(type)
Definition: queue.h:175
static statement_list_t * type_iface_get_stmts(const type_t *type)
Definition: typetree.h:151
#define memset(x, y, z)
Definition: compat.h:39
type_t * reg_type(type_t *type, const char *name, struct namespace *namespace, int t)
Definition: parser.tab.c:5992
#define args
Definition: format.c:66
IMAGEHLP_MODULEW64 module
GLuint const GLchar * name
Definition: glext.h:6031