parser.y 88.3 KB
Newer Older
1 2 3 4 5
%{
/*
 * IDL Compiler
 *
 * Copyright 2002 Ove Kaaven
6
 * Copyright 2006-2008 Robert Shearman
7 8 9 10 11 12 13 14 15 16 17 18 19
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
 */

#include "config.h"

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <assert.h>
#include <ctype.h>
#include <string.h>

#include "widl.h"
#include "utils.h"
#include "parser.h"
#include "header.h"
36
#include "typelib.h"
37
#include "typegen.h"
38
#include "expr.h"
39
#include "typetree.h"
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

#if defined(YYBYACC)
	/* Berkeley yacc (byacc) doesn't seem to know about these */
	/* Some *BSD supplied versions do define these though */
# ifndef YYEMPTY
#  define YYEMPTY	(-1)	/* Empty lookahead value of yychar */
# endif
# ifndef YYLEX
#  define YYLEX		yylex()
# endif

#elif defined(YYBISON)
	/* Bison was used for original development */
	/* #define YYEMPTY -2 */
	/* #define YYLEX   yylex() */

#else
	/* No yacc we know yet */
# if !defined(YYEMPTY) || !defined(YYLEX)
#  error Yacc version/type unknown. This version needs to be verified for settings of YYEMPTY and YYLEX.
# elif defined(__GNUC__)	/* gcc defines the #warning directive */
#  warning Yacc version/type unknown. It defines YYEMPTY and YYLEX, but is not tested
  /* #else we just take a chance that it works... */
# endif
#endif

66 67
#define YYERROR_VERBOSE

68
static unsigned char pointer_default = RPC_FC_UP;
69
static int is_object_interface = FALSE;
70

71 72 73 74 75 76
typedef struct list typelist_t;
struct typenode {
  type_t *type;
  struct list entry;
};

77 78 79 80 81 82
struct _import_t
{
  char *name;
  int import_performed;
};

83 84 85 86 87 88 89
typedef struct _decl_spec_t
{
  type_t *type;
  attr_list_t *attrs;
  enum storage_class stgclass;
} decl_spec_t;

90 91 92
typelist_t incomplete_types = LIST_INIT(incomplete_types);

static void fix_incomplete(void);
93
static void fix_incomplete_types(type_t *complete_type);
94

95
static str_list_t *append_str(str_list_t *list, char *str);
96
static attr_list_t *append_attr(attr_list_t *list, attr_t *attr);
97
static attr_list_t *append_attr_list(attr_list_t *new_list, attr_list_t *old_list);
98
static decl_spec_t *make_decl_spec(type_t *type, decl_spec_t *left, decl_spec_t *right, attr_t *attr, enum storage_class stgclass);
99
static attr_t *make_attr(enum attr_type type);
100
static attr_t *make_attrv(enum attr_type type, unsigned long val);
101
static attr_t *make_attrp(enum attr_type type, void *val);
102 103
static expr_list_t *append_expr(expr_list_t *list, expr_t *expr);
static array_dims_t *append_array(array_dims_t *list, expr_t *expr);
104
static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const declarator_t *decl, int top);
105
static var_list_t *set_var_types(attr_list_t *attrs, decl_spec_t *decl_spec, declarator_list_t *decls);
106
static ifref_list_t *append_ifref(ifref_list_t *list, ifref_t *iface);
107
static ifref_t *make_ifref(type_t *iface);
108
static var_list_t *append_var_list(var_list_t *list, var_list_t *vars);
109 110
static declarator_list_t *append_declarator(declarator_list_t *list, declarator_t *p);
static declarator_t *make_declarator(var_t *var);
111
static func_list_t *append_func(func_list_t *list, func_t *func);
112
static func_t *make_func(var_t *def);
113
static type_t *make_safearray(type_t *type);
114
static typelib_t *make_library(const char *name, const attr_list_t *attrs);
115
static type_t *append_ptrchain_type(type_t *ptrchain, type_t *type);
116

117
static type_t *reg_typedefs(decl_spec_t *decl_spec, var_list_t *names, attr_list_t *attrs);
118 119
static type_t *find_type_or_error(const char *name, int t);
static type_t *find_type_or_error2(char *name, int t);
120

121 122
static var_t *reg_const(var_t *var);

123
static char *gen_name(void);
124
static void check_arg_attrs(const var_t *arg);
125
static void check_statements(const statement_list_t *stmts, int is_inside_library);
126
static void check_all_user_types(const statement_list_t *stmts);
127
static attr_list_t *check_iface_attrs(const char *name, attr_list_t *attrs);
128
static attr_list_t *check_function_attrs(const char *name, attr_list_t *attrs);
129
static attr_list_t *check_typedef_attrs(attr_list_t *attrs);
130 131 132
static attr_list_t *check_enum_attrs(attr_list_t *attrs);
static attr_list_t *check_struct_attrs(attr_list_t *attrs);
static attr_list_t *check_union_attrs(attr_list_t *attrs);
133
static attr_list_t *check_field_attrs(const char *name, attr_list_t *attrs);
134
static attr_list_t *check_library_attrs(const char *name, attr_list_t *attrs);
135
static attr_list_t *check_dispiface_attrs(const char *name, attr_list_t *attrs);
136 137
static attr_list_t *check_module_attrs(const char *name, attr_list_t *attrs);
static attr_list_t *check_coclass_attrs(const char *name, attr_list_t *attrs);
138
const char *get_attr_display_name(enum attr_type type);
139
static void add_explicit_handle_if_necessary(var_t *func);
140
static void check_def(const type_t *t);
141

142 143 144
static statement_t *make_statement(enum statement_type type);
static statement_t *make_statement_type_decl(type_t *type);
static statement_t *make_statement_reference(type_t *type);
145
static statement_t *make_statement_declaration(var_t *var);
146 147 148 149
static statement_t *make_statement_library(typelib_t *typelib);
static statement_t *make_statement_cppquote(const char *str);
static statement_t *make_statement_importlib(const char *str);
static statement_t *make_statement_module(type_t *type);
150
static statement_t *make_statement_typedef(var_list_t *names);
151
static statement_t *make_statement_import(const char *str);
152
static statement_t *make_statement_typedef(var_list_t *names);
153 154
static statement_list_t *append_statement(statement_list_t *list, statement_t *stmt);

155 156 157
%}
%union {
	attr_t *attr;
158
	attr_list_t *attr_list;
159
	str_list_t *str_list;
160
	expr_t *expr;
161 162
	expr_list_t *expr_list;
	array_dims_t *array_dims;
163 164
	type_t *type;
	var_t *var;
165
	var_list_t *var_list;
166 167
	declarator_t *declarator;
	declarator_list_t *declarator_list;
168
	func_t *func;
169
	func_list_t *func_list;
170 171
	statement_t *statement;
	statement_list_t *stmt_list;
172
	ifref_t *ifref;
173
	ifref_list_t *ifref_list;
174
	char *str;
175
	UUID *uuid;
176
	unsigned int num;
177
	double dbl;
178
	interface_info_t ifinfo;
179 180
	typelib_t *typelib;
	struct _import_t *import;
181 182
	struct _decl_spec_t *declspec;
	enum storage_class stgclass;
183 184 185 186
}

%token <str> aIDENTIFIER
%token <str> aKNOWNTYPE
187
%token <num> aNUM aHEXNUM
188
%token <dbl> aDOUBLE
189
%token <str> aSTRING aWSTRING aSQSTRING
190
%token <uuid> aUUID
191
%token aEOF
192
%token SHL SHR
193
%token MEMBERPTR
194 195 196
%token EQUALITY INEQUALITY
%token GREATEREQUAL LESSEQUAL
%token LOGICALOR LOGICALAND
197
%token ELLIPSIS
198
%token tAGGREGATABLE tALLOCATE tANNOTATION tAPPOBJECT tASYNC tASYNCUUID
199 200 201 202 203
%token tAUTOHANDLE tBINDABLE tBOOLEAN tBROADCAST tBYTE tBYTECOUNT
%token tCALLAS tCALLBACK tCASE tCDECL tCHAR tCOCLASS tCODE tCOMMSTATUS
%token tCONST tCONTEXTHANDLE tCONTEXTHANDLENOSERIALIZE
%token tCONTEXTHANDLESERIALIZE tCONTROL tCPPQUOTE
%token tDEFAULT
204
%token tDEFAULTCOLLELEM
205
%token tDEFAULTVALUE
206
%token tDEFAULTVTABLE
207
%token tDISPLAYBIND
208 209
%token tDISPINTERFACE
%token tDLLNAME tDOUBLE tDUAL
210
%token tENDPOINT
211
%token tENTRY tENUM tERRORSTATUST
212
%token tEXPLICITHANDLE tEXTERN
213
%token tFALSE
214
%token tFASTCALL
215
%token tFLOAT
216
%token tHANDLE
217
%token tHANDLET
218 219
%token tHELPCONTEXT tHELPFILE
%token tHELPSTRING tHELPSTRINGCONTEXT tHELPSTRINGDLL
220
%token tHIDDEN
221
%token tHYPER tID tIDEMPOTENT
222
%token tIIDIS
223
%token tIMMEDIATEBIND
224
%token tIMPLICITHANDLE
225
%token tIMPORT tIMPORTLIB
226
%token tIN tIN_LINE tINLINE
227
%token tINPUTSYNC
228
%token tINT tINT3264 tINT64
229
%token tINTERFACE
230
%token tLCID
231
%token tLENGTHIS tLIBRARY
232 233
%token tLOCAL
%token tLONG
234 235
%token tMETHODS
%token tMODULE
236
%token tNONBROWSABLE
Huw Davies's avatar
Huw Davies committed
237
%token tNONCREATABLE
238
%token tNONEXTENSIBLE
239
%token tNULL
240
%token tOBJECT tODL tOLEAUTOMATION
241
%token tOPTIONAL
242
%token tOUT
243
%token tPASCAL
244
%token tPOINTERDEFAULT
245
%token tPROPERTIES
246
%token tPROPGET tPROPPUT tPROPPUTREF
247
%token tPTR
248
%token tPUBLIC
249
%token tRANGE
250
%token tREADONLY tREF
251
%token tREGISTER
252
%token tREQUESTEDIT
253
%token tRESTRICTED
254
%token tRETVAL
255
%token tSAFEARRAY
256 257 258
%token tSHORT
%token tSIGNED
%token tSIZEIS tSIZEOF
259
%token tSMALL
260
%token tSOURCE
261
%token tSTATIC
262
%token tSTDCALL
263
%token tSTRICTCONTEXTHANDLE
264 265
%token tSTRING tSTRUCT
%token tSWITCH tSWITCHIS tSWITCHTYPE
266
%token tTRANSMITAS
267
%token tTRUE
268 269 270 271 272 273
%token tTYPEDEF
%token tUNION
%token tUNIQUE
%token tUNSIGNED
%token tUUID
%token tV1ENUM
274
%token tVARARG
275 276 277 278
%token tVERSION
%token tVOID
%token tWCHAR tWIREMARSHAL

279
%type <attr> attribute type_qualifier function_specifier
280
%type <attr_list> m_attributes attributes attrib_list m_type_qual_list
281
%type <str_list> str_list
282
%type <expr> m_expr expr expr_const expr_int_const array m_bitfield
283
%type <expr_list> m_exprs /* exprs expr_list */ expr_list_int_const
284
%type <ifinfo> interfacehdr
285
%type <stgclass> storage_cls_spec
286
%type <declspec> decl_spec decl_spec_no_type m_decl_spec_no_type
287
%type <type> inherit interface interfacedef interfacedec
288 289
%type <type> dispinterface dispinterfacehdr dispinterfacedef
%type <type> module modulehdr moduledef
290
%type <type> base_type int_std
291
%type <type> enumdef structdef uniondef typedecl
292
%type <type> type
293
%type <ifref> coclass_int
294
%type <ifref_list> coclass_ints
295
%type <var> arg ne_union_field union_field s_field case enum declaration
296 297
%type <var_list> m_args arg_list args
%type <var_list> fields ne_union_fields cases enums enum_list dispint_props field
298
%type <var> m_ident ident
299
%type <declarator> declarator direct_declarator init_declarator struct_declarator
300 301
%type <declarator> m_any_declarator any_declarator any_declarator_no_direct any_direct_declarator
%type <declarator> m_abstract_declarator abstract_declarator abstract_declarator_no_direct abstract_direct_declarator
302
%type <declarator_list> declarator_list struct_declarator_list
303
%type <func> funcdef
304
%type <type> coclass coclasshdr coclassdef
305
%type <num> pointer_type version
306
%type <str> libraryhdr callconv cppquote importlib import t_ident
307
%type <uuid> uuid_string
308
%type <import> import_start
309
%type <typelib> library_start librarydef
310
%type <statement> statement typedef
311
%type <stmt_list> gbl_statements imp_statements int_statements dispint_meths
312 313

%left ','
314
%right '?' ':'
315 316
%left LOGICALOR
%left LOGICALAND
317
%left '|'
318
%left '^'
319
%left '&'
320 321
%left EQUALITY INEQUALITY
%left '<' '>' LESSEQUAL GREATEREQUAL
322
%left SHL SHR
323
%left '-' '+'
324
%left '*' '/' '%'
325
%right '!' '~' CAST PPTR POS NEG ADDRESSOF tSIZEOF
326
%left '.' MEMBERPTR '[' ']'
327 328 329

%%

330
input:   gbl_statements				{ fix_incomplete();
331
						  check_statements($1, FALSE);
332
						  check_all_user_types($1);
333
						  write_header($1);
334
						  write_id_data($1);
335 336 337
						  write_proxies($1);
						  write_client($1);
						  write_server($1);
338
						  write_dlldata($1);
339
						  write_local_stubs($1);
340
						}
341 342
	;

343
gbl_statements:					{ $$ = NULL; }
344
	| gbl_statements interfacedec		{ $$ = append_statement($1, make_statement_reference($2)); }
345
	| gbl_statements interfacedef		{ $$ = append_statement($1, make_statement_type_decl($2)); }
346 347 348
	| gbl_statements coclass ';'		{ $$ = $1;
						  reg_type($2, $2->name, 0);
						}
349
	| gbl_statements coclassdef		{ $$ = append_statement($1, make_statement_type_decl($2));
350 351
						  reg_type($2, $2->name, 0);
						}
352
	| gbl_statements moduledef		{ $$ = append_statement($1, make_statement_module($2)); }
