ReactOS  0.4.13-dev-247-g0f29b3f
typetree.c File Reference
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "widl.h"
#include "utils.h"
#include "parser.h"
#include "typetree.h"
#include "header.h"
Include dependency graph for typetree.c:

Go to the source code of this file.

Functions

type_tduptype (type_t *t, int dupname)
 
type_tmake_type (enum type_type type)
 
static const var_tfind_arg (const var_list_t *args, const char *name)
 
const chartype_get_name (const type_t *type, enum name_type name_type)
 
static charappend_namespace (char *ptr, struct namespace *namespace, const char *separator)
 
charformat_namespace (struct namespace *namespace, const char *prefix, const char *separator, const char *suffix)
 
type_ttype_new_function (var_list_t *args)
 
type_ttype_new_pointer (unsigned char pointer_default, type_t *ref, attr_list_t *attrs)
 
type_ttype_new_alias (type_t *t, const char *name)
 
type_ttype_new_module (char *name)
 
type_ttype_new_coclass (char *name)
 
type_ttype_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)
 
type_ttype_new_basic (enum type_basic_type basic_type)
 
type_ttype_new_int (enum type_basic_type basic_type, int sign)
 
type_ttype_new_void (void)
 
type_ttype_new_enum (const char *name, struct namespace *namespace, int defined, var_list_t *enums)
 
type_ttype_new_struct (char *name, struct namespace *namespace, int defined, var_list_t *fields)
 
type_ttype_new_nonencapsulated_union (const char *name, int defined, var_list_t *fields)
 
type_ttype_new_encapsulated_union (char *name, var_t *switch_field, var_t *union_field, var_list_t *cases)
 
static int is_valid_bitfield_type (const type_t *type)
 
type_ttype_new_bitfield (type_t *field, const expr_t *bits)
 
static int compute_method_indexes (type_t *iface)
 
void type_interface_define (type_t *iface, type_t *inherit, statement_list_t *stmts)
 
void type_dispinterface_define (type_t *iface, var_list_t *props, var_list_t *methods)
 
void type_dispinterface_define_from_iface (type_t *dispiface, type_t *iface)
 
void type_module_define (type_t *module, statement_list_t *stmts)
 
type_ttype_coclass_define (type_t *coclass, ifref_list_t *ifaces)
 
int type_is_equal (const type_t *type1, const type_t *type2)
 

Function Documentation

◆ append_namespace()

static char* append_namespace ( char ptr,
struct namespace namespace,
const char separator 
)
static

Definition at line 94 of file typetree.c.

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 }
static int is_global_namespace(const struct namespace *namespace)
Definition: widltypes.h:613
static const WCHAR separator[]
Definition: asmname.c:63
char * strcat(char *DstString, const char *SrcString)
Definition: utclib.c:568
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
static PVOID ptr
Definition: dispmode.c:27
int use_abi_namespace
Definition: widl.c:130
const char * name
Definition: widltypes.h:392
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
static char * append_namespace(char *ptr, struct namespace *namespace, const char *separator)
Definition: typetree.c:94
struct namespace * parent
Definition: widltypes.h:393

Referenced by format_namespace().

◆ compute_method_indexes()

static int compute_method_indexes ( type_t iface)
static

Definition at line 416 of file typetree.c.

417 {
418  int idx;
419  statement_t *stmt;
420 
421  if (!iface->details.iface)
422  return 0;
423 
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 }
#define STATEMENTS_FOR_EACH_FUNC(stmt, stmts)
Definition: widltypes.h:596
GLenum func
Definition: glext.h:6028
struct func_details * function
Definition: widltypes.h:426
var_t * var
Definition: widltypes.h:538
union _type_t::@4021 details
unsigned int idx
Definition: utils.c:41
static int compute_method_indexes(type_t *iface)
Definition: typetree.c:416
type_t * type
Definition: widltypes.h:452
struct iface_details * iface
Definition: widltypes.h:427
static type_t * type_iface_get_inherit(const type_t *type)
Definition: typetree.h:158
const var_t * is_callas(const attr_list_t *a)
Definition: header.c:943
const type_t * iface
Definition: typegen.c:57
union _statement_t::@4022 u
static statement_list_t * type_iface_get_stmts(const type_t *type)
Definition: typetree.h:151

Referenced by type_dispinterface_define(), type_dispinterface_define_from_iface(), and type_interface_define().

