ReactOS 0.4.15-dev-7660-g0086d05
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");
101 return ptr + strlen(ptr);
102 }
103
107 return ptr + strlen(ptr);
108}
char * strcat(char *DstString, const char *SrcString)
Definition: utclib.c:568
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
static const WCHAR separator[]
Definition: asmname.c:65
static PVOID ptr
Definition: dispmode.c:27
struct namespace * parent
Definition: widltypes.h:394
const char * name
Definition: widltypes.h:393
static char * append_namespace(char *ptr, struct namespace *namespace, const char *separator)
Definition: typetree.c:94
int use_abi_namespace
Definition: widl.c:130
static int is_global_namespace(const struct namespace *namespace)
Definition: widltypes.h:614

Referenced by append_namespace(), and 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
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}
unsigned int idx
Definition: utils.c:41
GLenum func
Definition: glext.h:6028
const var_t * is_callas(const attr_list_t *a)
Definition: header.c:943
var_t * var
Definition: widltypes.h:539
union _statement_t::@5026 u
struct func_details * function
Definition: widltypes.h:427
union _type_t::@5025 details
struct iface_details * iface
Definition: widltypes.h:428
type_t * type
Definition: widltypes.h:453
static int compute_method_indexes(type_t *iface)
Definition: typetree.c:416
static type_t * type_iface_get_inherit(const type_t *type)
Definition: typetree.h:158
static statement_list_t * type_iface_get_stmts(const type_t *type)
Definition: typetree.h:151
#define STATEMENTS_FOR_EACH_FUNC(stmt, stmts)
Definition: widltypes.h:597

Referenced by compute_method_indexes(), 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 * xstrdup(const char *s)
Definition: uimain.c:768
GLdouble GLdouble t
Definition: gl.h:2047
#define d
Definition: ke_i.h:81
char * name
Definition: compiler.c:66
type_t * alloc_type(void)

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

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}
void * xmalloc(int size)
Definition: uimain.c:747
GLenum GLsizei len
Definition: glext.h:6722
int ret

Referenced by 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:
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:
390 return FALSE;
391 }
392 return FALSE;
393 default:
394 return FALSE;
395 }
396}
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
static enum type_type type_get_type(const type_t *type)
Definition: typetree.h:68
static enum type_basic_type type_basic_get_type(const type_t *type)
Definition: typetree.h:73
@ TYPE_ENUM
Definition: widltypes.h:404
@ TYPE_BASIC
Definition: widltypes.h:403
@ TYPE_BASIC_DOUBLE
Definition: widltypes.h:275
@ TYPE_BASIC_INT32
Definition: widltypes.h:265
@ TYPE_BASIC_ERROR_STATUS_T
Definition: widltypes.h:276
@ TYPE_BASIC_CHAR
Definition: widltypes.h:270
@ TYPE_BASIC_WCHAR
Definition: widltypes.h:273
@ TYPE_BASIC_INT16
Definition: widltypes.h:264
@ TYPE_BASIC_HYPER
Definition: widltypes.h:271
@ TYPE_BASIC_HANDLE
Definition: widltypes.h:277
@ TYPE_BASIC_INT8
Definition: widltypes.h:263
@ TYPE_BASIC_INT3264
Definition: widltypes.h:268
@ TYPE_BASIC_LONG
Definition: widltypes.h:269
@ TYPE_BASIC_INT64
Definition: widltypes.h:266
@ TYPE_BASIC_BYTE
Definition: widltypes.h:272
@ TYPE_BASIC_INT
Definition: widltypes.h:267
@ TYPE_BASIC_FLOAT
Definition: widltypes.h:274

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}
#define memset(x, y, z)
Definition: compat.h:39
#define parse_only
Definition: parser.h:44
void init_loc_info(loc_info_t *)

Referenced by 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}
struct coclass_details coclass
Definition: widltypes.h:431
unsigned int defined
Definition: widltypes.h:443