353 354
	| gbl_statements librarydef		{ $$ = append_statement($1, make_statement_library($2)); }
	| gbl_statements statement		{ $$ = append_statement($1, $2); }
355 356
	;

357
imp_statements:					{ $$ = NULL; }
358 359
	| imp_statements interfacedec		{ $$ = append_statement($1, make_statement_reference($2)); }
	| imp_statements interfacedef		{ $$ = append_statement($1, make_statement_type_decl($2)); }
360
	| imp_statements coclass ';'		{ $$ = $1; reg_type($2, $2->name, 0); }
361
	| imp_statements coclassdef		{ $$ = append_statement($1, make_statement_type_decl($2));
362 363
						  reg_type($2, $2->name, 0);
						}
364
	| imp_statements moduledef		{ $$ = append_statement($1, make_statement_module($2)); }
365 366 367
	| imp_statements statement		{ $$ = append_statement($1, $2); }
	| imp_statements importlib		{ $$ = append_statement($1, make_statement_importlib($2)); }
	| imp_statements librarydef		{ $$ = append_statement($1, make_statement_library($2)); }
368 369 370
	;

int_statements:					{ $$ = NULL; }
371
	| int_statements statement		{ $$ = append_statement($1, $2); }
372 373
	;

374 375 376 377
semicolon_opt:
	| ';'
	;

378 379
statement:
	  cppquote				{ $$ = make_statement_cppquote($1); }
380 381
	| typedecl ';'				{ $$ = make_statement_type_decl($1); }
	| declaration ';'			{ $$ = make_statement_declaration($1); }
382
	| import				{ $$ = make_statement_import($1); }
383
	| typedef ';'				{ $$ = $1; }
384 385 386 387 388 389
	;

typedecl:
	  enumdef
	| structdef
	| uniondef
390 391 392
	| attributes enumdef                    { $$ = $2; $$->attrs = check_enum_attrs($1); }
	| attributes structdef                  { $$ = $2; $$->attrs = check_struct_attrs($1); }
	| attributes uniondef                   { $$ = $2; $$->attrs = check_union_attrs($1); }
393 394
	;

395
cppquote: tCPPQUOTE '(' aSTRING ')'		{ $$ = $3; }
396
	;
397
import_start: tIMPORT aSTRING ';'		{ assert(yychar == YYEMPTY);
398 399 400 401
						  $$ = xmalloc(sizeof(struct _import_t));
						  $$->name = $2;
						  $$->import_performed = do_import($2);
						  if (!$$->import_performed) yychar = aEOF;
402
						}
403
	;
404

405 406 407 408
import: import_start imp_statements aEOF	{ $$ = $1->name;
						  if ($1->import_performed) pop_import();
						  free($1);
						}
409 410
	;

411
importlib: tIMPORTLIB '(' aSTRING ')'
412
	   semicolon_opt			{ $$ = $3; if(!parse_only) add_importlib($3); }
Jacek Caban's avatar
Jacek Caban committed
413
	;
414

415 416
libraryhdr: tLIBRARY aIDENTIFIER		{ $$ = $2; }
	;
417 418
library_start: attributes libraryhdr '{'	{ $$ = make_library($2, check_library_attrs($2, $1));
						  if (!parse_only) start_typelib($$);
419
						}
420
	;
421
librarydef: library_start imp_statements '}'
422 423 424 425
	    semicolon_opt			{ $$ = $1;
						  $$->stmts = $2;
						  if (!parse_only) end_typelib();
						}
426
	;
427 428 429 430 431

m_args:						{ $$ = NULL; }
	| args
	;

432 433 434 435 436 437
arg_list: arg					{ check_arg_attrs($1); $$ = append_var( NULL, $1 ); }
	| arg_list ',' arg			{ check_arg_attrs($3); $$ = append_var( $1, $3 ); }
	;

args:	  arg_list
	| arg_list ',' ELLIPSIS			{ $$ = append_var( $1, make_var(strdup("...")) ); }
438 439 440
	;

/* split into two rules to get bison to resolve a tVOID conflict */
441
arg:	  attributes decl_spec m_any_declarator	{ if ($2->stgclass != STG_NONE && $2->stgclass != STG_REGISTER)
442
						    error_loc("invalid storage class for function parameter\n");
443
						  $$ = declare_var($1, $2, $3, TRUE);
444
						  free($2); free($3);
445
						}
446
	| decl_spec m_any_declarator		{ if ($1->stgclass != STG_NONE && $1->stgclass != STG_REGISTER)
447
						    error_loc("invalid storage class for function parameter\n");
448
						  $$ = declare_var(NULL, $1, $2, TRUE);
449
						  free($1); free($2);
450 451 452
						}
	;

453 454
array:	  '[' m_expr ']'			{ $$ = $2; }
	| '[' '*' ']'				{ $$ = make_expr(EXPR_VOID); }
455 456
	;

457 458 459 460 461
m_attributes:					{ $$ = NULL; }
	| attributes
	;

attributes:
462
	  '[' attrib_list ']'			{ $$ = $2; }
463 464
	;

465 466 467
attrib_list: attribute                          { $$ = append_attr( NULL, $1 ); }
	| attrib_list ',' attribute             { $$ = append_attr( $1, $3 ); }
	| attrib_list ']' '[' attribute         { $$ = append_attr( $1, $4 ); }
468 469
	;

470 471 472 473
str_list: aSTRING                               { $$ = append_str( NULL, $1 ); }
	| str_list ',' aSTRING                  { $$ = append_str( $1, $3 ); }
	;

474 475
attribute:					{ $$ = NULL; }
	| tAGGREGATABLE				{ $$ = make_attr(ATTR_AGGREGATABLE); }
476
	| tANNOTATION '(' aSTRING ')'		{ $$ = make_attrp(ATTR_ANNOTATION, $3); }
477 478
	| tAPPOBJECT				{ $$ = make_attr(ATTR_APPOBJECT); }
	| tASYNC				{ $$ = make_attr(ATTR_ASYNC); }
479
	| tAUTOHANDLE				{ $$ = make_attr(ATTR_AUTO_HANDLE); }
480
	| tBINDABLE				{ $$ = make_attr(ATTR_BINDABLE); }
481
	| tBROADCAST				{ $$ = make_attr(ATTR_BROADCAST); }
482
	| tCALLAS '(' ident ')'			{ $$ = make_attrp(ATTR_CALLAS, $3); }
483
	| tCASE '(' expr_list_int_const ')'	{ $$ = make_attrp(ATTR_CASE, $3); }
484 485 486
	| tCONTEXTHANDLE			{ $$ = make_attrv(ATTR_CONTEXTHANDLE, 0); }
	| tCONTEXTHANDLENOSERIALIZE		{ $$ = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_DONT_SERIALIZE */ }
	| tCONTEXTHANDLESERIALIZE		{ $$ = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_SERIALIZE */ }
487
	| tCONTROL				{ $$ = make_attr(ATTR_CONTROL); }
488
	| tDEFAULT				{ $$ = make_attr(ATTR_DEFAULT); }
489
	| tDEFAULTCOLLELEM			{ $$ = make_attr(ATTR_DEFAULTCOLLELEM); }
490
	| tDEFAULTVALUE '(' expr_const ')'	{ $$ = make_attrp(ATTR_DEFAULTVALUE, $3); }
491
	| tDEFAULTVTABLE			{ $$ = make_attr(ATTR_DEFAULTVTABLE); }
492
	| tDISPLAYBIND				{ $$ = make_attr(ATTR_DISPLAYBIND); }
493 494
	| tDLLNAME '(' aSTRING ')'		{ $$ = make_attrp(ATTR_DLLNAME, $3); }
	| tDUAL					{ $$ = make_attr(ATTR_DUAL); }
495
	| tENDPOINT '(' str_list ')'		{ $$ = make_attrp(ATTR_ENDPOINT, $3); }
496
	| tENTRY '(' expr_const ')'		{ $$ = make_attrp(ATTR_ENTRY, $3); }
497
	| tEXPLICITHANDLE			{ $$ = make_attr(ATTR_EXPLICIT_HANDLE); }
498
	| tHANDLE				{ $$ = make_attr(ATTR_HANDLE); }
499
	| tHELPCONTEXT '(' expr_int_const ')'	{ $$ = make_attrp(ATTR_HELPCONTEXT, $3); }
500
	| tHELPFILE '(' aSTRING ')'		{ $$ = make_attrp(ATTR_HELPFILE, $3); }
501
	| tHELPSTRING '(' aSTRING ')'		{ $$ = make_attrp(ATTR_HELPSTRING, $3); }
502
	| tHELPSTRINGCONTEXT '(' expr_int_const ')'	{ $$ = make_attrp(ATTR_HELPSTRINGCONTEXT, $3); }
503
	| tHELPSTRINGDLL '(' aSTRING ')'	{ $$ = make_attrp(ATTR_HELPSTRINGDLL, $3); }
504
	| tHIDDEN				{ $$ = make_attr(ATTR_HIDDEN); }
505
	| tID '(' expr_int_const ')'		{ $$ = make_attrp(ATTR_ID, $3); }
506
	| tIDEMPOTENT				{ $$ = make_attr(ATTR_IDEMPOTENT); }
507
	| tIIDIS '(' expr ')'			{ $$ = make_attrp(ATTR_IIDIS, $3); }
508
	| tIMMEDIATEBIND			{ $$ = make_attr(ATTR_IMMEDIATEBIND); }
509
	| tIMPLICITHANDLE '(' tHANDLET aIDENTIFIER ')'	{ $$ = make_attrp(ATTR_IMPLICIT_HANDLE, $4); }
510
	| tIN					{ $$ = make_attr(ATTR_IN); }
511
	| tINPUTSYNC				{ $$ = make_attr(ATTR_INPUTSYNC); }
512
	| tLENGTHIS '(' m_exprs ')'		{ $$ = make_attrp(ATTR_LENGTHIS, $3); }
513
	| tLCID	'(' expr_int_const ')'		{ $$ = make_attrp(ATTR_LIBLCID, $3); }
514
	| tLCID					{ $$ = make_attr(ATTR_PARAMLCID); }
515
	| tLOCAL				{ $$ = make_attr(ATTR_LOCAL); }
516
	| tNONBROWSABLE				{ $$ = make_attr(ATTR_NONBROWSABLE); }
Huw Davies's avatar
Huw Davies committed
517
	| tNONCREATABLE				{ $$ = make_attr(ATTR_NONCREATABLE); }
518
	| tNONEXTENSIBLE			{ $$ = make_attr(ATTR_NONEXTENSIBLE); }
519
	| tOBJECT				{ $$ = make_attr(ATTR_OBJECT); }
520
	| tODL					{ $$ = make_attr(ATTR_ODL); }
521
	| tOLEAUTOMATION			{ $$ = make_attr(ATTR_OLEAUTOMATION); }
522
	| tOPTIONAL                             { $$ = make_attr(ATTR_OPTIONAL); }
523 524
	| tOUT					{ $$ = make_attr(ATTR_OUT); }
	| tPOINTERDEFAULT '(' pointer_type ')'	{ $$ = make_attrv(ATTR_POINTERDEFAULT, $3); }
525 526
	| tPROPGET				{ $$ = make_attr(ATTR_PROPGET); }
	| tPROPPUT				{ $$ = make_attr(ATTR_PROPPUT); }
527
	| tPROPPUTREF				{ $$ = make_attr(ATTR_PROPPUTREF); }
528
	| tPUBLIC				{ $$ = make_attr(ATTR_PUBLIC); }
529 530 531 532
	| tRANGE '(' expr_int_const ',' expr_int_const ')'
						{ expr_list_t *list = append_expr( NULL, $3 );
						  list = append_expr( list, $5 );
						  $$ = make_attrp(ATTR_RANGE, list); }
533
	| tREADONLY				{ $$ = make_attr(ATTR_READONLY); }
534
	| tREQUESTEDIT				{ $$ = make_attr(ATTR_REQUESTEDIT); }
535
	| tRESTRICTED				{ $$ = make_attr(ATTR_RESTRICTED); }
536
	| tRETVAL				{ $$ = make_attr(ATTR_RETVAL); }
537
	| tSIZEIS '(' m_exprs ')'		{ $$ = make_attrp(ATTR_SIZEIS, $3); }
538
	| tSOURCE				{ $$ = make_attr(ATTR_SOURCE); }
539
	| tSTRICTCONTEXTHANDLE                  { $$ = make_attr(ATTR_STRICTCONTEXTHANDLE); }
540
	| tSTRING				{ $$ = make_attr(ATTR_STRING); }
541
	| tSWITCHIS '(' expr ')'		{ $$ = make_attrp(ATTR_SWITCHIS, $3); }
542 543
	| tSWITCHTYPE '(' type ')'		{ $$ = make_attrp(ATTR_SWITCHTYPE, $3); }
	| tTRANSMITAS '(' type ')'		{ $$ = make_attrp(ATTR_TRANSMITAS, $3); }
544
	| tUUID '(' uuid_string ')'		{ $$ = make_attrp(ATTR_UUID, $3); }
545
	| tV1ENUM				{ $$ = make_attr(ATTR_V1ENUM); }
546
	| tVARARG				{ $$ = make_attr(ATTR_VARARG); }
547
	| tVERSION '(' version ')'		{ $$ = make_attrv(ATTR_VERSION, $3); }
548
	| tWIREMARSHAL '(' type ')'		{ $$ = make_attrp(ATTR_WIREMARSHAL, $3); }
549
	| pointer_type				{ $$ = make_attrv(ATTR_POINTERTYPE, $1); }
550 551
	;

552 553 554
uuid_string:
	  aUUID
	| aSTRING				{ if (!is_valid_uuid($1))
555
						    error_loc("invalid UUID: %s\n", $1);
556
						  $$ = parse_uuid($1); }
557
        ;
558

559
callconv: tCDECL				{ $$ = $<str>1; }
560 561
	| tFASTCALL				{ $$ = $<str>1; }
	| tPASCAL				{ $$ = $<str>1; }
562
	| tSTDCALL				{ $$ = $<str>1; }
563 564
	;

565
cases:						{ $$ = NULL; }
566
	| cases case				{ $$ = append_var( $1, $2 ); }
567 568
	;

569
case:	  tCASE expr_int_const ':' union_field	{ attr_t *a = make_attrp(ATTR_CASE, append_expr( NULL, $2 ));
570
						  $$ = $4; if (!$$) $$ = make_var(NULL);
571
						  $$->attrs = append_attr( $$->attrs, a );
572
						}