◆ duptype()

type_t* duptype ( type_t t,
int  dupname 
)

Definition at line 33 of file typetree.c.

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 }
char * name
Definition: wpp.c:36
GLdouble GLdouble t
Definition: gl.h:2047
#define d
Definition: ke_i.h:81
type_t * alloc_type(void)
Definition: parser.tab.c:5517
char * xstrdup(const char *s)
Definition: uimain.c:768

Referenced by declare_var(), make_decl_spec(), and type_new_alias().

◆ find_arg()

static const var_t* find_arg ( const var_list_t args,
const char name 
)
static

Definition at line 68 of file typetree.c.

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 }
void * arg
Definition: msvc.h:12
Definition: match.c:390
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
smooth NULL
Definition: ftsmooth.c:416
uint32_t entry
Definition: isohybrid.c:63
Definition: name.c:36
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469

Referenced by type_new_function().

◆ format_namespace()

char* format_namespace ( struct namespace namespace,
const char prefix,
const char separator,
const char suffix 
)

Definition at line 110 of file typetree.c.

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 }
static int is_global_namespace(const struct namespace *namespace)
Definition: widltypes.h:613
static const WCHAR separator[]
Definition: asmname.c:63
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
void * xmalloc(int size)
Definition: uimain.c:747
static PVOID ptr
Definition: dispmode.c:27
int ret
GLenum GLsizei len
Definition: glext.h:6722
int use_abi_namespace
Definition: widl.c:130
const char * name
Definition: widltypes.h:392
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
static char * append_namespace(char *ptr, struct namespace *namespace, const char *separator)
Definition: typetree.c:94
struct namespace * parent
Definition: widltypes.h:393

Referenced by reg_type(), and write_uuid_decl().

◆ is_valid_bitfield_type()

static int is_valid_bitfield_type ( const type_t type)
static

Definition at line 365 of file typetree.c.

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 }
#define TRUE
Definition: types.h:120
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
static enum type_basic_type type_basic_get_type(const type_t *type)
Definition: typetree.h:73
static enum type_type type_get_type(const type_t *type)
Definition: typetree.h:68

Referenced by type_new_bitfield().

◆ make_type()

type_t* make_type ( enum type_type  type)

Definition at line 44 of file typetree.c.

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 }
GLdouble GLdouble t
Definition: gl.h:2047
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
smooth NULL
Definition: ftsmooth.c:416
void init_loc_info(loc_info_t *i)
Definition: parser.tab.c:7200
type_t * alloc_type(void)
Definition: parser.tab.c:5517
#define parse_only
Definition: parser.h:44
#define memset(x, y, z)
Definition: compat.h:39

Referenced by get_type(), type_new_array(), type_new_basic(), type_new_bitfield(), type_new_enum(), type_new_function(), type_new_nonencapsulated_union(), type_new_pointer(), type_new_struct(), and type_new_void().

◆ type_coclass_define()

type_t* type_coclass_define ( type_t coclass,
ifref_list_t ifaces 
)

Definition at line 488 of file typetree.c.

489 {
490  coclass->details.coclass.ifaces = ifaces;
491  coclass->defined = TRUE;
492  return coclass;
493 }
#define TRUE
Definition: types.h:120
union _type_t::@4021 details
struct coclass_details coclass
Definition: widltypes.h:430
unsigned int defined
Definition: widltypes.h:442

Referenced by yyparse().

◆ type_dispinterface_define()

void type_dispinterface_define ( type_t iface,
var_list_t props,
var_list_t methods 
)

Definition at line 452 of file typetree.c.

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 }
#define TRUE
Definition: types.h:120
union _type_t::@4021 details
void * xmalloc(int size)
Definition: uimain.c:747
void error_loc(const char *s,...)
Definition: utils.c:69
smooth NULL
Definition: ftsmooth.c:416
static int compute_method_indexes(type_t *iface)
Definition: typetree.c:416
unsigned int defined
Definition: widltypes.h:442
struct iface_details * iface
Definition: widltypes.h:427
type_t * find_type(const char *name, struct namespace *namespace, int t)
Definition: parser.tab.c:6139
static const WCHAR props[]
Definition: wbemdisp.c:288

Referenced by yyparse().

◆ type_dispinterface_define_from_iface()