◆ 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;
464}
void error_loc(const char *s,...)
Definition: utils.c:69
static const WCHAR props[]
Definition: wbemdisp.c:288
type_t * find_type(const char *name, struct namespace *namespace, int t)

◆ 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}

◆ type_get_name()

const char * type_get_name ( const type_t type,
enum name_type 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}
#define assert(x)
Definition: debug.h:53
name_type
Definition: typetree.h:27
@ NAME_C
Definition: typetree.h:29
@ NAME_DEFAULT
Definition: typetree.h:28

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;
450}

◆ 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}
const char * name
Definition: widltypes.h:419
static enum type_type type_get_type_detect_alias(const type_t *type)
Definition: widltypes.h:590

◆ 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}
IMAGEHLP_MODULEW64 module

◆ 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}
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
#define a
Definition: ke_i.h:78
type_t * duptype(type_t *t, int dupname)
Definition: typetree.c:33

◆ 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
@ TYPE_ARRAY
Definition: widltypes.h:414

◆ 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}

Referenced by 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}
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: glext.h:10929
#define bits
Definition: infblock.c:15
Definition: parser.c:44
static int is_valid_bitfield_type(const type_t *type)
Definition: typetree.c:365
@ TYPE_BITFIELD
Definition: widltypes.h:415

◆ 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}
struct hlsl_type * get_type(struct hlsl_scope *scope, const char *name, BOOL recursive) DECLSPEC_HIDDEN
Definition: utils.c:841
@ TYPE_COCLASS
Definition: widltypes.h:410

◆ 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}
type_t * type_new_nonencapsulated_union(const char *name, int defined, var_list_t *fields)
Definition: typetree.c:330
var_list_t * append_var(var_list_t *list, var_t *var)
#define tsUNION
Definition: widltypes.h:569
@ TYPE_ENCAPSULATED_UNION
Definition: widltypes.h:406
var_t * make_var(char *name)

◆ 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
296 }
297 return t;
298}
static const struct encodedInt enums[]
Definition: encode.c:365
struct enumeration_details * enumeration
Definition: widltypes.h:426
#define tsENUM
Definition: widltypes.h:567
type_t * reg_type(type_t *type, const char *name, struct namespace *namespace, int t)
void add_incomplete(type_t *t)

◆ 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;
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 void list_remove(struct list_entry *entry)
Definition: list.h:90
#define free
Definition: debug_ros.c:5
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
__WINE_SERVER_LIST_INLINE unsigned int list_count(const struct list *list)
Definition: list.h:155
#define args
Definition: format.c:66
Definition: list.h:15
#define LIST_ENTRY(type)
Definition: queue.h:175
static const var_t * find_arg(const var_list_t *args, const char *name)
Definition: typetree.c:68
@ TYPE_VOID
Definition: widltypes.h:402
@ TYPE_FUNCTION
Definition: widltypes.h:411

◆ 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}
#define sign(x)
Definition: mapdesc.cc:613
struct basic_details basic
Definition: widltypes.h:432
type_t * type_new_basic(enum type_basic_type basic_type)
Definition: typetree.c:243
#define TYPE_BASIC_INT_MAX
Definition: widltypes.h:282

Referenced by resolve_expression().

◆ 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}
@ TYPE_MODULE
Definition: widltypes.h:409

◆ 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)
347 else
349 }
350 return t;
351}
const char * fields[10]
Definition: parser.c:313
struct struct_details * structure
Definition: widltypes.h:425
@ TYPE_UNION
Definition: widltypes.h:407

Referenced by type_new_encapsulated_union().

◆ 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}
coclass PSFactoryBuffer pointer_default(unique)] interface ObjectRpcBaseTypes
Definition: dcom.idl:35
Definition: send.c:48
@ TYPE_POINTER
Definition: widltypes.h:413

Referenced by resolve_expression().

◆ 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
326 }
327 return t;
328}
int do_typelib
Definition: widl.c:117
@ TYPE_STRUCT
Definition: widltypes.h:405
#define tsSTRUCT
Definition: widltypes.h:568

◆ 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}