573
	| tDEFAULT ':' union_field		{ attr_t *a = make_attr(ATTR_DEFAULT);
574
						  $$ = $3; if (!$$) $$ = make_var(NULL);
575
						  $$->attrs = append_attr( $$->attrs, a );
576
						}
577 578
	;

579 580
enums:						{ $$ = NULL; }
	| enum_list ','				{ $$ = $1; }
581 582 583
	| enum_list
	;

584 585 586
enum_list: enum					{ if (!$1->eval)
						    $1->eval = make_exprl(EXPR_NUM, 0 /* default for first enum entry */);
                                                  $$ = append_var( NULL, $1 );
587
						}
588 589 590 591 592 593
	| enum_list ',' enum			{ if (!$3->eval)
                                                  {
                                                    var_t *last = LIST_ENTRY( list_tail($$), var_t, entry );
                                                    $3->eval = make_exprl(EXPR_NUM, last->eval->cval + 1);
                                                  }
                                                  $$ = append_var( $1, $3 );
594
						}
595 596
	;

597
enum:	  ident '=' expr_int_const		{ $$ = reg_const($1);
598
						  $$->eval = $3;
599
                                                  $$->type = type_new_int(TYPE_BASIC_INT, 0);
600 601
						}
	| ident					{ $$ = reg_const($1);
602
                                                  $$->type = type_new_int(TYPE_BASIC_INT, 0);
603
						}
604 605
	;

606
enumdef: tENUM t_ident '{' enums '}'		{ $$ = type_new_enum($2, TRUE, $4); }
607 608
	;

609 610
m_exprs:  m_expr                                { $$ = append_expr( NULL, $1 ); }
	| m_exprs ',' m_expr                    { $$ = append_expr( $1, $3 ); }
611 612 613
	;

/*
614 615
exprs:						{ $$ = make_expr(EXPR_VOID); }
	| expr_list
616 617
	;

618 619
expr_list: expr
	| expr_list ',' expr			{ LINK($3, $1); $$ = $3; }
620
	;
621 622 623 624 625
*/

m_expr:						{ $$ = make_expr(EXPR_VOID); }
	| expr
	;
626

627 628
expr:	  aNUM					{ $$ = make_exprl(EXPR_NUM, $1); }
	| aHEXNUM				{ $$ = make_exprl(EXPR_HEXNUM, $1); }
629
	| aDOUBLE				{ $$ = make_exprd(EXPR_DOUBLE, $1); }
630
	| tFALSE				{ $$ = make_exprl(EXPR_TRUEFALSE, 0); }
631
	| tNULL					{ $$ = make_exprl(EXPR_NUM, 0); }
632
	| tTRUE					{ $$ = make_exprl(EXPR_TRUEFALSE, 1); }
633 634
	| aSTRING				{ $$ = make_exprs(EXPR_STRLIT, $1); }
	| aWSTRING				{ $$ = make_exprs(EXPR_WSTRLIT, $1); }
635
	| aSQSTRING				{ $$ = make_exprs(EXPR_CHARCONST, $1); }
636
	| aIDENTIFIER				{ $$ = make_exprs(EXPR_IDENTIFIER, $1); }
637
	| expr '?' expr ':' expr		{ $$ = make_expr3(EXPR_COND, $1, $3, $5); }
638 639
	| expr LOGICALOR expr			{ $$ = make_expr2(EXPR_LOGOR, $1, $3); }
	| expr LOGICALAND expr			{ $$ = make_expr2(EXPR_LOGAND, $1, $3); }
640
	| expr '|' expr				{ $$ = make_expr2(EXPR_OR , $1, $3); }
641
	| expr '^' expr				{ $$ = make_expr2(EXPR_XOR, $1, $3); }
642
	| expr '&' expr				{ $$ = make_expr2(EXPR_AND, $1, $3); }
643 644 645 646 647 648 649 650
	| expr EQUALITY expr			{ $$ = make_expr2(EXPR_EQUALITY, $1, $3); }
	| expr INEQUALITY expr			{ $$ = make_expr2(EXPR_INEQUALITY, $1, $3); }
	| expr '>' expr				{ $$ = make_expr2(EXPR_GTR, $1, $3); }
	| expr '<' expr				{ $$ = make_expr2(EXPR_LESS, $1, $3); }
	| expr GREATEREQUAL expr		{ $$ = make_expr2(EXPR_GTREQL, $1, $3); }
	| expr LESSEQUAL expr			{ $$ = make_expr2(EXPR_LESSEQL, $1, $3); }
	| expr SHL expr				{ $$ = make_expr2(EXPR_SHL, $1, $3); }
	| expr SHR expr				{ $$ = make_expr2(EXPR_SHR, $1, $3); }
651 652
	| expr '+' expr				{ $$ = make_expr2(EXPR_ADD, $1, $3); }
	| expr '-' expr				{ $$ = make_expr2(EXPR_SUB, $1, $3); }
653
	| expr '%' expr				{ $$ = make_expr2(EXPR_MOD, $1, $3); }
654 655
	| expr '*' expr				{ $$ = make_expr2(EXPR_MUL, $1, $3); }
	| expr '/' expr				{ $$ = make_expr2(EXPR_DIV, $1, $3); }
656
	| '!' expr				{ $$ = make_expr1(EXPR_LOGNOT, $2); }
657
	| '~' expr				{ $$ = make_expr1(EXPR_NOT, $2); }
658
	| '+' expr %prec POS			{ $$ = make_expr1(EXPR_POS, $2); }
659
	| '-' expr %prec NEG			{ $$ = make_expr1(EXPR_NEG, $2); }
660
	| '&' expr %prec ADDRESSOF		{ $$ = make_expr1(EXPR_ADDRESSOF, $2); }
661
	| '*' expr %prec PPTR			{ $$ = make_expr1(EXPR_PPTR, $2); }
662 663
	| expr MEMBERPTR aIDENTIFIER		{ $$ = make_expr2(EXPR_MEMBER, make_expr1(EXPR_PPTR, $1), make_exprs(EXPR_IDENTIFIER, $3)); }
	| expr '.' aIDENTIFIER			{ $$ = make_expr2(EXPR_MEMBER, $1, make_exprs(EXPR_IDENTIFIER, $3)); }
664 665 666 667
	| '(' decl_spec m_abstract_declarator ')' expr %prec CAST
						{ $$ = make_exprt(EXPR_CAST, declare_var(NULL, $2, $3, 0), $5); free($2); free($3); }
	| tSIZEOF '(' decl_spec m_abstract_declarator ')'
						{ $$ = make_exprt(EXPR_SIZEOF, declare_var(NULL, $3, $4, 0), NULL); free($3); free($4); }
668
	| expr '[' expr ']'			{ $$ = make_expr2(EXPR_ARRAY, $1, $3); }
669 670 671
	| '(' expr ')'				{ $$ = $2; }
	;

672 673
expr_list_int_const: expr_int_const		{ $$ = append_expr( NULL, $1 ); }
	| expr_list_int_const ',' expr_int_const	{ $$ = append_expr( $1, $3 ); }
674 675
	;

676
expr_int_const: expr				{ $$ = $1;
677
						  if (!$$->is_const)
678 679 680 681 682 683
						      error_loc("expression is not an integer constant\n");
						}
	;

expr_const: expr				{ $$ = $1;
						  if (!$$->is_const && $$->type != EXPR_STRLIT && $$->type != EXPR_WSTRLIT)
684
						      error_loc("expression is not constant\n");
685 686 687
						}
	;

688
fields:						{ $$ = NULL; }
689
	| fields field				{ $$ = append_var_list($1, $2); }
690 691
	;

692
field:	  m_attributes decl_spec struct_declarator_list ';'
693
						{ const char *first = LIST_ENTRY(list_head($3), declarator_t, entry)->var->name;
694
						  check_field_attrs(first, $1);
695 696
						  $$ = set_var_types($1, $2, $3);
						}
697 698 699 700
	| m_attributes uniondef ';'		{ var_t *v = make_var(NULL);
						  v->type = $2; v->attrs = $1;
						  $$ = append_var(NULL, v);
						}
701 702 703 704
	;

ne_union_field:
	  s_field ';'				{ $$ = $1; }
705
	| attributes ';'			{ $$ = make_var(NULL); $$->attrs = $1; }
706
        ;
707 708 709

ne_union_fields:				{ $$ = NULL; }
	| ne_union_fields ne_union_field	{ $$ = append_var( $1, $2 ); }
710 711
	;

712 713 714
union_field:
	  s_field ';'				{ $$ = $1; }
	| ';'					{ $$ = NULL; }
715
        ;
716

717 718
s_field:  m_attributes decl_spec declarator	{ $$ = declare_var(check_field_attrs($3->var->name, $1),
						                $2, $3, FALSE);
719 720
						  free($3);
						}
721 722
	;

723
funcdef:
724 725 726
	  m_attributes decl_spec declarator	{ var_t *v;
						  v = declare_var(check_function_attrs($3->var->name, $1),
						               $2, $3, FALSE);
727
						  free($3);
728
						  $$ = make_func(v);
729 730 731
						}
	;

732 733
declaration:
	  attributes decl_spec init_declarator
734
						{ $$ = declare_var($1, $2, $3, FALSE);
735 736
						  free($3);
						}
737
	| decl_spec init_declarator		{ $$ = declare_var(NULL, $1, $2, FALSE);
738 739 740 741
						  free($2);
						}
	;

742 743 744 745 746
m_ident:					{ $$ = NULL; }
	| ident
	;

t_ident:					{ $$ = NULL; }
747 748
	| aIDENTIFIER				{ $$ = $1; }
	| aKNOWNTYPE				{ $$ = $1; }
749 750 751
	;

ident:	  aIDENTIFIER				{ $$ = make_var($1); }
752
/* some "reserved words" used in attributes are also used as field names in some MS IDL files */
753
	| aKNOWNTYPE				{ $$ = make_var($<str>1); }
754 755
	;

756 757
base_type: tBYTE				{ $$ = find_type_or_error($<str>1, 0); }
	| tWCHAR				{ $$ = find_type_or_error($<str>1, 0); }
758
	| int_std
759 760 761 762 763 764 765 766
	| tSIGNED int_std			{ $$ = type_new_int(type_basic_get_type($2), -1); }
	| tUNSIGNED int_std			{ $$ = type_new_int(type_basic_get_type($2), 1); }
	| tUNSIGNED				{ $$ = type_new_int(TYPE_BASIC_INT, 1); }
	| tFLOAT				{ $$ = find_type_or_error($<str>1, 0); }
	| tDOUBLE				{ $$ = find_type_or_error($<str>1, 0); }
	| tBOOLEAN				{ $$ = find_type_or_error($<str>1, 0); }
	| tERRORSTATUST				{ $$ = find_type_or_error($<str>1, 0); }
	| tHANDLET				{ $$ = find_type_or_error($<str>1, 0); }
767 768 769 770 771 772
	;

m_int:
	| tINT
	;

773 774 775 776 777 778 779
int_std:  tINT					{ $$ = type_new_int(TYPE_BASIC_INT, 0); }
	| tSHORT m_int				{ $$ = type_new_int(TYPE_BASIC_INT16, 0); }
	| tSMALL				{ $$ = type_new_int(TYPE_BASIC_INT8, 0); }
	| tLONG m_int				{ $$ = type_new_int(TYPE_BASIC_INT32, 0); }
	| tHYPER m_int				{ $$ = type_new_int(TYPE_BASIC_HYPER, 0); }
	| tINT64				{ $$ = type_new_int(TYPE_BASIC_INT64, 0); }
	| tCHAR					{ $$ = type_new_int(TYPE_BASIC_CHAR, 0); }
780
	| tINT3264				{ $$ = type_new_int(TYPE_BASIC_INT3264, 0); }
781 782
	;

783
coclass:  tCOCLASS aIDENTIFIER			{ $$ = type_new_coclass($2); }
784
	| tCOCLASS aKNOWNTYPE			{ $$ = find_type($2, 0);
785
						  if (type_get_type_detect_alias($$) != TYPE_COCLASS)
786 787 788
						    error_loc("%s was not declared a coclass at %s:%d\n",
							      $2, $$->loc_info.input_name,
							      $$->loc_info.line_number);
789
						}
790 791 792
	;

coclasshdr: attributes coclass			{ $$ = $2;
793
						  check_def($$);
794
						  $$->attrs = check_coclass_attrs($2->name, $1);
795 796 797
						}
	;

798
coclassdef: coclasshdr '{' coclass_ints '}' semicolon_opt
799
						{ $$ = type_coclass_define($1, $3); }
800 801 802
	;

coclass_ints:					{ $$ = NULL; }
803
	| coclass_ints coclass_int		{ $$ = append_ifref( $1, $2 ); }
804 805 806 807 808 809
	;

coclass_int:
	  m_attributes interfacedec		{ $$ = make_ifref($2); $$->attrs = $1; }
	;

810 811
dispinterface: tDISPINTERFACE aIDENTIFIER	{ $$ = get_type(TYPE_INTERFACE, $2, 0); }
	|      tDISPINTERFACE aKNOWNTYPE	{ $$ = get_type(TYPE_INTERFACE, $2, 0); }
812 813
	;

814
dispinterfacehdr: attributes dispinterface	{ attr_t *attrs;
815
						  is_object_interface = TRUE;
816
						  $$ = $2;
817
						  check_def($$);
818
						  attrs = make_attr(ATTR_DISPINTERFACE);
819
						  $$->attrs = append_attr( check_dispiface_attrs($2->name, $1), attrs );
820 821 822 823 824
						  $$->defined = TRUE;
						}
	;

dispint_props: tPROPERTIES ':'			{ $$ = NULL; }
825
	| dispint_props s_field ';'		{ $$ = append_var( $1, $2 ); }
826 827 828
	;

dispint_meths: tMETHODS ':'			{ $$ = NULL; }
829
	| dispint_meths funcdef ';'		{ $$ = append_func( $1, $2 ); }
830 831 832 833 834 835
	;

dispinterfacedef: dispinterfacehdr '{'
	  dispint_props
	  dispint_meths
	  '}'					{ $$ = $1;
836
						  type_dispinterface_define($$, $3, $4);
837
						}
838
	| dispinterfacehdr
839
	 '{' interface ';' '}' 			{ $$ = $1;
840
						  type_dispinterface_define_from_iface($$, $3);
841 842 843
						}
	;

844
inherit:					{ $$ = NULL; }
845
	| ':' aKNOWNTYPE			{ $$ = find_type_or_error2($2, 0); is_object_interface = 1; }
846 847
	;