void type_dispinterface_define_from_iface ( type_t dispiface,
type_t iface 
)

Definition at line 466 of file typetree.c.

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 }
#define TRUE
Definition: types.h:120
union _type_t::@4021 details
void * xmalloc(int size)
Definition: uimain.c:747
void error_loc(const char *s,...)
Definition: utils.c:69
smooth NULL
Definition: ftsmooth.c:416
static int compute_method_indexes(type_t *iface)
Definition: typetree.c:416
unsigned int defined
Definition: widltypes.h:442
struct iface_details * iface
Definition: widltypes.h:427
type_t * find_type(const char *name, struct namespace *namespace, int t)
Definition: parser.tab.c:6139

Referenced by yyparse().

◆ type_get_name()

const char* type_get_name ( const type_t type,
enum name_type name_type   
)

Definition at line 81 of file typetree.c.

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 }
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define assert(x)
Definition: debug.h:53
name_type
Definition: typetree.h:27
smooth NULL
Definition: ftsmooth.c:416

Referenced by write_type_left().

◆ type_interface_define()

void type_interface_define ( type_t iface,
type_t inherit,
statement_list_t stmts 
)

Definition at line 439 of file typetree.c.

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 }
#define TRUE
Definition: types.h:120
union _type_t::@4021 details
void * xmalloc(int size)
Definition: uimain.c:747
smooth NULL
Definition: ftsmooth.c:416
static int compute_method_indexes(type_t *iface)
Definition: typetree.c:416
unsigned int defined
Definition: widltypes.h:442
struct iface_details * iface
Definition: widltypes.h:427

Referenced by check_async_uuid(), and yyparse().

◆ type_is_equal()

int type_is_equal ( const type_t type1,
const type_t type2 
)

Definition at line 495 of file typetree.c.

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 }
static enum type_type type_get_type_detect_alias(const type_t *type)
Definition: widltypes.h:589
const char * name
Definition: widltypes.h:418
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469

Referenced by fix_incomplete_types().

◆ type_module_define()

void type_module_define ( type_t module,
statement_list_t stmts 
)

Definition at line 480 of file typetree.c.

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 }
#define TRUE
Definition: types.h:120
void * xmalloc(int size)
Definition: uimain.c:747
void error_loc(const char *s,...)
Definition: utils.c:69
IMAGEHLP_MODULEW64 module

Referenced by yyparse().

◆ type_new_alias()

type_t* type_new_alias ( type_t t,
const char name 
)

Definition at line 190 of file typetree.c.

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 }
#define TRUE
Definition: types.h:120
type_t * duptype(type_t *t, int dupname)
Definition: typetree.c:33
GLdouble GLdouble t
Definition: gl.h:2047
#define a
Definition: ke_i.h:78
smooth NULL
Definition: ftsmooth.c:416
void init_loc_info(loc_info_t *i)
Definition: parser.tab.c:7200
Definition: name.c:36
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
char * xstrdup(const char *s)
Definition: uimain.c:768

Referenced by decl_builtin_alias(), make_safearray(), and reg_typedefs().

◆ type_new_array()

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 at line 226 of file typetree.c.

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 }
type_t * make_type(enum type_type type)
Definition: typetree.c:44
GLdouble GLdouble t
Definition: gl.h:2047
Definition: name.c:36
char * xstrdup(const char *s)
Definition: uimain.c:768

Referenced by append_array(), declare_var(), and make_safearray().

◆ type_new_basic()

type_t* type_new_basic ( enum type_basic_type  basic_type)

Definition at line 243 of file typetree.c.

244 {
246  t->details.basic.type = basic_type;
247  t->details.basic.sign = 0;
248  return t;
249 }
type_t * make_type(enum type_type type)
Definition: typetree.c:44
GLdouble GLdouble t
Definition: gl.h:2047

Referenced by decl_builtin_basic(), init_types(), resolve_expression(), and type_new_int().

◆ type_new_bitfield()

type_t* type_new_bitfield ( type_t field,
const expr_t bits 
)

Definition at line 398 of file typetree.c.

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 }
static int is_valid_bitfield_type(const type_t *type)
Definition: typetree.c:365
type_t * make_type(enum type_type type)
Definition: typetree.c:44
GLdouble GLdouble t
Definition: gl.h:2047
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: glext.h:10929
void error_loc(const char *s,...)
Definition: utils.c:69
Definition: parser.c:43

Referenced by declare_var().

◆ type_new_coclass()

type_t* type_new_coclass ( char name)

Definition at line 215 of file typetree.c.

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 }
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
void error_loc(const char *s,...)
Definition: utils.c:69
smooth NULL
Definition: ftsmooth.c:416
Definition: name.c:36
struct hlsl_type * get_type(struct hlsl_scope *scope, const char *name, BOOL recursive) DECLSPEC_HIDDEN
Definition: utils.c:844
GLuint const GLchar * name
Definition: glext.h:6031

Referenced by yyparse().

◆ type_new_encapsulated_union()

type_t* type_new_encapsulated_union ( char name,
var_t switch_field,
var_t union_field,
var_list_t cases 
)

Definition at line 353 of file typetree.c.

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 }
#define TRUE
Definition: types.h:120
type_t * type_new_nonencapsulated_union(const char *name, int defined, var_list_t *fields)
Definition: typetree.c:330
GLdouble GLdouble t
Definition: gl.h:2047
#define tsUNION
Definition: widltypes.h:568
void * xmalloc(int size)
Definition: uimain.c:747
smooth NULL
Definition: ftsmooth.c:416
type_t * type
Definition: widltypes.h:452
var_list_t * append_var(var_list_t *list, var_t *var)
Definition: parser.tab.c:5852
Definition: name.c:36
struct hlsl_type * get_type(struct hlsl_scope *scope, const char *name, BOOL recursive) DECLSPEC_HIDDEN
Definition: utils.c:844
var_t * make_var(char *name)
Definition: parser.tab.c:5876
char * xstrdup(const char *s)
Definition: uimain.c:768

Referenced by yyparse().

◆ type_new_enum()

type_t* type_new_enum ( const char name,
struct namespace namespace,
int  defined,
var_list_t enums 
)

Definition at line 274 of file typetree.c.

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 }
#define TRUE
Definition: types.h:120
union _type_t::@4021 details
type_t * make_type(enum type_type type)
Definition: typetree.c:44
static const struct encodedInt enums[]
Definition: encode.c:365
GLdouble GLdouble t
Definition: gl.h:2047
void add_incomplete(type_t *t)
Definition: parser.tab.c:6026
#define tsENUM
Definition: widltypes.h:566
struct enumeration_details * enumeration
Definition: widltypes.h:425
void * xmalloc(int size)
Definition: uimain.c:747
smooth NULL
Definition: ftsmooth.c:416
type_t * find_type(const char *name, struct namespace *namespace, int t)
Definition: parser.tab.c:6139
Definition: name.c:36
type_t * reg_type(type_t *type, const char *name, struct namespace *namespace, int t)
Definition: parser.tab.c:5992
GLuint const GLchar * name
Definition: glext.h:6031

Referenced by yyparse().

◆ type_new_function()

type_t* type_new_function ( var_list_t args)

Definition at line 131 of file typetree.c.

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 }
static const var_t * find_arg(const var_list_t *args, const char *name)
Definition: typetree.c:68
type_t * make_type(enum type_type type)
Definition: typetree.c:44
#define free
Definition: debug_ros.c:5
GLdouble GLdouble t
Definition: gl.h:2047
void * arg
Definition: msvc.h:12
Definition: match.c:390
__WINE_SERVER_LIST_INLINE struct list * list_head(const struct list *list)
Definition: list.h:131
#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
void * xmalloc(int size)
Definition: uimain.c:747
__WINE_SERVER_LIST_INLINE unsigned int list_count(const struct list *list)
Definition: list.h:155
void error_loc(const char *s,...)
Definition: utils.c:69
smooth NULL
Definition: ftsmooth.c:416
__WINE_SERVER_LIST_INLINE void list_remove(struct list *elem)
Definition: list.h:108
static enum type_type type_get_type(const type_t *type)
Definition: typetree.h:68
uint32_t entry
Definition: isohybrid.c:63
Definition: name.c:36
_ForwardIter unique(_ForwardIter __first, _ForwardIter __last)
Definition: _algo.h:298
char * xstrdup(const char *s)
Definition: uimain.c:768
#define LIST_ENTRY(type)
Definition: queue.h:175
#define args
Definition: format.c:66

Referenced by check_async_uuid(), and yyparse().

◆ type_new_int()