848 849
interface: tINTERFACE aIDENTIFIER		{ $$ = get_type(TYPE_INTERFACE, $2, 0); }
	|  tINTERFACE aKNOWNTYPE		{ $$ = get_type(TYPE_INTERFACE, $2, 0); }
850 851
	;

852 853 854 855
interfacehdr: attributes interface		{ $$.interface = $2;
						  $$.old_pointer_default = pointer_default;
						  if (is_attr($1, ATTR_POINTERDEFAULT))
						    pointer_default = get_attrv($1, ATTR_POINTERDEFAULT);
856
						  check_def($2);
857
						  $2->attrs = check_iface_attrs($2->name, $1);
858
						  is_object_interface = is_object($2);
859
						  $2->defined = TRUE;
860 861 862 863
						}
	;

interfacedef: interfacehdr inherit
864
	  '{' int_statements '}' semicolon_opt	{ $$ = $1.interface;
865
						  type_interface_define($$, $2, $4);
866
						  pointer_default = $1.old_pointer_default;
867 868 869 870
						}
/* MIDL is able to import the definition of a base class from inside the
 * definition of a derived class, I'll try to support it with this rule */
	| interfacehdr ':' aIDENTIFIER
871 872
	  '{' import int_statements '}'
	   semicolon_opt			{ $$ = $1.interface;
873
						  type_interface_define($$, find_type_or_error2($3, 0), $6);
874
						  pointer_default = $1.old_pointer_default;
875
						}
876
	| dispinterfacedef semicolon_opt	{ $$ = $1; }
877 878 879
	;

interfacedec:
880 881
	  interface ';'				{ $$ = $1; }
	| dispinterface ';'			{ $$ = $1; }
882 883
	;

884 885
module:   tMODULE aIDENTIFIER			{ $$ = type_new_module($2); }
	| tMODULE aKNOWNTYPE			{ $$ = type_new_module($2); }
886 887 888
	;

modulehdr: attributes module			{ $$ = $2;
889
						  $$->attrs = check_module_attrs($2->name, $1);
890 891 892
						}
	;

893 894
moduledef: modulehdr '{' int_statements '}'
	   semicolon_opt			{ $$ = $1;
895
                                                  type_module_define($$, $3);
896
						}
897 898
	;

899 900 901 902 903 904
storage_cls_spec:
	  tEXTERN				{ $$ = STG_EXTERN; }
	| tSTATIC				{ $$ = STG_STATIC; }
	| tREGISTER				{ $$ = STG_REGISTER; }
	;

905 906 907 908
function_specifier:
	  tINLINE				{ $$ = make_attr(ATTR_INLINE); }
	;

909 910 911 912 913 914 915 916
type_qualifier:
	  tCONST				{ $$ = make_attr(ATTR_CONST); }
	;

m_type_qual_list:				{ $$ = NULL; }
	| m_type_qual_list type_qualifier	{ $$ = append_attr($1, $2); }
	;

917
decl_spec: type m_decl_spec_no_type		{ $$ = make_decl_spec($1, $2, NULL, NULL, STG_NONE); }
918
	| decl_spec_no_type type m_decl_spec_no_type
919
						{ $$ = make_decl_spec($2, $1, $3, NULL, STG_NONE); }
920 921 922 923 924 925 926
	;

m_decl_spec_no_type:				{ $$ = NULL; }
	| decl_spec_no_type
	;

decl_spec_no_type:
927 928
	  type_qualifier m_decl_spec_no_type	{ $$ = make_decl_spec(NULL, $2, NULL, $1, STG_NONE); }
	| function_specifier m_decl_spec_no_type  { $$ = make_decl_spec(NULL, $2, NULL, $1, STG_NONE); }
929
	| storage_cls_spec m_decl_spec_no_type  { $$ = make_decl_spec(NULL, $2, NULL, NULL, $1); }
930 931
	;

932
declarator:
933
	  '*' m_type_qual_list declarator %prec PPTR
934
						{ $$ = $3; $$->type = append_ptrchain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); }
935
	| callconv declarator			{ $$ = $2; $$->type->attrs = append_attr($$->type->attrs, make_attrp(ATTR_CALLCONV, $1)); }
936
	| direct_declarator
937 938
	;

939 940 941 942
direct_declarator:
	  ident					{ $$ = make_declarator($1); }
	| '(' declarator ')'			{ $$ = $2; }
	| direct_declarator array		{ $$ = $1; $$->array = append_array($$->array, $2); }
943
	| direct_declarator '(' m_args ')'	{ $$ = $1;
944
						  $$->func_type = append_ptrchain_type($$->type, type_new_function($3));
945
						  $$->type = NULL;
946
						}
947 948
	;

949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985
/* abstract declarator */
abstract_declarator:
	  '*' m_type_qual_list m_abstract_declarator %prec PPTR
						{ $$ = $3; $$->type = append_ptrchain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); }
	| callconv m_abstract_declarator	{ $$ = $2; $$->type->attrs = append_attr($$->type->attrs, make_attrp(ATTR_CALLCONV, $1)); }
	| abstract_direct_declarator
	;

/* abstract declarator without accepting direct declarator */
abstract_declarator_no_direct:
	  '*' m_type_qual_list m_any_declarator %prec PPTR
						{ $$ = $3; $$->type = append_ptrchain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); }
	| callconv m_any_declarator		{ $$ = $2; $$->type->attrs = append_attr($$->type->attrs, make_attrp(ATTR_CALLCONV, $1)); }
	;

/* abstract declarator or empty */
m_abstract_declarator: 				{ $$ = make_declarator(NULL); }
	| abstract_declarator
	;

/* abstract direct declarator */
abstract_direct_declarator:
	  '(' abstract_declarator_no_direct ')'	{ $$ = $2; }
	| abstract_direct_declarator array	{ $$ = $1; $$->array = append_array($$->array, $2); }
	| array					{ $$ = make_declarator(NULL); $$->array = append_array($$->array, $1); }
	| '(' m_args ')'
						{ $$ = make_declarator(NULL);
						  $$->func_type = append_ptrchain_type($$->type, type_new_function($2));
						  $$->type = NULL;
						}
	| abstract_direct_declarator '(' m_args ')'
						{ $$ = $1;
						  $$->func_type = append_ptrchain_type($$->type, type_new_function($3));
						  $$->type = NULL;
						}
	;

986 987 988 989 990 991 992 993
/* abstract or non-abstract declarator */
any_declarator:
	  '*' m_type_qual_list m_any_declarator %prec PPTR
						{ $$ = $3; $$->type = append_ptrchain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); }
	| callconv m_any_declarator		{ $$ = $2; $$->type->attrs = append_attr($$->type->attrs, make_attrp(ATTR_CALLCONV, $1)); }
	| any_direct_declarator
	;

994 995
/* abstract or non-abstract declarator without accepting direct declarator */
any_declarator_no_direct:
996 997 998 999 1000 1001 1002 1003 1004 1005
	  '*' m_type_qual_list m_any_declarator %prec PPTR
						{ $$ = $3; $$->type = append_ptrchain_type($$->type, type_new_pointer(pointer_default, NULL, $2)); }
	| callconv m_any_declarator		{ $$ = $2; $$->type->attrs = append_attr($$->type->attrs, make_attrp(ATTR_CALLCONV, $1)); }
	;

/* abstract or non-abstract declarator or empty */
m_any_declarator: 				{ $$ = make_declarator(NULL); }
	| any_declarator
	;

1006 1007 1008
/* abstract or non-abstract direct declarator. note: direct declarators
 * aren't accepted inside brackets to avoid ambiguity with the rule for
 * function arguments */
1009 1010
any_direct_declarator:
	  ident					{ $$ = make_declarator($1); }
1011
	| '(' any_declarator_no_direct ')'	{ $$ = $2; }
1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025
	| any_direct_declarator array		{ $$ = $1; $$->array = append_array($$->array, $2); }
	| array					{ $$ = make_declarator(NULL); $$->array = append_array($$->array, $1); }
	| '(' m_args ')'
						{ $$ = make_declarator(NULL);
						  $$->func_type = append_ptrchain_type($$->type, type_new_function($2));
						  $$->type = NULL;
						}
	| any_direct_declarator '(' m_args ')'
						{ $$ = $1;
						  $$->func_type = append_ptrchain_type($$->type, type_new_function($3));
						  $$->type = NULL;
						}
	;

1026 1027 1028
declarator_list:
	  declarator				{ $$ = append_declarator( NULL, $1 ); }
	| declarator_list ',' declarator	{ $$ = append_declarator( $1, $3 ); }
1029 1030
	;

1031 1032 1033 1034 1035 1036
m_bitfield:					{ $$ = NULL; }
	| ':' expr_const			{ $$ = $2; }
	;

struct_declarator: any_declarator m_bitfield	{ $$ = $1; $$->bits = $2;
						  if (!$$->bits && !$$->var->name)
1037
						    error_loc("unnamed fields are not allowed\n");
1038 1039 1040 1041 1042 1043 1044 1045 1046
						}
	;

struct_declarator_list:
	  struct_declarator			{ $$ = append_declarator( NULL, $1 ); }
	| struct_declarator_list ',' struct_declarator
						{ $$ = append_declarator( $1, $3 ); }
	;

1047 1048 1049 1050 1051
init_declarator:
	  declarator				{ $$ = $1; }
	| declarator '=' expr_const		{ $$ = $1; $1->var->eval = $3; }
	;

1052 1053 1054
pointer_type:
	  tREF					{ $$ = RPC_FC_RP; }
	| tUNIQUE				{ $$ = RPC_FC_UP; }
1055
	| tPTR					{ $$ = RPC_FC_FP; }
1056 1057
	;

1058
structdef: tSTRUCT t_ident '{' fields '}'	{ $$ = type_new_struct($2, TRUE, $4); }
1059 1060
	;

1061
type:	  tVOID					{ $$ = type_new_void(); }
1062
	| aKNOWNTYPE				{ $$ = find_type_or_error($1, 0); }
1063 1064
	| base_type				{ $$ = $1; }
	| enumdef				{ $$ = $1; }
1065
	| tENUM aIDENTIFIER			{ $$ = type_new_enum($2, FALSE, NULL); }
1066
	| structdef				{ $$ = $1; }
1067
	| tSTRUCT aIDENTIFIER			{ $$ = type_new_struct($2, FALSE, NULL); }
1068
	| uniondef				{ $$ = $1; }
1069
	| tUNION aIDENTIFIER			{ $$ = type_new_nonencapsulated_union($2, FALSE, NULL); }
1070
	| tSAFEARRAY '(' type ')'		{ $$ = make_safearray($3); }
1071 1072
	;

1073
typedef: tTYPEDEF m_attributes decl_spec declarator_list
1074
						{ reg_typedefs($3, $4, check_typedef_attrs($2));
1075
						  $$ = make_statement_typedef($4);
1076 1077 1078
						}
	;

1079
uniondef: tUNION t_ident '{' ne_union_fields '}'
1080
						{ $$ = type_new_nonencapsulated_union($2, TRUE, $4); }
1081
	| tUNION t_ident
1082
	  tSWITCH '(' s_field ')'
1083
	  m_ident '{' cases '}'			{ $$ = type_new_encapsulated_union($2, $5, $7, $9); }
1084 1085 1086
	;

version:
1087 1088
	  aNUM					{ $$ = MAKEVERSION($1, 0); }
	| aNUM '.' aNUM				{ $$ = MAKEVERSION($1, $3); }
1089 1090 1091 1092
	;

%%

1093
static void decl_builtin_basic(const char *name, enum type_basic_type type)
1094
{
1095
  type_t *t = type_new_basic(type);
1096 1097 1098
  reg_type(t, name, 0);
}

1099
static void decl_builtin_alias(const char *name, type_t *t)
1100
{
1101
  reg_type(type_new_alias(t, name), name, 0);
1102 1103 1104 1105
}

void init_types(void)
{
1106 1107 1108 1109 1110 1111 1112
  decl_builtin_basic("byte", TYPE_BASIC_BYTE);
  decl_builtin_basic("wchar_t", TYPE_BASIC_WCHAR);
  decl_builtin_basic("float", TYPE_BASIC_FLOAT);
  decl_builtin_basic("double", TYPE_BASIC_DOUBLE);
  decl_builtin_basic("error_status_t", TYPE_BASIC_ERROR_STATUS_T);
  decl_builtin_basic("handle_t", TYPE_BASIC_HANDLE);
  decl_builtin_alias("boolean", type_new_basic(TYPE_BASIC_BYTE));
1113 1114
}

1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130
static str_list_t *append_str(str_list_t *list, char *str)
{
    struct str_list_entry_t *entry;

    if (!str) return list;
    if (!list)
    {
        list = xmalloc( sizeof(*list) );
        list_init( list );
    }
    entry = xmalloc( sizeof(*entry) );
    entry->str = str;
    list_add_tail( list, &entry->entry );
    return list;
}

1131 1132
static attr_list_t *append_attr(attr_list_t *list, attr_t *attr)
{
1133
    attr_t *attr_existing;
1134 1135 1136 1137 1138 1139
    if (!attr) return list;
    if (!list)
    {
        list = xmalloc( sizeof(*list) );
        list_init( list );
    }
1140 1141 1142 1143 1144 1145 1146 1147
    LIST_FOR_EACH_ENTRY(attr_existing, list, attr_t, entry)
        if (attr_existing->type == attr->type)
        {
            parser_warning("duplicate attribute %s\n", get_attr_display_name(attr->type));
            /* use the last attribute, like MIDL does */
            list_remove(&attr_existing->entry);
            break;
        }
1148 1149 1150 1151
    list_add_tail( list, &attr->entry );
    return list;
}

1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164
static attr_list_t *move_attr(attr_list_t *dst, attr_list_t *src, enum attr_type type)
{
  attr_t *attr;
  if (!src) return dst;
  LIST_FOR_EACH_ENTRY(attr, src, attr_t, entry)
    if (attr->type == type)
    {
      list_remove(&attr->entry);
      return append_attr(dst, attr);
    }
  return dst;
}

1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197
static attr_list_t *append_attr_list(attr_list_t *new_list, attr_list_t *old_list)
{
  struct list *entry;

  if (!old_list) return new_list;

  while ((entry = list_head(old_list)))
  {
    attr_t *attr = LIST_ENTRY(entry, attr_t, entry);
    list_remove(entry);
    new_list = append_attr(new_list, attr);
  }
  return new_list;
}

static attr_list_t *dupattrs(const attr_list_t *list)
{
  attr_list_t *new_list;
  const attr_t *attr;

  if (!list) return NULL;

  new_list = xmalloc( sizeof(*list) );
  list_init( new_list );
  LIST_FOR_EACH_ENTRY(attr, list, const attr_t, entry)
  {
    attr_t *new_attr = xmalloc(sizeof(*new_attr));
    *new_attr = *attr;
    list_add_tail(new_list, &new_attr->entry);
  }
  return new_list;
}

1198
static decl_spec_t *make_decl_spec(type_t *type, decl_spec_t *left, decl_spec_t *right, attr_t *attr, enum storage_class stgclass)
1199
{
1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237
  decl_spec_t *declspec = left ? left : right;
  if (!declspec)
  {
    declspec = xmalloc(sizeof(*declspec));
    declspec->type = NULL;
    declspec->attrs = NULL;
    declspec->stgclass = STG_NONE;
  }
  declspec->type = type;
  if (left && declspec != left)
  {
    declspec->attrs = append_attr_list(declspec->attrs, left->attrs);
    if (declspec->stgclass == STG_NONE)
      declspec->stgclass = left->stgclass;
    else if (left->stgclass != STG_NONE)
      error_loc("only one storage class can be specified\n");
    assert(!left->type);
    free(left);
  }
  if (right && declspec != right)
  {
    declspec->attrs = append_attr_list(declspec->attrs, right->attrs);
    if (declspec->stgclass == STG_NONE)
      declspec->stgclass = right->stgclass;
    else if (right->stgclass != STG_NONE)
      error_loc("only one storage class can be specified\n");
    assert(!right->type);
    free(right);
  }

  declspec->attrs = append_attr(declspec->attrs, attr);
  if (declspec->stgclass == STG_NONE)
    declspec->stgclass = stgclass;
  else if (stgclass != STG_NONE)
    error_loc("only one storage class can be specified\n");

  /* apply attributes to type */
  if (type && declspec->attrs)
1238 1239
  {
    attr_list_t *attrs;
1240
    declspec->type = duptype(type, 1);
1241
    attrs = dupattrs(type->attrs);
1242 1243
    declspec->type->attrs = append_attr_list(attrs, declspec->attrs);
    declspec->attrs = NULL;
1244
  }
1245 1246

  return declspec;
1247 1248
}

1249
static attr_t *make_attr(enum attr_type type)
1250 1251 1252 1253 1254 1255 1256
{
  attr_t *a = xmalloc(sizeof(attr_t));
  a->type = type;
  a->u.ival = 0;
  return a;
}

1257
static attr_t *make_attrv(enum attr_type type, unsigned long val)
1258 1259 1260 1261 1262 1263 1264
{
  attr_t *a = xmalloc(sizeof(attr_t));
  a->type = type;
  a->u.ival = val;
  return a;
}

1265
static attr_t *make_attrp(enum attr_type type, void *val)
1266 1267 1268 1269 1270 1271 1272
{
  attr_t *a = xmalloc(sizeof(attr_t));
  a->type = type;
  a->u.pval = val;
  return a;
}

1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296
static expr_list_t *append_expr(expr_list_t *list, expr_t *expr)
{
    if (!expr) return list;
    if (!list)
    {
        list = xmalloc( sizeof(*list) );
        list_init( list );
    }
    list_add_tail( list, &expr->entry );
    return list;
}

static array_dims_t *append_array(array_dims_t *list, expr_t *expr)
{
    if (!expr) return list;
    if (!list)
    {
        list = xmalloc( sizeof(*list) );
        list_init( list );
    }
    list_add_tail( list, &expr->entry );
    return list;
}

1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317
static struct list type_pool = LIST_INIT(type_pool);
typedef struct
{
  type_t data;
  struct list link;
} type_pool_node_t;

type_t *alloc_type(void)
{
  type_pool_node_t *node = xmalloc(sizeof *node);
  list_add_tail(&type_pool, &node->link);
  return &node->data;
}

void set_all_tfswrite(int val)
{
  type_pool_node_t *node;
  LIST_FOR_EACH_ENTRY(node, &type_pool, type_pool_node_t, link)
    node->data.tfswrite = val;
}

1318 1319 1320 1321 1322 1323 1324
void clear_all_offsets(void)
{
  type_pool_node_t *node;
  LIST_FOR_EACH_ENTRY(node, &type_pool, type_pool_node_t, link)
    node->data.typestring_offset = node->data.ptrdesc = 0;
}

1325
static void type_function_add_head_arg(type_t *type, var_t *arg)
1326
{
1327
    if (!type->details.function->args)
1328
    {
1329 1330
        type->details.function->args = xmalloc( sizeof(*type->details.function->args) );
        list_init( type->details.function->args );
1331
    }
1332
    list_add_head( type->details.function->args, &arg->entry );
1333 1334
}

1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348
static int is_allowed_range_type(const type_t *type)
{
    switch (type_get_type(type))
    {
    case TYPE_ENUM:
        return TRUE;
    case TYPE_BASIC:
        switch (type_basic_get_type(type))
        {
        case TYPE_BASIC_INT8:
        case TYPE_BASIC_INT16:
        case TYPE_BASIC_INT32:
        case TYPE_BASIC_INT64:
        case TYPE_BASIC_INT:
1349
        case TYPE_BASIC_INT3264:
1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366
        case TYPE_BASIC_BYTE:
        case TYPE_BASIC_CHAR:
        case TYPE_BASIC_WCHAR:
        case TYPE_BASIC_HYPER:
            return TRUE;
        case TYPE_BASIC_FLOAT:
        case TYPE_BASIC_DOUBLE:
        case TYPE_BASIC_ERROR_STATUS_T:
        case TYPE_BASIC_HANDLE:
            return FALSE;
        }
        return FALSE;
    default:
        return FALSE;
    }
}

1367 1368 1369 1370 1371
static type_t *append_ptrchain_type(type_t *ptrchain, type_t *type)
{
  type_t *ptrchain_type;
  if (!ptrchain)
    return type;
1372
  for (ptrchain_type = ptrchain; type_pointer_get_ref(ptrchain_type); ptrchain_type = type_pointer_get_ref(ptrchain_type))
1373
    ;
1374 1375
  assert(ptrchain_type->type_type == TYPE_POINTER);
  ptrchain_type->details.pointer.ref = type;
1376 1377 1378
  return ptrchain;
}

1379 1380
static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const declarator_t *decl,
                       int top)
1381
{
1382 1383 1384
  var_t *v = decl->var;
  expr_list_t *sizes = get_attrp(attrs, ATTR_SIZEIS);
  expr_list_t *lengs = get_attrp(attrs, ATTR_LENGTHIS);
1385
  int sizeless;
1386
  expr_t *dim;
1387
  type_t **ptype;
1388
  array_dims_t *arr = decl ? decl->array : NULL;
1389
  type_t *func_type = decl ? decl->func_type : NULL;
1390
  type_t *type = decl_spec->type;
1391

1392 1393
  if (is_attr(type->attrs, ATTR_INLINE))
  {
1394
    if (!func_type)
1395 1396 1397 1398 1399
      error_loc("inline attribute applied to non-function type\n");
    else
    {
      type_t *t;
      /* move inline attribute from return type node to function node */
1400
      for (t = func_type; is_ptr(t); t = type_pointer_get_ref(t))
1401 1402 1403 1404 1405
        ;
      t->attrs = move_attr(t->attrs, type->attrs, ATTR_INLINE);
    }
  }

1406
  /* add type onto the end of the pointers in pident->type */
1407
  v->type = append_ptrchain_type(decl ? decl->type : NULL, type);
1408
  v->stgclass = decl_spec->stgclass;
1409
  v->attrs = attrs;
1410

1411 1412
  /* check for pointer attribute being applied to non-pointer, non-array
   * type */
1413
  if (!arr)
1414
  {
1415
    int ptr_attr = get_attrv(v->attrs, ATTR_POINTERTYPE);
1416
    const type_t *ptr = NULL;
1417 1418 1419
    /* pointer attributes on the left side of the type belong to the function
     * pointer, if one is being declared */
    type_t **pt = func_type ? &func_type : &v->type;
1420
    for (ptr = *pt; ptr && !ptr_attr; )
1421
    {
1422
      ptr_attr = get_attrv(ptr->attrs, ATTR_POINTERTYPE);
1423
      if (!ptr_attr && type_is_alias(ptr))
1424
        ptr = type_alias_get_aliasee(ptr);
1425 1426
      else
        break;
1427
    }
1428
    if (is_ptr(ptr))
1429
    {
1430 1431 1432 1433 1434
      if (ptr_attr && ptr_attr != RPC_FC_UP &&
          type_get_type(type_pointer_get_ref(ptr)) == TYPE_INTERFACE)
          warning_loc_info(&v->loc_info,
                           "%s: pointer attribute applied to interface "
                           "pointer type has no effect\n", v->name);
1435
      if (!ptr_attr && top && (*pt)->details.pointer.def_fc != RPC_FC_RP)
1436
      {
1437 1438 1439 1440
        /* FIXME: this is a horrible hack to cope with the issue that we
         * store an offset to the typeformat string in the type object, but
         * two typeformat strings may be written depending on whether the
         * pointer is a toplevel parameter or not */
1441 1442
        *pt = duptype(*pt, 1);
      }
1443
    }
1444 1445
    else if (ptr_attr)
       error_loc("%s: pointer attribute applied to non-pointer type\n", v->name);
1446 1447
  }

1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467
  if (is_attr(v->attrs, ATTR_STRING))
  {
    type_t *t = type;

    if (!is_ptr(v->type) && !arr)
      error_loc("'%s': [string] attribute applied to non-pointer, non-array type\n",
                v->name);

    while (is_ptr(t))
      t = type_pointer_get_ref(t);

    if (type_get_type(t) != TYPE_BASIC &&
        (get_basic_fc(t) != RPC_FC_CHAR &&
         get_basic_fc(t) != RPC_FC_BYTE &&
         get_basic_fc(t) != RPC_FC_WCHAR))
    {
      error_loc("'%s': [string] attribute is only valid on 'char', 'byte', or 'wchar_t' pointers and arrays\n",
                v->name);
    }
  }
1468

1469 1470
  if (is_attr(v->attrs, ATTR_V1ENUM))
  {
1471
    if (type_get_type_detect_alias(v->type) != TYPE_ENUM)
1472 1473 1474
      error_loc("'%s': [v1_enum] attribute applied to non-enum type\n", v->name);
  }

1475 1476 1477 1478
  if (is_attr(v->attrs, ATTR_RANGE) && !is_allowed_range_type(v->type))
    error_loc("'%s': [range] attribute applied to non-integer type\n",
              v->name);

1479
  ptype = &v->type;
1480 1481 1482 1483
  sizeless = FALSE;
  if (arr) LIST_FOR_EACH_ENTRY_REV(dim, arr, expr_t, entry)
  {
    if (sizeless)
1484
      error_loc("%s: only the first array dimension can be unspecified\n", v->name);
1485 1486 1487

    if (dim->is_const)
    {
1488 1489 1490 1491 1492 1493 1494
      if (dim->cval <= 0)
        error_loc("%s: array dimension must be positive\n", v->name);

      /* FIXME: should use a type_memsize that allows us to pass in a pointer size */
      if (0)
      {
        unsigned int align = 0;
1495
        unsigned int size = type_memsize(v->type, &align);
1496

1497
        if (0xffffffffu / size < dim->cval)
1498 1499
          error_loc("%s: total array size is too large\n", v->name);
      }
1500 1501 1502 1503
    }
    else
      sizeless = TRUE;

1504
    *ptype = type_new_array(NULL, *ptype, FALSE,
1505
                            dim->is_const ? dim->cval : 0,
1506 1507
                            dim->is_const ? NULL : dim, NULL,
                            pointer_default);
1508 1509 1510 1511 1512 1513 1514
  }

  ptype = &v->type;
  if (sizes) LIST_FOR_EACH_ENTRY(dim, sizes, expr_t, entry)
  {
    if (dim->type != EXPR_VOID)
    {
1515 1516 1517 1518 1519 1520
      if (is_array(*ptype))
      {
        if (type_array_get_conformance(*ptype)->is_const)
          error_loc("%s: cannot specify size_is for a fixed sized array\n", v->name);
        else
          *ptype = type_new_array((*ptype)->name,
1521
                                  type_array_get_element(*ptype), FALSE,
1522
                                  0, dim, NULL, 0);
1523 1524
      }
      else if (is_ptr(*ptype))
1525
        *ptype = type_new_array((*ptype)->name, type_pointer_get_ref(*ptype), TRUE,
1526
                                0, dim, NULL, pointer_default);
1527
      else
1528
        error_loc("%s: size_is attribute applied to illegal type\n", v->name);
1529 1530
    }

1531 1532 1533 1534 1535
    if (is_ptr(*ptype))
      ptype = &(*ptype)->details.pointer.ref;
    else if (is_array(*ptype))
      ptype = &(*ptype)->details.array.elem;
    else
1536
      error_loc("%s: too many expressions in size_is attribute\n", v->name);
1537 1538 1539 1540 1541 1542 1543
  }

  ptype = &v->type;
  if (lengs) LIST_FOR_EACH_ENTRY(dim, lengs, expr_t, entry)
  {
    if (dim->type != EXPR_VOID)
    {
1544 1545 1546 1547
      if (is_array(*ptype))
      {
        *ptype = type_new_array((*ptype)->name,
                                type_array_get_element(*ptype),
1548
                                type_array_is_decl_as_ptr(*ptype),
1549 1550
                                type_array_get_dim(*ptype),
                                type_array_get_conformance(*ptype),
1551
                                dim, type_array_get_ptr_default_fc(*ptype));
1552
      }
1553
      else
1554
        error_loc("%s: length_is attribute applied to illegal type\n", v->name);
1555 1556
    }

1557 1558 1559 1560 1561
    if (is_ptr(*ptype))
      ptype = &(*ptype)->details.pointer.ref;
    else if (is_array(*ptype))
      ptype = &(*ptype)->details.array.elem;
    else
1562
      error_loc("%s: too many expressions in length_is attribute\n", v->name);
1563 1564
  }

1565
  /* v->type is currently pointing to the type on the left-side of the
1566 1567
   * declaration, so we need to fix this up so that it is the return type of the
   * function and make v->type point to the function side of the declaration */
1568
  if (func_type)
1569
  {
1570
    type_t *ft, *t;
1571
    type_t *return_type = v->type;
1572
    v->type = func_type;
1573
    for (ft = v->type; is_ptr(ft); ft = type_pointer_get_ref(ft))
1574
      ;
1575
    assert(type_get_type_detect_alias(ft) == TYPE_FUNCTION);
1576
    ft->details.function->rettype = return_type;
1577 1578
    /* move calling convention attribute, if present, from pointer nodes to
     * function node */
1579
    for (t = v->type; is_ptr(t); t = type_pointer_get_ref(t))
1580 1581
      ft->attrs = move_attr(ft->attrs, t->attrs, ATTR_CALLCONV);
    if (is_object_interface && !is_attr(ft->attrs, ATTR_CALLCONV))
1582 1583 1584
    {
      static char *stdmethodcalltype;
      if (!stdmethodcalltype) stdmethodcalltype = strdup("STDMETHODCALLTYPE");
1585
      ft->attrs = append_attr(NULL, make_attrp(ATTR_CALLCONV, stdmethodcalltype));
1586 1587
    }
  }
1588 1589 1590
  else
  {
    type_t *t;
1591
    for (t = v->type; is_ptr(t); t = type_pointer_get_ref(t))
1592 1593 1594
      if (is_attr(t->attrs, ATTR_CALLCONV))
        error_loc("calling convention applied to non-function-pointer type\n");
  }
1595

1596 1597 1598
  if (decl->bits)
    v->type = type_new_bitfield(v->type, decl->bits);

1599
  return v;
1600 1601
}