type_t* type_new_int ( enum type_basic_type  basic_type,
int  sign 
)

Definition at line 251 of file typetree.c.

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 }
static size_t double int int int * sign
Definition: printf.c:64
union _type_t::@4021 details
#define TYPE_BASIC_INT_MAX
Definition: widltypes.h:281
#define assert(x)
Definition: debug.h:53
type_t * type_new_basic(enum type_basic_type basic_type)
Definition: typetree.c:243
struct basic_details basic
Definition: widltypes.h:431

Referenced by resolve_expression(), and yyparse().

◆ type_new_module()

type_t* type_new_module ( char name)

Definition at line 205 of file typetree.c.

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 }
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
void error_loc(const char *s,...)
Definition: utils.c:69
smooth NULL
Definition: ftsmooth.c:416
Definition: name.c:36
struct hlsl_type * get_type(struct hlsl_scope *scope, const char *name, BOOL recursive) DECLSPEC_HIDDEN
Definition: utils.c:844
GLuint const GLchar * name
Definition: glext.h:6031

Referenced by yyparse().

◆ type_new_nonencapsulated_union()

type_t* type_new_nonencapsulated_union ( const char name,
int  defined,
var_list_t fields 
)

Definition at line 330 of file typetree.c.

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 }
struct struct_details * structure
Definition: widltypes.h:424
#define TRUE
Definition: types.h:120
union _type_t::@4021 details
type_t * make_type(enum type_type type)
Definition: typetree.c:44
GLdouble GLdouble t
Definition: gl.h:2047
void add_incomplete(type_t *t)
Definition: parser.tab.c:6026
#define tsUNION
Definition: widltypes.h:568
void * xmalloc(int size)
Definition: uimain.c:747
smooth NULL
Definition: ftsmooth.c:416
type_t * find_type(const char *name, struct namespace *namespace, int t)
Definition: parser.tab.c:6139
Definition: name.c:36
type_t * reg_type(type_t *type, const char *name, struct namespace *namespace, int t)
Definition: parser.tab.c:5992
GLuint const GLchar * name
Definition: glext.h:6031

Referenced by type_new_encapsulated_union(), and yyparse().

◆ type_new_pointer()

type_t* type_new_pointer ( unsigned char  pointer_default,
type_t ref,
attr_list_t attrs 
)

Definition at line 181 of file typetree.c.

182 {
184  t->details.pointer.def_fc = pointer_default;
185  t->details.pointer.ref = ref;
186  t->attrs = attrs;
187  return t;
188 }
type_t * make_type(enum type_type type)
Definition: typetree.c:44
GLdouble GLdouble t
Definition: gl.h:2047
GLenum GLint ref
Definition: glext.h:6028
static unsigned char pointer_default
Definition: parser.tab.c:114

Referenced by resolve_expression(), and yyparse().

◆ type_new_struct()

type_t* type_new_struct ( char name,
struct namespace namespace,
int  defined,
var_list_t fields 
)

Definition at line 300 of file typetree.c.

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 }
struct struct_details * structure
Definition: widltypes.h:424
#define TRUE
Definition: types.h:120
union _type_t::@4021 details
type_t * make_type(enum type_type type)
Definition: typetree.c:44
GLdouble GLdouble t
Definition: gl.h:2047
void add_incomplete(type_t *t)
Definition: parser.tab.c:6026
void * xmalloc(int size)
Definition: uimain.c:747
#define tsSTRUCT
Definition: widltypes.h:567
smooth NULL
Definition: ftsmooth.c:416
int do_typelib
Definition: widl.c:117
type_t * find_type(const char *name, struct namespace *namespace, int t)
Definition: parser.tab.c:6139
Definition: name.c:36
type_t * reg_type(type_t *type, const char *name, struct namespace *namespace, int t)
Definition: parser.tab.c:5992
GLuint const GLchar * name
Definition: glext.h:6031

Referenced by yyparse().

◆ type_new_void()

type_t* type_new_void ( void  )

Definition at line 266 of file typetree.c.

267 {
268  static type_t *void_type = NULL;
269  if (!void_type)
270  void_type = make_type(TYPE_VOID);
271  return void_type;
272 }
type_t * make_type(enum type_type type)
Definition: typetree.c:44
smooth NULL
Definition: ftsmooth.c:416

Referenced by yyparse().