1602
static var_list_t *set_var_types(attr_list_t *attrs, decl_spec_t *decl_spec, declarator_list_t *decls)
1603 1604 1605 1606 1607 1608
{
  declarator_t *decl, *next;
  var_list_t *var_list = NULL;

  LIST_FOR_EACH_ENTRY_SAFE( decl, next, decls, declarator_t, entry )
  {
1609
    var_t *var = declare_var(attrs, decl_spec, decl, 0);
1610 1611 1612
    var_list = append_var(var_list, var);
    free(decl);
  }
1613
  free(decl_spec);
1614 1615 1616
  return var_list;
}

1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628
static ifref_list_t *append_ifref(ifref_list_t *list, ifref_t *iface)
{
    if (!iface) return list;
    if (!list)
    {
        list = xmalloc( sizeof(*list) );
        list_init( list );
    }
    list_add_tail( list, &iface->entry );
    return list;
}

1629 1630 1631 1632 1633 1634 1635 1636
static ifref_t *make_ifref(type_t *iface)
{
  ifref_t *l = xmalloc(sizeof(ifref_t));
  l->iface = iface;
  l->attrs = NULL;
  return l;
}

1637
var_list_t *append_var(var_list_t *list, var_t *var)
1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648
{
    if (!var) return list;
    if (!list)
    {
        list = xmalloc( sizeof(*list) );
        list_init( list );
    }
    list_add_tail( list, &var->entry );
    return list;
}

1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660
static var_list_t *append_var_list(var_list_t *list, var_list_t *vars)
{
    if (!vars) return list;
    if (!list)
    {
        list = xmalloc( sizeof(*list) );
        list_init( list );
    }
    list_move_tail( list, vars );
    return list;
}

1661
var_t *make_var(char *name)
1662 1663 1664 1665 1666
{
  var_t *v = xmalloc(sizeof(var_t));
  v->name = name;
  v->type = NULL;
  v->attrs = NULL;
1667
  v->eval = NULL;
1668
  v->stgclass = STG_NONE;
1669
  init_loc_info(&v->loc_info);
1670 1671 1672
  return v;
}

1673
static declarator_list_t *append_declarator(declarator_list_t *list, declarator_t *d)
1674
{
1675
  if (!d) return list;
1676 1677 1678 1679
  if (!list) {
    list = xmalloc(sizeof(*list));
    list_init(list);
  }
1680
  list_add_tail(list, &d->entry);
1681 1682 1683
  return list;
}

1684
static declarator_t *make_declarator(var_t *var)
1685
{
1686
  declarator_t *d = xmalloc(sizeof(*d));
1687
  d->var = var ? var : make_var(NULL);
1688 1689 1690
  d->type = NULL;
  d->func_type = NULL;
  d->array = NULL;
1691
  d->bits = NULL;
1692
  return d;
1693 1694
}

1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706
static func_list_t *append_func(func_list_t *list, func_t *func)
{
    if (!func) return list;
    if (!list)
    {
        list = xmalloc( sizeof(*list) );
        list_init( list );
    }
    list_add_tail( list, &func->entry );
    return list;
}

1707
static func_t *make_func(var_t *def)
1708 1709 1710 1711 1712 1713
{
  func_t *f = xmalloc(sizeof(func_t));
  f->def = def;
  return f;
}

1714
static type_t *make_safearray(type_t *type)
1715
{
1716 1717
  return type_new_array(NULL, type_new_alias(type, "SAFEARRAY"), TRUE, 0,
                        NULL, NULL, RPC_FC_RP);
1718 1719
}

1720 1721 1722 1723 1724 1725 1726 1727 1728 1729
static typelib_t *make_library(const char *name, const attr_list_t *attrs)
{
    typelib_t *typelib = xmalloc(sizeof(*typelib));
    typelib->name = xstrdup(name);
    typelib->filename = NULL;
    typelib->attrs = attrs;
    list_init( &typelib->importlibs );
    return typelib;
}

1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745
#define HASHMAX 64

static int hash_ident(const char *name)
{
  const char *p = name;
  int sum = 0;
  /* a simple sum hash is probably good enough */
  while (*p) {
    sum += *p;
    p++;
  }
  return sum & (HASHMAX-1);
}

/***** type repository *****/

1746
struct rtype {
1747
  const char *name;
1748 1749 1750 1751 1752
  type_t *type;
  int t;
  struct rtype *next;
};

1753
struct rtype *type_hash[HASHMAX];
1754

1755
type_t *reg_type(type_t *type, const char *name, int t)
1756 1757
{
  struct rtype *nt;
1758
  int hash;
1759
  if (!name) {
1760
    error_loc("registering named type without name\n");
1761 1762
    return type;
  }
1763
  hash = hash_ident(name);
1764 1765 1766 1767
  nt = xmalloc(sizeof(struct rtype));
  nt->name = name;
  nt->type = type;
  nt->t = t;
1768 1769
  nt->next = type_hash[hash];
  type_hash[hash] = nt;
1770 1771
  if ((t == tsSTRUCT || t == tsUNION))
    fix_incomplete_types(type);
1772 1773 1774
  return type;
}

1775 1776
static int is_incomplete(const type_t *t)
{
1777 1778 1779 1780
  return !t->defined &&
    (type_get_type_detect_alias(t) == TYPE_STRUCT ||
     type_get_type_detect_alias(t) == TYPE_UNION ||
     type_get_type_detect_alias(t) == TYPE_ENCAPSULATED_UNION);
1781 1782
}

1783
void add_incomplete(type_t *t)
1784 1785 1786 1787 1788 1789 1790 1791
{
  struct typenode *tn = xmalloc(sizeof *tn);
  tn->type = t;
  list_add_tail(&incomplete_types, &tn->entry);
}

static void fix_type(type_t *t)
{
1792
  if (type_is_alias(t) && is_incomplete(t)) {
1793
    type_t *ot = type_alias_get_aliasee(t);
1794
    fix_type(ot);
1795 1796 1797
    if (type_get_type_detect_alias(ot) == TYPE_STRUCT ||
        type_get_type_detect_alias(ot) == TYPE_UNION ||
        type_get_type_detect_alias(ot) == TYPE_ENCAPSULATED_UNION)
1798
      t->details.structure = ot->details.structure;
1799 1800 1801 1802 1803 1804 1805 1806 1807 1808
    t->defined = ot->defined;
  }
}

static void fix_incomplete(void)
{
  struct typenode *tn, *next;

  LIST_FOR_EACH_ENTRY_SAFE(tn, next, &incomplete_types, struct typenode, entry) {
    fix_type(tn->type);
1809
    list_remove(&tn->entry);
1810 1811 1812 1813
    free(tn);
  }
}

1814 1815 1816 1817 1818 1819
static void fix_incomplete_types(type_t *complete_type)
{
  struct typenode *tn, *next;

  LIST_FOR_EACH_ENTRY_SAFE(tn, next, &incomplete_types, struct typenode, entry)
  {
1820
    if (type_is_equal(complete_type, tn->type))
1821 1822 1823 1824 1825 1826 1827 1828
    {
      tn->type->details.structure = complete_type->details.structure;
      list_remove(&tn->entry);
      free(tn);
    }
  }
}

1829
static type_t *reg_typedefs(decl_spec_t *decl_spec, declarator_list_t *decls, attr_list_t *attrs)
1830
{
1831
  const declarator_t *decl;
1832
  type_t *type = decl_spec->type;
1833

1834 1835
  /* We must generate names for tagless enum, struct or union.
     Typedef-ing a tagless enum, struct or union means we want the typedef
1836
     to be included in a library hence the public attribute.  */
1837 1838 1839 1840
  if ((type_get_type_detect_alias(type) == TYPE_ENUM ||
       type_get_type_detect_alias(type) == TYPE_STRUCT ||
       type_get_type_detect_alias(type) == TYPE_UNION ||
       type_get_type_detect_alias(type) == TYPE_ENCAPSULATED_UNION) &&
1841
      !type->name && !parse_only)
1842 1843
  {
    if (! is_attr(attrs, ATTR_PUBLIC))
1844
      attrs = append_attr( attrs, make_attr(ATTR_PUBLIC) );
1845 1846
    type->name = gen_name();
  }
1847 1848
  else if (is_attr(attrs, ATTR_UUID) && !is_attr(attrs, ATTR_PUBLIC))
    attrs = append_attr( attrs, make_attr(ATTR_PUBLIC) );
1849

1850
  LIST_FOR_EACH_ENTRY( decl, decls, const declarator_t, entry )
1851
  {
1852

1853
    if (decl->var->name) {
1854
      type_t *cur;
1855
      var_t *name;
1856

1857
      cur = find_type(decl->var->name, 0);
1858 1859 1860 1861 1862
      if (cur)
          error_loc("%s: redefinition error; original definition was at %s:%d\n",
                    cur->name, cur->loc_info.input_name,
                    cur->loc_info.line_number);

1863
      name = declare_var(attrs, decl_spec, decl, 0);
1864
      cur = type_new_alias(name->type, name->name);
1865
      cur->attrs = attrs;
1866

1867 1868
      if (is_incomplete(cur))
        add_incomplete(cur);
1869
      reg_type(cur, cur->name, 0);
1870 1871 1872 1873 1874
    }
  }
  return type;
}

1875
type_t *find_type(const char *name, int t)
1876
{
1877
  struct rtype *cur = type_hash[hash_ident(name)];
1878 1879
  while (cur && (cur->t != t || strcmp(cur->name, name)))
    cur = cur->next;
1880 1881 1882
  return cur ? cur->type : NULL;
}

1883
static type_t *find_type_or_error(const char *name, int t)
1884
{
1885
  type_t *type = find_type(name, t);
1886
  if (!type) {
1887
    error_loc("type '%s' not found\n", name);
1888 1889
    return NULL;
  }
1890
  return type;
1891 1892
}

1893
static type_t *find_type_or_error2(char *name, int t)
1894
{
1895
  type_t *tp = find_type_or_error(name, t);
1896 1897 1898 1899 1900 1901
  free(name);
  return tp;
}

int is_type(const char *name)
{
1902
  return find_type(name, 0) != NULL;
1903 1904
}

1905
type_t *get_type(enum type_type type, char *name, int t)
1906 1907 1908
{
  type_t *tp;
  if (name) {
1909
    tp = find_type(name, t);
1910 1911 1912 1913
    if (tp) {
      free(name);
      return tp;
    }
1914
  }
1915
  tp = make_type(type);
1916 1917 1918 1919 1920
  tp->name = name;
  if (!name) return tp;
  return reg_type(tp, name, t);
}

1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935
/***** constant repository *****/

struct rconst {
  char *name;
  var_t *var;
  struct rconst *next;
};

struct rconst *const_hash[HASHMAX];

static var_t *reg_const(var_t *var)
{
  struct rconst *nc;
  int hash;
  if (!var->name) {
1936
    error_loc("registering constant without name\n");
1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947
    return var;
  }
  hash = hash_ident(var->name);
  nc = xmalloc(sizeof(struct rconst));
  nc->name = var->name;
  nc->var = var;
  nc->next = const_hash[hash];
  const_hash[hash] = nc;
  return var;
}

1948
var_t *find_const(const char *name, int f)
1949 1950 1951 1952 1953
{
  struct rconst *cur = const_hash[hash_ident(name)];
  while (cur && strcmp(cur->name, name))
    cur = cur->next;
  if (!cur) {
1954
    if (f) error_loc("constant '%s' not found\n", name);
1955 1956 1957 1958
    return NULL;
  }
  return cur->var;
}
1959

1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983
static char *gen_name(void)
{
  static const char format[] = "__WIDL_%s_generated_name_%08lX";
  static unsigned long n = 0;
  static const char *file_id;
  static size_t size;
  char *name;

  if (! file_id)
  {
    char *dst = dup_basename(input_name, ".idl");
    file_id = dst;

    for (; *dst; ++dst)
      if (! isalnum((unsigned char) *dst))
        *dst = '_';

    size = sizeof format - 7 + strlen(file_id) + 8;
  }

  name = xmalloc(size);
  sprintf(name, format, file_id, n++);
  return name;
}
1984

1985 1986 1987 1988 1989 1990 1991 1992
struct allowed_attr
{
    unsigned int dce_compatible : 1;
    unsigned int acf : 1;
    unsigned int on_interface : 1;
    unsigned int on_function : 1;
    unsigned int on_arg : 1;
    unsigned int on_type : 1;
1993 1994 1995
    unsigned int on_enum : 1;
    unsigned int on_struct : 1;
    unsigned int on_union : 1;
1996 1997 1998 1999 2000 2001 2002 2003 2004 2005
    unsigned int on_field : 1;
    unsigned int on_library : 1;
    unsigned int on_dispinterface : 1;
    unsigned int on_module : 1;
    unsigned int on_coclass : 1;
    const char *display_name;
};

struct allowed_attr allowed_attr[] =
{
2006 2007
    /* attr                        { D ACF I Fn ARG T En St Un Fi  L  DI M  C  <display name> } */
    /* ATTR_AGGREGATABLE */        { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "aggregatable" },
2008
    /* ATTR_ANNOTATION */          { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "annotation" },
2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056
    /* ATTR_APPOBJECT */           { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "appobject" },
    /* ATTR_ASYNC */               { 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "async" },
    /* ATTR_AUTO_HANDLE */         { 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "auto_handle" },
    /* ATTR_BINDABLE */            { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "bindable" },
    /* ATTR_BROADCAST */           { 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "broadcast" },
    /* ATTR_CALLAS */              { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "call_as" },
    /* ATTR_CALLCONV */            { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL },
    /* ATTR_CASE */                { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, "case" },
    /* ATTR_CONST */               { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "const" },
    /* ATTR_CONTEXTHANDLE */       { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "context_handle" },
    /* ATTR_CONTROL */             { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, "control" },
    /* ATTR_DEFAULT */             { 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, "default" },
    /* ATTR_DEFAULTCOLLELEM */     { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "defaultcollelem" },
    /* ATTR_DEFAULTVALUE */        { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "defaultvalue" },
    /* ATTR_DEFAULTVTABLE */       { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "defaultvtable" },
    /* ATTR_DISPINTERFACE */       { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL },
    /* ATTR_DISPLAYBIND */         { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "displaybind" },
    /* ATTR_DLLNAME */             { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, "dllname" },
    /* ATTR_DUAL */                { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "dual" },
    /* ATTR_ENDPOINT */            { 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "endpoint" },
    /* ATTR_ENTRY */               { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "entry" },
    /* ATTR_EXPLICIT_HANDLE */     { 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "explicit_handle" },
    /* ATTR_HANDLE */              { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "handle" },
    /* ATTR_HELPCONTEXT */         { 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, "helpcontext" },
    /* ATTR_HELPFILE */            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, "helpfile" },
    /* ATTR_HELPSTRING */          { 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, "helpstring" },
    /* ATTR_HELPSTRINGCONTEXT */   { 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, "helpstringcontext" },
    /* ATTR_HELPSTRINGDLL */       { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, "helpstringdll" },
    /* ATTR_HIDDEN */              { 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, "hidden" },
    /* ATTR_ID */                  { 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, "id" },
    /* ATTR_IDEMPOTENT */          { 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "idempotent" },
    /* ATTR_IIDIS */               { 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, "iid_is" },
    /* ATTR_IMMEDIATEBIND */       { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "immediatebind" },
    /* ATTR_IMPLICIT_HANDLE */     { 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "implicit_handle" },
    /* ATTR_IN */                  { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "in" },
    /* ATTR_INLINE */              { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "inline" },
    /* ATTR_INPUTSYNC */           { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "inputsync" },
    /* ATTR_LENGTHIS */            { 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, "length_is" },
    /* ATTR_LIBLCID */             { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, "lcid" },
    /* ATTR_LOCAL */               { 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "local" },
    /* ATTR_NONBROWSABLE */        { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "nonbrowsable" },
    /* ATTR_NONCREATABLE */        { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "noncreatable" },
    /* ATTR_NONEXTENSIBLE */       { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "nonextensible" },
    /* ATTR_OBJECT */              { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "object" },
    /* ATTR_ODL */                 { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, "odl" },
    /* ATTR_OLEAUTOMATION */       { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "oleautomation" },
    /* ATTR_OPTIONAL */            { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "optional" },
    /* ATTR_OUT */                 { 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "out" },
2057
    /* ATTR_PARAMLCID */           { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "lcid" },
2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080
    /* ATTR_POINTERDEFAULT */      { 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "pointer_default" },
    /* ATTR_POINTERTYPE */         { 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, "ref, unique or ptr" },
    /* ATTR_PROPGET */             { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "propget" },
    /* ATTR_PROPPUT */             { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "propput" },
    /* ATTR_PROPPUTREF */          { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "propputref" },
    /* ATTR_PUBLIC */              { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "public" },
    /* ATTR_RANGE */               { 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, "range" },
    /* ATTR_READONLY */            { 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, "readonly" },
    /* ATTR_REQUESTEDIT */         { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "requestedit" },
    /* ATTR_RESTRICTED */          { 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, "restricted" },
    /* ATTR_RETVAL */              { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "retval" },
    /* ATTR_SIZEIS */              { 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, "size_is" },
    /* ATTR_SOURCE */              { 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, "source" },
    /* ATTR_STRICTCONTEXTHANDLE */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "strict_context_handle" },
    /* ATTR_STRING */              { 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, "string" },
    /* ATTR_SWITCHIS */            { 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, "switch_is" },
    /* ATTR_SWITCHTYPE */          { 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, "switch_type" },
    /* ATTR_TRANSMITAS */          { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "transmit_as" },
    /* ATTR_UUID */                { 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, "uuid" },
    /* ATTR_V1ENUM */              { 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, "v1_enum" },
    /* ATTR_VARARG */              { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "vararg" },
    /* ATTR_VERSION */             { 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, "version" },
    /* ATTR_WIREMARSHAL */         { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "wire_marshal" },
2081 2082
};

2083 2084 2085 2086 2087
const char *get_attr_display_name(enum attr_type type)
{
    return allowed_attr[type].display_name;
}

2088
static attr_list_t *check_iface_attrs(const char *name, attr_list_t *attrs)
2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113
{
  const attr_t *attr;
  if (!attrs) return attrs;
  LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
  {
    if (!allowed_attr[attr->type].on_interface)
      error_loc("inapplicable attribute %s for interface %s\n",
                allowed_attr[attr->type].display_name, name);
  }
  return attrs;
}

static attr_list_t *check_function_attrs(const char *name, attr_list_t *attrs)
{
  const attr_t *attr;
  if (!attrs) return attrs;
  LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
  {
    if (!allowed_attr[attr->type].on_function)
      error_loc("inapplicable attribute %s for function %s\n",
                allowed_attr[attr->type].display_name, name);
  }
  return attrs;
}

2114
static void check_arg_attrs(const var_t *arg)
2115
{
2116
  const attr_t *attr;
2117

2118 2119 2120 2121 2122 2123 2124 2125 2126
  if (arg->attrs)
  {
    LIST_FOR_EACH_ENTRY(attr, arg->attrs, const attr_t, entry)
    {
      if (!allowed_attr[attr->type].on_arg)
        error_loc("inapplicable attribute %s for argument %s\n",
                  allowed_attr[attr->type].display_name, arg->name);
    }
  }
2127
}
2128

2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141
static attr_list_t *check_typedef_attrs(attr_list_t *attrs)
{
  const attr_t *attr;
  if (!attrs) return attrs;
  LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
  {
    if (!allowed_attr[attr->type].on_type)
      error_loc("inapplicable attribute %s for typedef\n",
                allowed_attr[attr->type].display_name);
  }
  return attrs;
}

2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180
static attr_list_t *check_enum_attrs(attr_list_t *attrs)
{
  const attr_t *attr;
  if (!attrs) return attrs;
  LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
  {
    if (!allowed_attr[attr->type].on_enum)
      error_loc("inapplicable attribute %s for enum\n",
                allowed_attr[attr->type].display_name);
  }
  return attrs;
}

static attr_list_t *check_struct_attrs(attr_list_t *attrs)
{
  const attr_t *attr;
  if (!attrs) return attrs;
  LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
  {
    if (!allowed_attr[attr->type].on_struct)
      error_loc("inapplicable attribute %s for struct\n",
                allowed_attr[attr->type].display_name);
  }
  return attrs;
}

static attr_list_t *check_union_attrs(attr_list_t *attrs)
{
  const attr_t *attr;
  if (!attrs) return attrs;
  LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
  {
    if (!allowed_attr[attr->type].on_union)
      error_loc("inapplicable attribute %s for union\n",
                allowed_attr[attr->type].display_name);
  }
  return attrs;
}

2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193
static attr_list_t *check_field_attrs(const char *name, attr_list_t *attrs)
{
  const attr_t *attr;
  if (!attrs) return attrs;
  LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
  {
    if (!allowed_attr[attr->type].on_field)
      error_loc("inapplicable attribute %s for field %s\n",
                allowed_attr[attr->type].display_name, name);
  }
  return attrs;
}

2194
static attr_list_t *check_library_attrs(const char *name, attr_list_t *attrs)
2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219
{
  const attr_t *attr;
  if (!attrs) return attrs;
  LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
  {
    if (!allowed_attr[attr->type].on_library)
      error_loc("inapplicable attribute %s for library %s\n",
                allowed_attr[attr->type].display_name, name);
  }
  return attrs;
}

static attr_list_t *check_dispiface_attrs(const char *name, attr_list_t *attrs)
{
  const attr_t *attr;
  if (!attrs) return attrs;
  LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
  {
    if (!allowed_attr[attr->type].on_dispinterface)
      error_loc("inapplicable attribute %s for dispinterface %s\n",
                allowed_attr[attr->type].display_name, name);
  }
  return attrs;
}

2220
static attr_list_t *check_module_attrs(const char *name, attr_list_t *attrs)
2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232
{
  const attr_t *attr;
  if (!attrs) return attrs;
  LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
  {
    if (!allowed_attr[attr->type].on_module)
      error_loc("inapplicable attribute %s for module %s\n",
                allowed_attr[attr->type].display_name, name);
  }
  return attrs;
}

2233
static attr_list_t *check_coclass_attrs(const char *name, attr_list_t *attrs)
2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245
{
  const attr_t *attr;
  if (!attrs) return attrs;
  LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
  {
    if (!allowed_attr[attr->type].on_coclass)
      error_loc("inapplicable attribute %s for coclass %s\n",
                allowed_attr[attr->type].display_name, name);
  }
  return attrs;
}

2246 2247
static int is_allowed_conf_type(const type_t *type)
{
2248
    switch (type_get_type(type))
2249
    {
2250
    case TYPE_ENUM:
2251
        return TRUE;
2252
    case TYPE_BASIC:
2253
        switch (type_basic_get_type(type))
2254
        {
2255 2256 2257 2258 2259 2260 2261 2262 2263 2264
        case TYPE_BASIC_INT8:
        case TYPE_BASIC_INT16:
        case TYPE_BASIC_INT32:
        case TYPE_BASIC_INT64:
        case TYPE_BASIC_INT:
        case TYPE_BASIC_CHAR:
        case TYPE_BASIC_HYPER:
        case TYPE_BASIC_BYTE:
        case TYPE_BASIC_WCHAR:
        case TYPE_BASIC_ERROR_STATUS_T:
2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282
            return TRUE;
        default:
            return FALSE;
        }
    case TYPE_ALIAS:
        /* shouldn't get here because of type_get_type call above */
        assert(0);
        /* fall through */
    case TYPE_STRUCT:
    case TYPE_UNION:
    case TYPE_ENCAPSULATED_UNION:
    case TYPE_ARRAY:
    case TYPE_POINTER:
    case TYPE_VOID:
    case TYPE_MODULE:
    case TYPE_COCLASS:
    case TYPE_FUNCTION:
    case TYPE_INTERFACE:
2283
    case TYPE_BITFIELD:
2284 2285
        return FALSE;
    }
2286
    return FALSE;
2287 2288 2289 2290 2291
}

static int is_ptr_guid_type(const type_t *type)
{
    unsigned int align = 0;
2292 2293 2294 2295 2296 2297

    /* first, make sure it is a pointer to something */
    if (!is_ptr(type)) return FALSE;

    /* second, make sure it is a pointer to something of size sizeof(GUID),
     * i.e. 16 bytes */
2298
    return (type_memsize(type_pointer_get_ref(type), &align) == 16);
2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310
}

static void check_conformance_expr_list(const char *attr_name, const var_t *arg, const type_t *container_type, expr_list_t *expr_list)
{
    expr_t *dim;
    struct expr_loc expr_loc;
    expr_loc.v = arg;
    expr_loc.attr = attr_name;
    if (expr_list) LIST_FOR_EACH_ENTRY(dim, expr_list, expr_t, entry)
    {
        if (dim->type != EXPR_VOID)
        {
2311 2312
            const type_t *expr_type = expr_resolve_type(&expr_loc, container_type, dim);
            if (!is_allowed_conf_type(expr_type))
2313 2314 2315 2316 2317 2318
                error_loc_info(&arg->loc_info, "expression must resolve to integral type <= 32bits for attribute %s\n",
                               attr_name);
        }
    }
}

2319
static void check_remoting_fields(const var_t *var, type_t *type);
2320 2321

/* checks that properties common to fields and arguments are consistent */
2322
static void check_field_common(const type_t *container_type,
2323 2324 2325
                               const char *container_name, const var_t *arg)
{
    type_t *type = arg->type;
2326
    int more_to_do;
2327 2328
    const char *container_type_name;
    const char *var_type;
2329

2330
    switch (type_get_type(container_type))
2331 2332
    {
    case TYPE_STRUCT:
2333
        container_type_name = "struct";
2334
        var_type = "field";
2335 2336
        break;
    case TYPE_UNION:
2337
        container_type_name = "union";
2338
        var_type = "arm";
2339 2340 2341
        break;
    case TYPE_ENCAPSULATED_UNION:
        container_type_name = "encapsulated union";
2342
        var_type = "arm";
2343 2344
        break;
    case TYPE_FUNCTION:
2345
        container_type_name = "function";
2346
        var_type = "parameter";
2347 2348
        break;
    default:
2349 2350
        /* should be no other container types */
        assert(0);
2351
        return;
2352
    }
2353 2354 2355 2356 2357 2358 2359

    if (is_attr(arg->attrs, ATTR_LENGTHIS) &&
        (is_attr(arg->attrs, ATTR_STRING) || is_aliaschain_attr(arg->type, ATTR_STRING)))
        error_loc_info(&arg->loc_info,
                       "string and length_is specified for argument %s are mutually exclusive attributes\n",
                       arg->name);

2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375
    if (is_attr(arg->attrs, ATTR_SIZEIS))
    {
        expr_list_t *size_is_exprs = get_attrp(arg->attrs, ATTR_SIZEIS);
        check_conformance_expr_list("size_is", arg, container_type, size_is_exprs);
    }
    if (is_attr(arg->attrs, ATTR_LENGTHIS))
    {
        expr_list_t *length_is_exprs = get_attrp(arg->attrs, ATTR_LENGTHIS);
        check_conformance_expr_list("length_is", arg, container_type, length_is_exprs);
    }
    if (is_attr(arg->attrs, ATTR_IIDIS))
    {
        struct expr_loc expr_loc;
        expr_t *expr = get_attrp(arg->attrs, ATTR_IIDIS);
        if (expr->type != EXPR_VOID)
        {
2376
            const type_t *expr_type;
2377 2378
            expr_loc.v = arg;
            expr_loc.attr = "iid_is";
2379 2380
            expr_type = expr_resolve_type(&expr_loc, container_type, expr);
            if (!expr_type || !is_ptr_guid_type(expr_type))
2381 2382 2383 2384 2385 2386 2387 2388 2389
                error_loc_info(&arg->loc_info, "expression must resolve to pointer to GUID type for attribute iid_is\n");
        }
    }
    if (is_attr(arg->attrs, ATTR_SWITCHIS))
    {
        struct expr_loc expr_loc;
        expr_t *expr = get_attrp(arg->attrs, ATTR_SWITCHIS);
        if (expr->type != EXPR_VOID)
        {
2390
            const type_t *expr_type;
2391 2392
            expr_loc.v = arg;
            expr_loc.attr = "switch_is";
2393 2394
            expr_type = expr_resolve_type(&expr_loc, container_type, expr);
            if (!expr_type || !is_allowed_conf_type(expr_type))
2395 2396 2397 2398 2399
                error_loc_info(&arg->loc_info, "expression must resolve to integral type <= 32bits for attribute %s\n",
                               expr_loc.attr);
        }
    }

2400
    do
2401
    {
2402 2403 2404
        more_to_do = FALSE;

        switch (typegen_detect_type(type, arg->attrs, TDT_IGNORE_STRINGS))
2405
        {
2406 2407 2408
        case TGT_STRUCT:
        case TGT_UNION:
            check_remoting_fields(arg, type);
2409
            break;
2410
        case TGT_INVALID:
2411 2412
        {
            const char *reason = "is invalid";
2413 2414 2415
            switch (type_get_type(type))
            {
            case TYPE_VOID:
2416
                reason = "cannot derive from void *";
2417 2418
                break;
            case TYPE_FUNCTION:
2419 2420 2421 2422
                reason = "cannot be a function pointer";
                break;
            case TYPE_BITFIELD:
                reason = "cannot be a bit-field";
2423 2424
                break;
            case TYPE_COCLASS:
2425 2426
                reason = "cannot be a class";
                break;
2427
            case TYPE_INTERFACE:
2428 2429
                reason = "cannot be a non-pointer to an interface";
                break;
2430
            case TYPE_MODULE:
2431
                reason = "cannot be a module";
2432 2433 2434 2435
                break;
            default:
                break;
            }
2436 2437 2438 2439
            error_loc_info(&arg->loc_info, "%s \'%s\' of %s \'%s\' %s\n",
                           var_type, arg->name, container_type_name, container_name, reason);
            break;
        }
2440 2441 2442
        case TGT_CTXT_HANDLE:
        case TGT_CTXT_HANDLE_POINTER:
            /* FIXME */
2443
            break;
2444 2445 2446 2447 2448 2449 2450 2451 2452
        case TGT_STRING:
        {
            const type_t *t = type;
            while (is_ptr(t))
                t = type_pointer_get_ref(t);
            if (is_aliaschain_attr(t, ATTR_RANGE))
                warning_loc_info(&arg->loc_info, "%s: range not verified for a string of ranged types\n", arg->name);
            break;
        }
2453
        case TGT_POINTER:
2454
            type = type_pointer_get_ref(type);
2455 2456 2457
            more_to_do = TRUE;
            break;
        case TGT_ARRAY:
2458
            type = type_array_get_element(type);
2459
            more_to_do = TRUE;
2460
            break;
2461 2462 2463 2464
        case TGT_USER_TYPE:
        case TGT_IFACE_POINTER:
        case TGT_BASIC:
        case TGT_ENUM:
2465
        case TGT_RANGE:
2466 2467 2468 2469
            /* nothing to do */
            break;
        }
    } while (more_to_do);
2470 2471
}

2472
static void check_remoting_fields(const var_t *var, type_t *type)
2473 2474 2475 2476
{
    const var_t *field;
    const var_list_t *fields = NULL;

2477
    type = type_get_real_type(type);
2478

2479 2480 2481 2482 2483
    if (type->checked)
        return;

    type->checked = TRUE;

2484
    if (type_get_type(type) == TYPE_STRUCT)
2485
    {
2486
        if (type_is_complete(type))
2487
            fields = type_struct_get_fields(type);
2488 2489 2490
        else
            error_loc_info(&var->loc_info, "undefined type declaration %s\n", type->name);
    }
2491
    else if (type_get_type(type) == TYPE_UNION || type_get_type(type) == TYPE_ENCAPSULATED_UNION)
2492
        fields = type_union_get_cases(type);
2493

2494
    if (fields) LIST_FOR_EACH_ENTRY( field, fields, const var_t, entry )
2495
        if (field->type) check_field_common(type, type->name, field);
2496 2497
}

2498
/* checks that arguments for a function make sense for marshalling and unmarshalling */
2499
static void check_remoting_args(const var_t *func)
2500
{
2501
    const char *funcname = func->name;
2502 2503
    const var_t *arg;

2504
    if (func->type->details.function->args) LIST_FOR_EACH_ENTRY( arg, func->type->details.function->args, const var_t, entry )
2505 2506 2507 2508 2509 2510
    {
        const type_t *type = arg->type;

        /* check that [out] parameters have enough pointer levels */
        if (is_attr(arg->attrs, ATTR_OUT))
        {
2511
            switch (typegen_detect_type(type, arg->attrs, TDT_ALL_TYPES))
2512
            {
2513 2514
            case TGT_BASIC:
            case TGT_ENUM:
2515
            case TGT_RANGE:
2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537
            case TGT_STRUCT:
            case TGT_UNION:
            case TGT_CTXT_HANDLE:
            case TGT_USER_TYPE:
                error_loc_info(&arg->loc_info, "out parameter \'%s\' of function \'%s\' is not a pointer\n", arg->name, funcname);
                break;
            case TGT_IFACE_POINTER:
                error_loc_info(&arg->loc_info, "out interface pointer \'%s\' of function \'%s\' is not a double pointer\n", arg->name, funcname);
                break;
            case TGT_STRING:
                if (!is_array(type))
                {
                    /* FIXME */
                }
                break;
            case TGT_INVALID:
                /* already error'd before we get here */
            case TGT_CTXT_HANDLE_POINTER:
            case TGT_POINTER:
            case TGT_ARRAY:
                /* OK */
                break;
2538 2539 2540
            }
        }

2541
        check_field_common(func->type, funcname, arg);
2542
    }
2543 2544 2545 2546 2547 2548 2549 2550 2551 2552

    if (type_get_type(type_function_get_rettype(func->type)) != TYPE_VOID)
    {
        var_t var;
        var = *func;
        var.type = type_function_get_rettype(func->type);
        var.name = xstrdup("return value");
        check_field_common(func->type, funcname, &var);
        free(var.name);
    }
2553 2554
}

2555
static void add_explicit_handle_if_necessary(var_t *func)
2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575
{
    const var_t* explicit_handle_var;
    const var_t* explicit_generic_handle_var = NULL;
    const var_t* context_handle_var = NULL;

    /* check for a defined binding handle */
    explicit_handle_var = get_explicit_handle_var(func);
    if (!explicit_handle_var)
    {
        explicit_generic_handle_var = get_explicit_generic_handle_var(func);
        if (!explicit_generic_handle_var)
        {
            context_handle_var = get_context_handle_var(func);
            if (!context_handle_var)
            {
                /* no explicit handle specified so add
                 * "[in] handle_t IDL_handle" as the first parameter to the
                 * function */
                var_t *idl_handle = make_var(xstrdup("IDL_handle"));
                idl_handle->attrs = append_attr(NULL, make_attr(ATTR_IN));
2576
                idl_handle->type = find_type_or_error("handle_t", 0);
2577
                type_function_add_head_arg(func->type, idl_handle);
2578 2579 2580 2581 2582
            }
        }
    }
}

2583
static void check_functions(const type_t *iface, int is_inside_library)
2584
{
2585 2586
    const statement_t *stmt;
    if (is_attr(iface->attrs, ATTR_EXPLICIT_HANDLE))
2587
    {
2588
        STATEMENTS_FOR_EACH_FUNC( stmt, type_iface_get_stmts(iface) )
2589 2590
        {
            var_t *func = stmt->u.var;
2591
            add_explicit_handle_if_necessary(func);
2592
        }
2593
    }
2594 2595
    if (!is_inside_library && !is_attr(iface->attrs, ATTR_LOCAL))
    {
2596
        STATEMENTS_FOR_EACH_FUNC( stmt, type_iface_get_stmts(iface) )
2597
        {
2598 2599
            const var_t *func = stmt->u.var;
            if (!is_attr(func->attrs, ATTR_LOCAL))
2600 2601 2602 2603 2604
                check_remoting_args(func);
        }
    }
}

2605 2606 2607 2608 2609 2610 2611 2612
static void check_statements(const statement_list_t *stmts, int is_inside_library)
{
    const statement_t *stmt;

    if (stmts) LIST_FOR_EACH_ENTRY(stmt, stmts, const statement_t, entry)
    {
      if (stmt->type == STMT_LIBRARY)
          check_statements(stmt->u.lib->stmts, TRUE);
2613
      else if (stmt->type == STMT_TYPE && type_get_type(stmt->u.type) == TYPE_INTERFACE)
2614 2615 2616 2617
          check_functions(stmt->u.type, is_inside_library);
    }
}

2618
static void check_all_user_types(const statement_list_t *stmts)
2619
{
2620
  const statement_t *stmt;
2621

2622
  if (stmts) LIST_FOR_EACH_ENTRY(stmt, stmts, const statement_t, entry)
2623
  {
2624 2625
    if (stmt->type == STMT_LIBRARY)
      check_all_user_types(stmt->u.lib->stmts);
2626
    else if (stmt->type == STMT_TYPE && type_get_type(stmt->u.type) == TYPE_INTERFACE &&
2627
             !is_local(stmt->u.type->attrs))
2628
    {
2629
      const statement_t *stmt_func;
2630
      STATEMENTS_FOR_EACH_FUNC(stmt_func, type_iface_get_stmts(stmt->u.type)) {
2631 2632 2633
        const var_t *func = stmt_func->u.var;
        check_for_additional_prototype_types(func->type->details.function->args);
      }
2634
    }
2635 2636
  }
}
2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653

int is_valid_uuid(const char *s)
{
  int i;

  for (i = 0; i < 36; ++i)
    if (i == 8 || i == 13 || i == 18 || i == 23)
    {
      if (s[i] != '-')
        return FALSE;
    }
    else
      if (!isxdigit(s[i]))
        return FALSE;

  return s[i] == '\0';
}
2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675

static statement_t *make_statement(enum statement_type type)
{
    statement_t *stmt = xmalloc(sizeof(*stmt));
    stmt->type = type;
    return stmt;
}

static statement_t *make_statement_type_decl(type_t *type)
{
    statement_t *stmt = make_statement(STMT_TYPE);
    stmt->u.type = type;
    return stmt;
}

static statement_t *make_statement_reference(type_t *type)
{
    statement_t *stmt = make_statement(STMT_TYPEREF);
    stmt->u.type = type;
    return stmt;
}

2676
static statement_t *make_statement_declaration(var_t *var)
2677
{
2678
    statement_t *stmt = make_statement(STMT_DECLARATION);
2679
    stmt->u.var = var;
2680 2681 2682 2683 2684 2685 2686
    if (var->stgclass == STG_EXTERN && var->eval)
        warning("'%s' initialised and declared extern\n", var->name);
    if (is_const_decl(var))
    {
        if (var->eval)
            reg_const(var);
    }
2687 2688 2689
    else if (type_get_type(var->type) == TYPE_FUNCTION)
        check_function_attrs(var->name, var->attrs);
    else if (var->stgclass == STG_NONE || var->stgclass == STG_REGISTER)
2690
        error_loc("instantiation of data is illegal\n");
2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714
    return stmt;
}

static statement_t *make_statement_library(typelib_t *typelib)
{
    statement_t *stmt = make_statement(STMT_LIBRARY);
    stmt->u.lib = typelib;
    return stmt;
}

static statement_t *make_statement_cppquote(const char *str)
{
    statement_t *stmt = make_statement(STMT_CPPQUOTE);
    stmt->u.str = str;
    return stmt;
}

static statement_t *make_statement_importlib(const char *str)
{
    statement_t *stmt = make_statement(STMT_IMPORTLIB);
    stmt->u.str = str;
    return stmt;
}

2715 2716 2717 2718 2719 2720 2721
static statement_t *make_statement_import(const char *str)
{
    statement_t *stmt = make_statement(STMT_IMPORT);
    stmt->u.str = str;
    return stmt;
}

2722 2723 2724 2725 2726 2727 2728
static statement_t *make_statement_module(type_t *type)
{
    statement_t *stmt = make_statement(STMT_MODULE);
    stmt->u.type = type;
    return stmt;
}

2729
static statement_t *make_statement_typedef(declarator_list_t *decls)
2730
{
2731
    declarator_t *decl, *next;
2732 2733 2734
    statement_t *stmt;
    type_list_t **type_list;

2735
    if (!decls) return NULL;
2736 2737 2738 2739 2740

    stmt = make_statement(STMT_TYPEDEF);
    stmt->u.type_list = NULL;
    type_list = &stmt->u.type_list;

2741
    LIST_FOR_EACH_ENTRY_SAFE( decl, next, decls, declarator_t, entry )
2742
    {
2743
        var_t *var = decl->var;
2744
        type_t *type = find_type_or_error(var->name, 0);
2745 2746 2747 2748 2749
        *type_list = xmalloc(sizeof(type_list_t));
        (*type_list)->type = type;
        (*type_list)->next = NULL;

        type_list = &(*type_list)->next;
2750
        free(decl);
2751 2752 2753 2754 2755 2756
        free(var);
    }

    return stmt;
}

2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767
static statement_list_t *append_statement(statement_list_t *list, statement_t *stmt)
{
    if (!stmt) return list;
    if (!list)
    {
        list = xmalloc( sizeof(*list) );
        list_init( list );
    }
    list_add_tail( list, &stmt->entry );
    return list;
}
2768

2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781
void init_loc_info(loc_info_t *i)
{
    i->input_name = input_name ? input_name : "stdin";
    i->line_number = line_number;
    i->near_text = parser_text;
}

static void check_def(const type_t *t)
{
    if (t->defined)
        error_loc("%s: redefinition error; original definition was at %s:%d\n",
                  t->name, t->loc_info.input_name, t->loc_info.line_number);
}