?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ntdll: Execute .so constructors during module initialization.
[wine/zf.git] / tools / widl / parser.y
blob3ef8d89ba1c4e269a5fa262865dc6ebc117b3f70
1 %{
2 /*
3 * IDL Compiler
4 *
5 * Copyright 2002 Ove Kaaven
6 * Copyright 2006-2008 Robert Shearman
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * 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 #include "config.h"
24
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <stdarg.h>
28 #include <assert.h>
29 #include <ctype.h>
30 #include <string.h>
31
32 #include "widl.h"
33 #include "utils.h"
34 #include "parser.h"
35 #include "header.h"
36 #include "typelib.h"
37 #include "typegen.h"
38 #include "expr.h"
39 #include "typetree.h"
40
41 typedef struct list typelist_t;
42 struct typenode {
43 type_t *type;
44 struct list entry;
45 };
46
47 struct _import_t
48 {
49 char *name;
50 int import_performed;
51 };
52
53 static str_list_t *append_str(str_list_t *list, char *str);
54 static attr_list_t *append_attr(attr_list_t *list, attr_t *attr);
55 static attr_list_t *append_attr_list(attr_list_t *new_list, attr_list_t *old_list);
56 static decl_spec_t *make_decl_spec(type_t *type, decl_spec_t *left, decl_spec_t *right,
57 enum storage_class stgclass, enum type_qualifier qual, enum function_specifier func_specifier);
58 static attr_t *make_attr(enum attr_type type);
59 static attr_t *make_attrv(enum attr_type type, unsigned int val);
60 static attr_t *make_attrp(enum attr_type type, void *val);
61 static expr_list_t *append_expr(expr_list_t *list, expr_t *expr);
62 static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, declarator_t *decl, int top);
63 static var_list_t *set_var_types(attr_list_t *attrs, decl_spec_t *decl_spec, declarator_list_t *decls);
64 static ifref_list_t *append_ifref(ifref_list_t *list, ifref_t *iface);
65 static ifref_t *make_ifref(type_t *iface);
66 static var_list_t *append_var_list(var_list_t *list, var_list_t *vars);
67 static declarator_list_t *append_declarator(declarator_list_t *list, declarator_t *p);
68 static declarator_t *make_declarator(var_t *var);
69 static type_t *make_safearray(type_t *type);
70 static typelib_t *make_library(const char *name, const attr_list_t *attrs);
71 static void append_array(declarator_t *decl, expr_t *expr);
72 static void append_chain_type(declarator_t *decl, type_t *type, enum type_qualifier qual);
73 static void append_chain_callconv(type_t *chain, char *callconv);
74 static warning_list_t *append_warning(warning_list_t *, int);
75
76 static type_t *reg_typedefs(decl_spec_t *decl_spec, var_list_t *names, attr_list_t *attrs);
77 static type_t *find_type_or_error(const char *name, int t);
78 static type_t *find_type_or_error2(char *name, int t);
79
80 static var_t *reg_const(var_t *var);
81
82 static void push_namespace(const char *name);
83 static void pop_namespace(const char *name);
84
85 static void check_arg_attrs(const var_t *arg);
86 static void check_statements(const statement_list_t *stmts, int is_inside_library);
87 static void check_all_user_types(const statement_list_t *stmts);
88 static attr_list_t *check_iface_attrs(const char *name, attr_list_t *attrs);
89 static attr_list_t *check_function_attrs(const char *name, attr_list_t *attrs);
90 static attr_list_t *check_typedef_attrs(attr_list_t *attrs);
91 static attr_list_t *check_enum_attrs(attr_list_t *attrs);
92 static attr_list_t *check_struct_attrs(attr_list_t *attrs);
93 static attr_list_t *check_union_attrs(attr_list_t *attrs);
94 static attr_list_t *check_field_attrs(const char *name, attr_list_t *attrs);
95 static attr_list_t *check_library_attrs(const char *name, attr_list_t *attrs);
96 static attr_list_t *check_dispiface_attrs(const char *name, attr_list_t *attrs);
97 static attr_list_t *check_module_attrs(const char *name, attr_list_t *attrs);
98 static attr_list_t *check_coclass_attrs(const char *name, attr_list_t *attrs);
99 const char *get_attr_display_name(enum attr_type type);
100 static void add_explicit_handle_if_necessary(const type_t *iface, var_t *func);
101 static void check_def(const type_t *t);
102
103 static void check_async_uuid(type_t *iface);
104
105 static statement_t *make_statement(enum statement_type type);
106 static statement_t *make_statement_type_decl(type_t *type);
107 static statement_t *make_statement_reference(type_t *type);
108 static statement_t *make_statement_declaration(var_t *var);
109 static statement_t *make_statement_library(typelib_t *typelib);
110 static statement_t *make_statement_pragma(const char *str);
111 static statement_t *make_statement_cppquote(const char *str);
112 static statement_t *make_statement_importlib(const char *str);
113 static statement_t *make_statement_module(type_t *type);
114 static statement_t *make_statement_typedef(var_list_t *names, int declonly);
115 static statement_t *make_statement_import(const char *str);
116 static statement_list_t *append_statement(statement_list_t *list, statement_t *stmt);
117 static statement_list_t *append_statements(statement_list_t *, statement_list_t *);
118 static attr_list_t *append_attribs(attr_list_t *, attr_list_t *);
119
120 static struct namespace global_namespace = {
121 NULL, NULL, LIST_INIT(global_namespace.entry), LIST_INIT(global_namespace.children)
122 };
123
124 static struct namespace *current_namespace = &global_namespace;
125
126 static typelib_t *current_typelib;
127
128 %}
129 %union {
130 attr_t *attr;
131 attr_list_t *attr_list;
132 str_list_t *str_list;
133 expr_t *expr;
134 expr_list_t *expr_list;
135 type_t *type;
136 var_t *var;
137 var_list_t *var_list;
138 declarator_t *declarator;
139 declarator_list_t *declarator_list;
140 statement_t *statement;
141 statement_list_t *stmt_list;
142 warning_t *warning;
143 warning_list_t *warning_list;
144 ifref_t *ifref;
145 ifref_list_t *ifref_list;
146 char *str;
147 UUID *uuid;
148 unsigned int num;
149 double dbl;
150 typelib_t *typelib;
151 struct _import_t *import;
152 struct _decl_spec_t *declspec;
153 enum storage_class stgclass;
154 enum type_qualifier type_qualifier;
155 enum function_specifier function_specifier;
156 }
157
158 %token <str> aIDENTIFIER aPRAGMA
159 %token <str> aKNOWNTYPE
160 %token <num> aNUM aHEXNUM
161 %token <dbl> aDOUBLE
162 %token <str> aSTRING aWSTRING aSQSTRING
163 %token <uuid> aUUID
164 %token aEOF aACF
165 %token SHL SHR
166 %token MEMBERPTR
167 %token EQUALITY INEQUALITY
168 %token GREATEREQUAL LESSEQUAL
169 %token LOGICALOR LOGICALAND
170 %token ELLIPSIS
171 %token tAGGREGATABLE tALLOCATE tANNOTATION tAPPOBJECT tASYNC tASYNCUUID
172 %token tAUTOHANDLE tBINDABLE tBOOLEAN tBROADCAST tBYTE tBYTECOUNT
173 %token tCALLAS tCALLBACK tCASE tCDECL tCHAR tCOCLASS tCODE tCOMMSTATUS
174 %token tCONST tCONTEXTHANDLE tCONTEXTHANDLENOSERIALIZE
175 %token tCONTEXTHANDLESERIALIZE tCONTROL tCPPQUOTE
176 %token tDECODE tDEFAULT tDEFAULTBIND
177 %token tDEFAULTCOLLELEM
178 %token tDEFAULTVALUE
179 %token tDEFAULTVTABLE
180 %token tDISABLECONSISTENCYCHECK tDISPLAYBIND
181 %token tDISPINTERFACE
182 %token tDLLNAME tDOUBLE tDUAL
183 %token tENABLEALLOCATE tENCODE tENDPOINT
184 %token tENTRY tENUM tERRORSTATUST
185 %token tEXPLICITHANDLE tEXTERN
186 %token tFALSE
187 %token tFASTCALL tFAULTSTATUS
188 %token tFLOAT tFORCEALLOCATE
189 %token tHANDLE
190 %token tHANDLET
191 %token tHELPCONTEXT tHELPFILE
192 %token tHELPSTRING tHELPSTRINGCONTEXT tHELPSTRINGDLL
193 %token tHIDDEN
194 %token tHYPER tID tIDEMPOTENT
195 %token tIGNORE tIIDIS
196 %token tIMMEDIATEBIND
197 %token tIMPLICITHANDLE
198 %token tIMPORT tIMPORTLIB
199 %token tIN tIN_LINE tINLINE
200 %token tINPUTSYNC
201 %token tINT tINT32 tINT3264 tINT64
202 %token tINTERFACE
203 %token tLCID
204 %token tLENGTHIS tLIBRARY
205 %token tLICENSED tLOCAL
206 %token tLONG
207 %token tMAYBE tMESSAGE
208 %token tMETHODS
209 %token tMODULE
210 %token tNAMESPACE
211 %token tNOCODE tNONBROWSABLE
212 %token tNONCREATABLE
213 %token tNONEXTENSIBLE
214 %token tNOTIFY tNOTIFYFLAG
215 %token tNULL
216 %token tOBJECT tODL tOLEAUTOMATION
217 %token tOPTIMIZE tOPTIONAL
218 %token tOUT
219 %token tPARTIALIGNORE tPASCAL
220 %token tPOINTERDEFAULT
221 %token tPRAGMA_WARNING
222 %token tPROGID tPROPERTIES
223 %token tPROPGET tPROPPUT tPROPPUTREF
224 %token tPROXY tPTR
225 %token tPUBLIC
226 %token tRANGE
227 %token tREADONLY tREF
228 %token tREGISTER tREPRESENTAS
229 %token tREQUESTEDIT
230 %token tRESTRICTED
231 %token tRETVAL
232 %token tSAFEARRAY
233 %token tSHORT
234 %token tSIGNED
235 %token tSIZEIS tSIZEOF
236 %token tSMALL
237 %token tSOURCE
238 %token tSTATIC
239 %token tSTDCALL
240 %token tSTRICTCONTEXTHANDLE
241 %token tSTRING tSTRUCT
242 %token tSWITCH tSWITCHIS tSWITCHTYPE
243 %token tTHREADING tTRANSMITAS
244 %token tTRUE
245 %token tTYPEDEF
246 %token tUIDEFAULT tUNION
247 %token tUNIQUE
248 %token tUNSIGNED
249 %token tUSESGETLASTERROR tUSERMARSHAL tUUID
250 %token tV1ENUM
251 %token tVARARG
252 %token tVERSION tVIPROGID
253 %token tVOID
254 %token tWCHAR tWIREMARSHAL
255 %token tAPARTMENT tNEUTRAL tSINGLE tFREE tBOTH
256
257 %type <attr> attribute acf_attribute
258 %type <attr_list> m_attributes attributes attrib_list
259 %type <attr_list> acf_attributes acf_attribute_list
260 %type <str_list> str_list
261 %type <expr> m_expr expr expr_const expr_int_const array m_bitfield
262 %type <expr_list> m_exprs /* exprs expr_list */ expr_list_int_const
263 %type <type> interfacehdr
264 %type <stgclass> storage_cls_spec
265 %type <type_qualifier> type_qualifier m_type_qual_list
266 %type <function_specifier> function_specifier
267 %type <declspec> decl_spec decl_spec_no_type m_decl_spec_no_type
268 %type <type> inherit interface interfacedef interfacedec
269 %type <type> dispinterface dispinterfacehdr dispinterfacedef
270 %type <type> module modulehdr moduledef
271 %type <str> namespacedef
272 %type <type> base_type int_std
273 %type <type> enumdef structdef uniondef typedecl
274 %type <type> type
275 %type <ifref> coclass_int
276 %type <ifref_list> coclass_ints
277 %type <var> arg ne_union_field union_field s_field case enum declaration
278 %type <var> funcdef
279 %type <var_list> m_args arg_list args dispint_meths
280 %type <var_list> fields ne_union_fields cases enums enum_list dispint_props field
281 %type <var> m_ident ident
282 %type <declarator> declarator direct_declarator init_declarator struct_declarator
283 %type <declarator> m_any_declarator any_declarator any_declarator_no_direct any_direct_declarator
284 %type <declarator> m_abstract_declarator abstract_declarator abstract_declarator_no_direct abstract_direct_declarator
285 %type <declarator_list> declarator_list struct_declarator_list
286 %type <type> coclass coclasshdr coclassdef
287 %type <num> pointer_type threading_type version
288 %type <str> libraryhdr callconv cppquote importlib import t_ident
289 %type <uuid> uuid_string
290 %type <import> import_start
291 %type <typelib> library_start librarydef
292 %type <statement> statement typedef pragma_warning
293 %type <stmt_list> gbl_statements imp_statements int_statements
294 %type <warning_list> warnings
295
296 %left ','
297 %right '?' ':'
298 %left LOGICALOR
299 %left LOGICALAND
300 %left '|'
301 %left '^'
302 %left '&'
303 %left EQUALITY INEQUALITY
304 %left '<' '>' LESSEQUAL GREATEREQUAL
305 %left SHL SHR
306 %left '-' '+'
307 %left '*' '/' '%'
308 %right '!' '~' CAST PPTR POS NEG ADDRESSOF tSIZEOF
309 %left '.' MEMBERPTR '[' ']'
310
311 %define parse.error verbose
312
313 %%
314
315 input: gbl_statements m_acf { check_statements($1, FALSE);
316 check_all_user_types($1);
317 write_header($1);
318 write_id_data($1);
319 write_proxies($1);
320 write_client($1);
321 write_server($1);
322 write_regscript($1);
323 write_typelib_regscript($1);
324 write_dlldata($1);
325 write_local_stubs($1);
326 }
327 ;
328
329 m_acf: /* empty */ | aACF acf_statements
330
331 gbl_statements: { $$ = NULL; }
332 | gbl_statements namespacedef '{' { push_namespace($2); } gbl_statements '}'
333 { pop_namespace($2); $$ = append_statements($1, $5); }
334 | gbl_statements interfacedec { $$ = append_statement($1, make_statement_reference($2)); }
335 | gbl_statements interfacedef { $$ = append_statement($1, make_statement_type_decl($2)); }
336 | gbl_statements coclass ';' { $$ = $1;
337 reg_type($2, $2->name, current_namespace, 0);
338 }
339 | gbl_statements coclassdef { $$ = append_statement($1, make_statement_type_decl($2));
340 reg_type($2, $2->name, current_namespace, 0);
341 }
342 | gbl_statements moduledef { $$ = append_statement($1, make_statement_module($2)); }
343 | gbl_statements librarydef { $$ = append_statement($1, make_statement_library($2)); }
344 | gbl_statements statement { $$ = append_statement($1, $2); }
345 ;
346
347 imp_statements: { $$ = NULL; }
348 | imp_statements interfacedec { $$ = append_statement($1, make_statement_reference($2)); }
349 | imp_statements namespacedef '{' { push_namespace($2); } imp_statements '}'
350 { pop_namespace($2); $$ = append_statements($1, $5); }
351 | imp_statements interfacedef { $$ = append_statement($1, make_statement_type_decl($2)); }
352 | imp_statements coclass ';' { $$ = $1; reg_type($2, $2->name, current_namespace, 0); }
353 | imp_statements coclassdef { $$ = append_statement($1, make_statement_type_decl($2));
354 reg_type($2, $2->name, current_namespace, 0);
355 }
356 | imp_statements moduledef { $$ = append_statement($1, make_statement_module($2)); }
357 | imp_statements statement { $$ = append_statement($1, $2); }
358 | imp_statements importlib { $$ = append_statement($1, make_statement_importlib($2)); }
359 | imp_statements librarydef { $$ = append_statement($1, make_statement_library($2)); }
360 ;
361
362 int_statements: { $$ = NULL; }
363 | int_statements statement { $$ = append_statement($1, $2); }
364 ;
365
366 semicolon_opt:
367 | ';'
368 ;
369
370 statement:
371 cppquote { $$ = make_statement_cppquote($1); }
372 | typedecl ';' { $$ = make_statement_type_decl($1); }
373 | declaration ';' { $$ = make_statement_declaration($1); }
374 | import { $$ = make_statement_import($1); }
375 | typedef ';' { $$ = $1; }
376 | aPRAGMA { $$ = make_statement_pragma($1); }
377 | pragma_warning { $$ = NULL; }
378 ;
379
380 pragma_warning: tPRAGMA_WARNING '(' aIDENTIFIER ':' warnings ')'
381 {
382 int result;
383 $$ = NULL;
384 result = do_warning($3, $5);
385 if(!result)
386 error_loc("expected \"disable\" or \"enable\"\n");
387 }
388 ;
389
390 warnings:
391 aNUM { $$ = append_warning(NULL, $1); }
392 | warnings aNUM { $$ = append_warning($1, $2); }
393 ;
394
395 typedecl:
396 enumdef
397 | tENUM aIDENTIFIER { $$ = type_new_enum($2, current_namespace, FALSE, NULL); }
398 | structdef
399 | tSTRUCT aIDENTIFIER { $$ = type_new_struct($2, current_namespace, FALSE, NULL); }
400 | uniondef
401 | tUNION aIDENTIFIER { $$ = type_new_nonencapsulated_union($2, FALSE, NULL); }
402 | attributes enumdef { $$ = $2; $$->attrs = check_enum_attrs($1); }
403 | attributes structdef { $$ = $2; $$->attrs = check_struct_attrs($1); }
404 | attributes uniondef { $$ = $2; $$->attrs = check_union_attrs($1); }
405 ;
406
407 cppquote: tCPPQUOTE '(' aSTRING ')' { $$ = $3; }
408 ;
409 import_start: tIMPORT aSTRING ';' { assert(yychar == YYEMPTY);
410 $$ = xmalloc(sizeof(struct _import_t));
411 $$->name = $2;
412 $$->import_performed = do_import($2);
413 if (!$$->import_performed) yychar = aEOF;
414 }
415 ;
416
417 import: import_start imp_statements aEOF { $$ = $1->name;
418 if ($1->import_performed) pop_import();
419 free($1);
420 }
421 ;
422
423 importlib: tIMPORTLIB '(' aSTRING ')'
424 semicolon_opt { $$ = $3; if(!parse_only) add_importlib($3, current_typelib); }
425 ;
426
427 libraryhdr: tLIBRARY aIDENTIFIER { $$ = $2; }
428 | tLIBRARY aKNOWNTYPE { $$ = $2; }
429 ;
430 library_start: attributes libraryhdr '{' { $$ = make_library($2, check_library_attrs($2, $1));
431 if (!parse_only && do_typelib) current_typelib = $$;
432 }
433 ;
434 librarydef: library_start imp_statements '}'
435 semicolon_opt { $$ = $1; $$->stmts = $2; }
436 ;
437
438 m_args: { $$ = NULL; }
439 | args
440 ;
441
442 arg_list: arg { check_arg_attrs($1); $$ = append_var( NULL, $1 ); }
443 | arg_list ',' arg { check_arg_attrs($3); $$ = append_var( $1, $3 ); }
444 ;
445
446 args: arg_list
447 | arg_list ',' ELLIPSIS { $$ = append_var( $1, make_var(strdup("...")) ); }
448 ;
449
450 /* split into two rules to get bison to resolve a tVOID conflict */
451 arg: attributes decl_spec m_any_declarator { if ($2->stgclass != STG_NONE && $2->stgclass != STG_REGISTER)
452 error_loc("invalid storage class for function parameter\n");
453 $$ = declare_var($1, $2, $3, TRUE);
454 free($2); free($3);
455 }
456 | decl_spec m_any_declarator { if ($1->stgclass != STG_NONE && $1->stgclass != STG_REGISTER)
457 error_loc("invalid storage class for function parameter\n");
458 $$ = declare_var(NULL, $1, $2, TRUE);
459 free($1); free($2);
460 }
461 ;
462
463 array: '[' expr ']' { $$ = $2;
464 if (!$$->is_const || $$->cval <= 0)
465 error_loc("array dimension is not a positive integer constant\n");
466 }
467 | '[' '*' ']' { $$ = make_expr(EXPR_VOID); }
468 | '[' ']' { $$ = make_expr(EXPR_VOID); }
469 ;
470
471 m_attributes: { $$ = NULL; }
472 | attributes
473 ;
474
475 attributes:
476 '[' attrib_list ']' { $$ = $2; }
477 ;
478
479 attrib_list: attribute { $$ = append_attr( NULL, $1 ); }
480 | attrib_list ',' attribute { $$ = append_attr( $1, $3 ); }
481 | attrib_list ']' '[' attribute { $$ = append_attr( $1, $4 ); }
482 ;
483
484 str_list: aSTRING { $$ = append_str( NULL, $1 ); }
485 | str_list ',' aSTRING { $$ = append_str( $1, $3 ); }
486 ;
487
488 attribute: { $$ = NULL; }
489 | tAGGREGATABLE { $$ = make_attr(ATTR_AGGREGATABLE); }
490 | tANNOTATION '(' aSTRING ')' { $$ = make_attrp(ATTR_ANNOTATION, $3); }
491 | tAPPOBJECT { $$ = make_attr(ATTR_APPOBJECT); }
492 | tASYNC { $$ = make_attr(ATTR_ASYNC); }
493 | tAUTOHANDLE { $$ = make_attr(ATTR_AUTO_HANDLE); }
494 | tBINDABLE { $$ = make_attr(ATTR_BINDABLE); }
495 | tBROADCAST { $$ = make_attr(ATTR_BROADCAST); }
496 | tCALLAS '(' ident ')' { $$ = make_attrp(ATTR_CALLAS, $3); }
497 | tCASE '(' expr_list_int_const ')' { $$ = make_attrp(ATTR_CASE, $3); }
498 | tCODE { $$ = make_attr(ATTR_CODE); }
499 | tCOMMSTATUS { $$ = make_attr(ATTR_COMMSTATUS); }
500 | tCONTEXTHANDLE { $$ = make_attrv(ATTR_CONTEXTHANDLE, 0); }
501 | tCONTEXTHANDLENOSERIALIZE { $$ = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_DONT_SERIALIZE */ }
502 | tCONTEXTHANDLESERIALIZE { $$ = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_SERIALIZE */ }
503 | tCONTROL { $$ = make_attr(ATTR_CONTROL); }
504 | tDECODE { $$ = make_attr(ATTR_DECODE); }
505 | tDEFAULT { $$ = make_attr(ATTR_DEFAULT); }
506 | tDEFAULTBIND { $$ = make_attr(ATTR_DEFAULTBIND); }
507 | tDEFAULTCOLLELEM { $$ = make_attr(ATTR_DEFAULTCOLLELEM); }
508 | tDEFAULTVALUE '(' expr_const ')' { $$ = make_attrp(ATTR_DEFAULTVALUE, $3); }
509 | tDEFAULTVTABLE { $$ = make_attr(ATTR_DEFAULTVTABLE); }
510 | tDISABLECONSISTENCYCHECK { $$ = make_attr(ATTR_DISABLECONSISTENCYCHECK); }
511 | tDISPLAYBIND { $$ = make_attr(ATTR_DISPLAYBIND); }
512 | tDLLNAME '(' aSTRING ')' { $$ = make_attrp(ATTR_DLLNAME, $3); }
513 | tDUAL { $$ = make_attr(ATTR_DUAL); }
514 | tENABLEALLOCATE { $$ = make_attr(ATTR_ENABLEALLOCATE); }
515 | tENCODE { $$ = make_attr(ATTR_ENCODE); }
516 | tENDPOINT '(' str_list ')' { $$ = make_attrp(ATTR_ENDPOINT, $3); }
517 | tENTRY '(' expr_const ')' { $$ = make_attrp(ATTR_ENTRY, $3); }
518 | tEXPLICITHANDLE { $$ = make_attr(ATTR_EXPLICIT_HANDLE); }
519 | tFAULTSTATUS { $$ = make_attr(ATTR_FAULTSTATUS); }
520 | tFORCEALLOCATE { $$ = make_attr(ATTR_FORCEALLOCATE); }
521 | tHANDLE { $$ = make_attr(ATTR_HANDLE); }
522 | tHELPCONTEXT '(' expr_int_const ')' { $$ = make_attrp(ATTR_HELPCONTEXT, $3); }
523 | tHELPFILE '(' aSTRING ')' { $$ = make_attrp(ATTR_HELPFILE, $3); }
524 | tHELPSTRING '(' aSTRING ')' { $$ = make_attrp(ATTR_HELPSTRING, $3); }
525 | tHELPSTRINGCONTEXT '(' expr_int_const ')' { $$ = make_attrp(ATTR_HELPSTRINGCONTEXT, $3); }
526 | tHELPSTRINGDLL '(' aSTRING ')' { $$ = make_attrp(ATTR_HELPSTRINGDLL, $3); }
527 | tHIDDEN { $$ = make_attr(ATTR_HIDDEN); }
528 | tID '(' expr_int_const ')' { $$ = make_attrp(ATTR_ID, $3); }
529 | tIDEMPOTENT { $$ = make_attr(ATTR_IDEMPOTENT); }
530 | tIGNORE { $$ = make_attr(ATTR_IGNORE); }
531 | tIIDIS '(' expr ')' { $$ = make_attrp(ATTR_IIDIS, $3); }
532 | tIMMEDIATEBIND { $$ = make_attr(ATTR_IMMEDIATEBIND); }
533 | tIMPLICITHANDLE '(' arg ')' { $$ = make_attrp(ATTR_IMPLICIT_HANDLE, $3); }
534 | tIN { $$ = make_attr(ATTR_IN); }
535 | tINPUTSYNC { $$ = make_attr(ATTR_INPUTSYNC); }
536 | tLENGTHIS '(' m_exprs ')' { $$ = make_attrp(ATTR_LENGTHIS, $3); }
537 | tLCID '(' expr_int_const ')' { $$ = make_attrp(ATTR_LIBLCID, $3); }
538 | tLCID { $$ = make_attr(ATTR_PARAMLCID); }
539 | tLICENSED { $$ = make_attr(ATTR_LICENSED); }
540 | tLOCAL { $$ = make_attr(ATTR_LOCAL); }
541 | tMAYBE { $$ = make_attr(ATTR_MAYBE); }
542 | tMESSAGE { $$ = make_attr(ATTR_MESSAGE); }
543 | tNOCODE { $$ = make_attr(ATTR_NOCODE); }
544 | tNONBROWSABLE { $$ = make_attr(ATTR_NONBROWSABLE); }
545 | tNONCREATABLE { $$ = make_attr(ATTR_NONCREATABLE); }
546 | tNONEXTENSIBLE { $$ = make_attr(ATTR_NONEXTENSIBLE); }
547 | tNOTIFY { $$ = make_attr(ATTR_NOTIFY); }
548 | tNOTIFYFLAG { $$ = make_attr(ATTR_NOTIFYFLAG); }
549 | tOBJECT { $$ = make_attr(ATTR_OBJECT); }
550 | tODL { $$ = make_attr(ATTR_ODL); }
551 | tOLEAUTOMATION { $$ = make_attr(ATTR_OLEAUTOMATION); }
552 | tOPTIMIZE '(' aSTRING ')' { $$ = make_attrp(ATTR_OPTIMIZE, $3); }
553 | tOPTIONAL { $$ = make_attr(ATTR_OPTIONAL); }
554 | tOUT { $$ = make_attr(ATTR_OUT); }
555 | tPARTIALIGNORE { $$ = make_attr(ATTR_PARTIALIGNORE); }
556 | tPOINTERDEFAULT '(' pointer_type ')' { $$ = make_attrv(ATTR_POINTERDEFAULT, $3); }
557 | tPROGID '(' aSTRING ')' { $$ = make_attrp(ATTR_PROGID, $3); }
558 | tPROPGET { $$ = make_attr(ATTR_PROPGET); }
559 | tPROPPUT { $$ = make_attr(ATTR_PROPPUT); }
560 | tPROPPUTREF { $$ = make_attr(ATTR_PROPPUTREF); }
561 | tPROXY { $$ = make_attr(ATTR_PROXY); }
562 | tPUBLIC { $$ = make_attr(ATTR_PUBLIC); }
563 | tRANGE '(' expr_int_const ',' expr_int_const ')'
564 { expr_list_t *list = append_expr( NULL, $3 );
565 list = append_expr( list, $5 );
566 $$ = make_attrp(ATTR_RANGE, list); }
567 | tREADONLY { $$ = make_attr(ATTR_READONLY); }
568 | tREPRESENTAS '(' type ')' { $$ = make_attrp(ATTR_REPRESENTAS, $3); }
569 | tREQUESTEDIT { $$ = make_attr(ATTR_REQUESTEDIT); }
570 | tRESTRICTED { $$ = make_attr(ATTR_RESTRICTED); }
571 | tRETVAL { $$ = make_attr(ATTR_RETVAL); }
572 | tSIZEIS '(' m_exprs ')' { $$ = make_attrp(ATTR_SIZEIS, $3); }
573 | tSOURCE { $$ = make_attr(ATTR_SOURCE); }
574 | tSTRICTCONTEXTHANDLE { $$ = make_attr(ATTR_STRICTCONTEXTHANDLE); }
575 | tSTRING { $$ = make_attr(ATTR_STRING); }
576 | tSWITCHIS '(' expr ')' { $$ = make_attrp(ATTR_SWITCHIS, $3); }
577 | tSWITCHTYPE '(' type ')' { $$ = make_attrp(ATTR_SWITCHTYPE, $3); }
578 | tTRANSMITAS '(' type ')' { $$ = make_attrp(ATTR_TRANSMITAS, $3); }
579 | tTHREADING '(' threading_type ')' { $$ = make_attrv(ATTR_THREADING, $3); }
580 | tUIDEFAULT { $$ = make_attr(ATTR_UIDEFAULT); }
581 | tUSESGETLASTERROR { $$ = make_attr(ATTR_USESGETLASTERROR); }
582 | tUSERMARSHAL '(' type ')' { $$ = make_attrp(ATTR_USERMARSHAL, $3); }
583 | tUUID '(' uuid_string ')' { $$ = make_attrp(ATTR_UUID, $3); }
584 | tASYNCUUID '(' uuid_string ')' { $$ = make_attrp(ATTR_ASYNCUUID, $3); }
585 | tV1ENUM { $$ = make_attr(ATTR_V1ENUM); }
586 | tVARARG { $$ = make_attr(ATTR_VARARG); }
587 | tVERSION '(' version ')' { $$ = make_attrv(ATTR_VERSION, $3); }
588 | tVIPROGID '(' aSTRING ')' { $$ = make_attrp(ATTR_VIPROGID, $3); }
589 | tWIREMARSHAL '(' type ')' { $$ = make_attrp(ATTR_WIREMARSHAL, $3); }
590 | pointer_type { $$ = make_attrv(ATTR_POINTERTYPE, $1); }
591 ;
592
593 uuid_string:
594 aUUID
595 | aSTRING { if (!is_valid_uuid($1))
596 error_loc("invalid UUID: %s\n", $1);
597 $$ = parse_uuid($1); }
598 ;
599
600 callconv: tCDECL { $$ = xstrdup("__cdecl"); }
601 | tFASTCALL { $$ = xstrdup("__fastcall"); }
602 | tPASCAL { $$ = xstrdup("__pascal"); }
603 | tSTDCALL { $$ = xstrdup("__stdcall"); }
604 ;
605
606 cases: { $$ = NULL; }
607 | cases case { $$ = append_var( $1, $2 ); }
608 ;
609
610 case: tCASE expr_int_const ':' union_field { attr_t *a = make_attrp(ATTR_CASE, append_expr( NULL, $2 ));
611 $$ = $4; if (!$$) $$ = make_var(NULL);
612 $$->attrs = append_attr( $$->attrs, a );
613 }
614 | tDEFAULT ':' union_field { attr_t *a = make_attr(ATTR_DEFAULT);
615 $$ = $3; if (!$$) $$ = make_var(NULL);
616 $$->attrs = append_attr( $$->attrs, a );
617 }
618 ;
619
620 enums: { $$ = NULL; }
621 | enum_list ',' { $$ = $1; }
622 | enum_list
623 ;
624
625 enum_list: enum { if (!$1->eval)
626 $1->eval = make_exprl(EXPR_NUM, 0 /* default for first enum entry */);
627 $$ = append_var( NULL, $1 );
628 }
629 | enum_list ',' enum { if (!$3->eval)
630 {
631 var_t *last = LIST_ENTRY( list_tail($$), var_t, entry );
632 enum expr_type type = EXPR_NUM;
633 if (last->eval->type == EXPR_HEXNUM) type = EXPR_HEXNUM;
634 if (last->eval->cval + 1 < 0) type = EXPR_HEXNUM;
635 $3->eval = make_exprl(type, last->eval->cval + 1);
636 }
637 $$ = append_var( $1, $3 );
638 }
639 ;
640
641 enum: ident '=' expr_int_const { $$ = reg_const($1);
642 $$->eval = $3;
643 $$->declspec.type = type_new_int(TYPE_BASIC_INT, 0);
644 }
645 | ident { $$ = reg_const($1);
646 $$->declspec.type = type_new_int(TYPE_BASIC_INT, 0);
647 }
648 ;
649
650 enumdef: tENUM t_ident '{' enums '}' { $$ = type_new_enum($2, current_namespace, TRUE, $4); }
651 ;
652
653 m_exprs: m_expr { $$ = append_expr( NULL, $1 ); }
654 | m_exprs ',' m_expr { $$ = append_expr( $1, $3 ); }
655 ;
656
657 m_expr: { $$ = make_expr(EXPR_VOID); }
658 | expr
659 ;
660
661 expr: aNUM { $$ = make_exprl(EXPR_NUM, $1); }
662 | aHEXNUM { $$ = make_exprl(EXPR_HEXNUM, $1); }
663 | aDOUBLE { $$ = make_exprd(EXPR_DOUBLE, $1); }
664 | tFALSE { $$ = make_exprl(EXPR_TRUEFALSE, 0); }
665 | tNULL { $$ = make_exprl(EXPR_NUM, 0); }
666 | tTRUE { $$ = make_exprl(EXPR_TRUEFALSE, 1); }
667 | aSTRING { $$ = make_exprs(EXPR_STRLIT, $1); }
668 | aWSTRING { $$ = make_exprs(EXPR_WSTRLIT, $1); }
669 | aSQSTRING { $$ = make_exprs(EXPR_CHARCONST, $1); }
670 | aIDENTIFIER { $$ = make_exprs(EXPR_IDENTIFIER, $1); }
671 | expr '?' expr ':' expr { $$ = make_expr3(EXPR_COND, $1, $3, $5); }
672 | expr LOGICALOR expr { $$ = make_expr2(EXPR_LOGOR, $1, $3); }
673 | expr LOGICALAND expr { $$ = make_expr2(EXPR_LOGAND, $1, $3); }
674 | expr '|' expr { $$ = make_expr2(EXPR_OR , $1, $3); }
675 | expr '^' expr { $$ = make_expr2(EXPR_XOR, $1, $3); }
676 | expr '&' expr { $$ = make_expr2(EXPR_AND, $1, $3); }
677 | expr EQUALITY expr { $$ = make_expr2(EXPR_EQUALITY, $1, $3); }
678 | expr INEQUALITY expr { $$ = make_expr2(EXPR_INEQUALITY, $1, $3); }
679 | expr '>' expr { $$ = make_expr2(EXPR_GTR, $1, $3); }
680 | expr '<' expr { $$ = make_expr2(EXPR_LESS, $1, $3); }
681 | expr GREATEREQUAL expr { $$ = make_expr2(EXPR_GTREQL, $1, $3); }
682 | expr LESSEQUAL expr { $$ = make_expr2(EXPR_LESSEQL, $1, $3); }
683 | expr SHL expr { $$ = make_expr2(EXPR_SHL, $1, $3); }
684 | expr SHR expr { $$ = make_expr2(EXPR_SHR, $1, $3); }
685 | expr '+' expr { $$ = make_expr2(EXPR_ADD, $1, $3); }
686 | expr '-' expr { $$ = make_expr2(EXPR_SUB, $1, $3); }
687 | expr '%' expr { $$ = make_expr2(EXPR_MOD, $1, $3); }
688 | expr '*' expr { $$ = make_expr2(EXPR_MUL, $1, $3); }
689 | expr '/' expr { $$ = make_expr2(EXPR_DIV, $1, $3); }
690 | '!' expr { $$ = make_expr1(EXPR_LOGNOT, $2); }
691 | '~' expr { $$ = make_expr1(EXPR_NOT, $2); }
692 | '+' expr %prec POS { $$ = make_expr1(EXPR_POS, $2); }
693 | '-' expr %prec NEG { $$ = make_expr1(EXPR_NEG, $2); }
694 | '&' expr %prec ADDRESSOF { $$ = make_expr1(EXPR_ADDRESSOF, $2); }
695 | '*' expr %prec PPTR { $$ = make_expr1(EXPR_PPTR, $2); }
696 | expr MEMBERPTR aIDENTIFIER { $$ = make_expr2(EXPR_MEMBER, make_expr1(EXPR_PPTR, $1), make_exprs(EXPR_IDENTIFIER, $3)); }
697 | expr '.' aIDENTIFIER { $$ = make_expr2(EXPR_MEMBER, $1, make_exprs(EXPR_IDENTIFIER, $3)); }
698 | '(' decl_spec m_abstract_declarator ')' expr %prec CAST
699 { $$ = make_exprt(EXPR_CAST, declare_var(NULL, $2, $3, 0), $5); free($2); free($3); }
700 | tSIZEOF '(' decl_spec m_abstract_declarator ')'
701 { $$ = make_exprt(EXPR_SIZEOF, declare_var(NULL, $3, $4, 0), NULL); free($3); free($4); }
702 | expr '[' expr ']' { $$ = make_expr2(EXPR_ARRAY, $1, $3); }
703 | '(' expr ')' { $$ = $2; }
704 ;
705
706 expr_list_int_const: expr_int_const { $$ = append_expr( NULL, $1 ); }
707 | expr_list_int_const ',' expr_int_const { $$ = append_expr( $1, $3 ); }
708 ;
709
710 expr_int_const: expr { $$ = $1;
711 if (!$$->is_const)
712 error_loc("expression is not an integer constant\n");
713 }
714 ;
715
716 expr_const: expr { $$ = $1;
717 if (!$$->is_const && $$->type != EXPR_STRLIT && $$->type != EXPR_WSTRLIT)
718 error_loc("expression is not constant\n");
719 }
720 ;
721
722 fields: { $$ = NULL; }
723 | fields field { $$ = append_var_list($1, $2); }
724 ;
725
726 field: m_attributes decl_spec struct_declarator_list ';'
727 { const char *first = LIST_ENTRY(list_head($3), declarator_t, entry)->var->name;
728 check_field_attrs(first, $1);
729 $$ = set_var_types($1, $2, $3);
730 }
731 | m_attributes uniondef ';' { var_t *v = make_var(NULL);
732 v->declspec.type = $2; v->attrs = $1;
733 $$ = append_var(NULL, v);
734 }
735 ;
736
737 ne_union_field:
738 s_field ';' { $$ = $1; }
739 | attributes ';' { $$ = make_var(NULL); $$->attrs = $1; }
740 ;
741
742 ne_union_fields: { $$ = NULL; }
743 | ne_union_fields ne_union_field { $$ = append_var( $1, $2 ); }
744 ;
745
746 union_field:
747 s_field ';' { $$ = $1; }
748 | ';' { $$ = NULL; }
749 ;
750
751 s_field: m_attributes decl_spec declarator { $$ = declare_var(check_field_attrs($3->var->name, $1),
752 $2, $3, FALSE);
753 free($3);
754 }
755 | m_attributes structdef { var_t *v = make_var(NULL);
756 v->declspec.type = $2; v->attrs = $1;
757 $$ = v;
758 }
759 ;
760
761 funcdef: declaration { $$ = $1;
762 if (type_get_type($$->declspec.type) != TYPE_FUNCTION)
763 error_loc("only methods may be declared inside the methods section of a dispinterface\n");
764 check_function_attrs($$->name, $$->attrs);
765 }
766 ;
767
768 declaration:
769 attributes decl_spec init_declarator
770 { $$ = declare_var($1, $2, $3, FALSE);
771 free($3);
772 }
773 | decl_spec init_declarator { $$ = declare_var(NULL, $1, $2, FALSE);
774 free($2);
775 }
776 ;
777
778 m_ident: { $$ = NULL; }
779 | ident
780 ;
781
782 t_ident: { $$ = NULL; }
783 | aIDENTIFIER { $$ = $1; }
784 | aKNOWNTYPE { $$ = $1; }
785 ;
786
787 ident: aIDENTIFIER { $$ = make_var($1); }
788 /* some "reserved words" used in attributes are also used as field names in some MS IDL files */
789 | aKNOWNTYPE { $$ = make_var($<str>1); }
790 ;
791
792 base_type: tBYTE { $$ = find_type_or_error($<str>1, 0); }
793 | tWCHAR { $$ = find_type_or_error($<str>1, 0); }
794 | int_std
795 | tSIGNED int_std { $$ = type_new_int(type_basic_get_type($2), -1); }
796 | tUNSIGNED int_std { $$ = type_new_int(type_basic_get_type($2), 1); }
797 | tUNSIGNED { $$ = type_new_int(TYPE_BASIC_INT, 1); }
798 | tFLOAT { $$ = find_type_or_error($<str>1, 0); }
799 | tDOUBLE { $$ = find_type_or_error($<str>1, 0); }
800 | tBOOLEAN { $$ = find_type_or_error($<str>1, 0); }
801 | tERRORSTATUST { $$ = find_type_or_error($<str>1, 0); }
802 | tHANDLET { $$ = find_type_or_error($<str>1, 0); }
803 ;
804
805 m_int:
806 | tINT
807 ;
808
809 int_std: tINT { $$ = type_new_int(TYPE_BASIC_INT, 0); }
810 | tSHORT m_int { $$ = type_new_int(TYPE_BASIC_INT16, 0); }
811 | tSMALL { $$ = type_new_int(TYPE_BASIC_INT8, 0); }
812 | tLONG m_int { $$ = type_new_int(TYPE_BASIC_LONG, 0); }
813 | tHYPER m_int { $$ = type_new_int(TYPE_BASIC_HYPER, 0); }
814 | tINT64 { $$ = type_new_int(TYPE_BASIC_INT64, 0); }
815 | tCHAR { $$ = type_new_int(TYPE_BASIC_CHAR, 0); }
816 | tINT32 { $$ = type_new_int(TYPE_BASIC_INT32, 0); }
817 | tINT3264 { $$ = type_new_int(TYPE_BASIC_INT3264, 0); }
818 ;
819
820 coclass: tCOCLASS aIDENTIFIER { $$ = type_new_coclass($2); }
821 | tCOCLASS aKNOWNTYPE { $$ = find_type($2, NULL, 0);
822 if (type_get_type_detect_alias($$) != TYPE_COCLASS)
823 error_loc("%s was not declared a coclass at %s:%d\n",
824 $2, $$->loc_info.input_name,
825 $$->loc_info.line_number);
826 }
827 ;
828
829 coclasshdr: attributes coclass { $$ = $2;
830 check_def($$);
831 $$->attrs = check_coclass_attrs($2->name, $1);
832 }
833 ;
834
835 coclassdef: coclasshdr '{' coclass_ints '}' semicolon_opt
836 { $$ = type_coclass_define($1, $3); }
837 ;
838
839 namespacedef: tNAMESPACE aIDENTIFIER { $$ = $2; }
840 ;
841
842 coclass_ints: { $$ = NULL; }
843 | coclass_ints coclass_int { $$ = append_ifref( $1, $2 ); }
844 ;
845
846 coclass_int:
847 m_attributes interfacedec { $$ = make_ifref($2); $$->attrs = $1; }
848 ;
849
850 dispinterface: tDISPINTERFACE aIDENTIFIER { $$ = get_type(TYPE_INTERFACE, $2, current_namespace, 0); }
851 | tDISPINTERFACE aKNOWNTYPE { $$ = get_type(TYPE_INTERFACE, $2, current_namespace, 0); }
852 ;
853
854 dispinterfacehdr: attributes dispinterface { attr_t *attrs;
855 $$ = $2;
856 check_def($$);
857 attrs = make_attr(ATTR_DISPINTERFACE);
858 $$->attrs = append_attr( check_dispiface_attrs($2->name, $1), attrs );
859 $$->defined = TRUE;
860 }
861 ;
862
863 dispint_props: tPROPERTIES ':' { $$ = NULL; }
864 | dispint_props s_field ';' { $$ = append_var( $1, $2 ); }
865 ;
866
867 dispint_meths: tMETHODS ':' { $$ = NULL; }
868 | dispint_meths funcdef ';' { $$ = append_var( $1, $2 ); }
869 ;
870
871 dispinterfacedef: dispinterfacehdr '{'
872 dispint_props
873 dispint_meths
874 '}' { $$ = $1;
875 type_dispinterface_define($$, $3, $4);
876 }
877 | dispinterfacehdr
878 '{' interface ';' '}' { $$ = $1;
879 type_dispinterface_define_from_iface($$, $3);
880 }
881 ;
882
883 inherit: { $$ = NULL; }
884 | ':' aKNOWNTYPE { $$ = find_type_or_error2($2, 0); }
885 ;
886
887 interface: tINTERFACE aIDENTIFIER { $$ = get_type(TYPE_INTERFACE, $2, current_namespace, 0); }
888 | tINTERFACE aKNOWNTYPE { $$ = get_type(TYPE_INTERFACE, $2, current_namespace, 0); }
889 ;
890
891 interfacehdr: attributes interface { $$ = $2;
892 check_def($2);
893 $2->attrs = check_iface_attrs($2->name, $1);
894 $2->defined = TRUE;
895 }
896 ;
897
898 interfacedef: interfacehdr inherit
899 '{' int_statements '}' semicolon_opt { $$ = $1;
900 if($$ == $2)
901 error_loc("Interface can't inherit from itself\n");
902 type_interface_define($$, $2, $4);
903 check_async_uuid($$);
904 }
905 /* MIDL is able to import the definition of a base class from inside the
906 * definition of a derived class, I'll try to support it with this rule */
907 | interfacehdr ':' aIDENTIFIER
908 '{' import int_statements '}'
909 semicolon_opt { $$ = $1;
910 type_interface_define($$, find_type_or_error2($3, 0), $6);
911 }
912 | dispinterfacedef semicolon_opt { $$ = $1; }
913 ;
914
915 interfacedec:
916 interface ';' { $$ = $1; }
917 | dispinterface ';' { $$ = $1; }
918 ;
919
920 module: tMODULE aIDENTIFIER { $$ = type_new_module($2); }
921 | tMODULE aKNOWNTYPE { $$ = type_new_module($2); }
922 ;
923
924 modulehdr: attributes module { $$ = $2;
925 $$->attrs = check_module_attrs($2->name, $1);
926 }
927 ;
928
929 moduledef: modulehdr '{' int_statements '}'
930 semicolon_opt { $$ = $1;
931 type_module_define($$, $3);
932 }
933 ;
934
935 storage_cls_spec:
936 tEXTERN { $$ = STG_EXTERN; }
937 | tSTATIC { $$ = STG_STATIC; }
938 | tREGISTER { $$ = STG_REGISTER; }
939 ;
940
941 function_specifier:
942 tINLINE { $$ = FUNCTION_SPECIFIER_INLINE; }
943 ;
944
945 type_qualifier:
946 tCONST { $$ = TYPE_QUALIFIER_CONST; }
947 ;
948
949 m_type_qual_list: { $$ = 0; }
950 | m_type_qual_list type_qualifier { $$ = $1 | $2; }
951 ;
952
953 decl_spec: type m_decl_spec_no_type { $$ = make_decl_spec($1, $2, NULL, STG_NONE, 0, 0); }
954 | decl_spec_no_type type m_decl_spec_no_type
955 { $$ = make_decl_spec($2, $1, $3, STG_NONE, 0, 0); }
956 ;
957
958 m_decl_spec_no_type: { $$ = NULL; }
959 | decl_spec_no_type
960 ;
961
962 decl_spec_no_type:
963 type_qualifier m_decl_spec_no_type { $$ = make_decl_spec(NULL, $2, NULL, STG_NONE, $1, 0); }
964 | function_specifier m_decl_spec_no_type { $$ = make_decl_spec(NULL, $2, NULL, STG_NONE, 0, $1); }
965 | storage_cls_spec m_decl_spec_no_type { $$ = make_decl_spec(NULL, $2, NULL, $1, 0, 0); }
966 ;
967
968 declarator:
969 '*' m_type_qual_list declarator %prec PPTR
970 { $$ = $3; append_chain_type($$, type_new_pointer(NULL), $2); }
971 | callconv declarator { $$ = $2; append_chain_callconv($$->type, $1); }
972 | direct_declarator
973 ;
974
975 direct_declarator:
976 ident { $$ = make_declarator($1); }
977 | '(' declarator ')' { $$ = $2; }
978 | direct_declarator array { $$ = $1; append_array($$, $2); }
979 | direct_declarator '(' m_args ')' { $$ = $1; append_chain_type($$, type_new_function($3), 0); }
980 ;
981
982 /* abstract declarator */
983 abstract_declarator:
984 '*' m_type_qual_list m_abstract_declarator %prec PPTR
985 { $$ = $3; append_chain_type($$, type_new_pointer(NULL), $2); }
986 | callconv m_abstract_declarator { $$ = $2; append_chain_callconv($$->type, $1); }
987 | abstract_direct_declarator
988 ;
989
990 /* abstract declarator without accepting direct declarator */
991 abstract_declarator_no_direct:
992 '*' m_type_qual_list m_any_declarator %prec PPTR
993 { $$ = $3; append_chain_type($$, type_new_pointer(NULL), $2); }
994 | callconv m_any_declarator { $$ = $2; append_chain_callconv($$->type, $1); }
995 ;
996
997 /* abstract declarator or empty */
998 m_abstract_declarator: { $$ = make_declarator(NULL); }
999 | abstract_declarator
1000 ;
1001
1002 /* abstract direct declarator */
1003 abstract_direct_declarator:
1004 '(' abstract_declarator_no_direct ')' { $$ = $2; }
1005 | abstract_direct_declarator array { $$ = $1; append_array($$, $2); }
1006 | array { $$ = make_declarator(NULL); append_array($$, $1); }
1007 | '(' m_args ')'
1008 { $$ = make_declarator(NULL);
1009 append_chain_type($$, type_new_function($2), 0);
1010 }
1011 | abstract_direct_declarator '(' m_args ')'
1012 { $$ = $1;
1013 append_chain_type($$, type_new_function($3), 0);
1014 }
1015 ;
1016
1017 /* abstract or non-abstract declarator */
1018 any_declarator:
1019 '*' m_type_qual_list m_any_declarator %prec PPTR
1020 { $$ = $3; append_chain_type($$, type_new_pointer(NULL), $2); }
1021 | callconv m_any_declarator { $$ = $2; append_chain_callconv($$->type, $1); }
1022 | any_direct_declarator
1023 ;
1024
1025 /* abstract or non-abstract declarator without accepting direct declarator */
1026 any_declarator_no_direct:
1027 '*' m_type_qual_list m_any_declarator %prec PPTR
1028 { $$ = $3; append_chain_type($$, type_new_pointer(NULL), $2); }
1029 | callconv m_any_declarator { $$ = $2; append_chain_callconv($$->type, $1); }
1030 ;
1031
1032 /* abstract or non-abstract declarator or empty */
1033 m_any_declarator: { $$ = make_declarator(NULL); }
1034 | any_declarator
1035 ;
1036
1037 /* abstract or non-abstract direct declarator. note: direct declarators
1038 * aren't accepted inside brackets to avoid ambiguity with the rule for
1039 * function arguments */
1040 any_direct_declarator:
1041 ident { $$ = make_declarator($1); }
1042 | '(' any_declarator_no_direct ')' { $$ = $2; }
1043 | any_direct_declarator array { $$ = $1; append_array($$, $2); }
1044 | array { $$ = make_declarator(NULL); append_array($$, $1); }
1045 | '(' m_args ')'
1046 { $$ = make_declarator(NULL);
1047 append_chain_type($$, type_new_function($2), 0);
1048 }
1049 | any_direct_declarator '(' m_args ')'
1050 { $$ = $1;
1051 append_chain_type($$, type_new_function($3), 0);
1052 }
1053 ;
1054
1055 declarator_list:
1056 declarator { $$ = append_declarator( NULL, $1 ); }
1057 | declarator_list ',' declarator { $$ = append_declarator( $1, $3 ); }
1058 ;
1059
1060 m_bitfield: { $$ = NULL; }
1061 | ':' expr_const { $$ = $2; }
1062 ;
1063
1064 struct_declarator: any_declarator m_bitfield { $$ = $1; $$->bits = $2;
1065 if (!$$->bits && !$$->var->name)
1066 error_loc("unnamed fields are not allowed\n");
1067 }
1068 ;
1069
1070 struct_declarator_list:
1071 struct_declarator { $$ = append_declarator( NULL, $1 ); }
1072 | struct_declarator_list ',' struct_declarator
1073 { $$ = append_declarator( $1, $3 ); }
1074 ;
1075
1076 init_declarator:
1077 declarator { $$ = $1; }
1078 | declarator '=' expr_const { $$ = $1; $1->var->eval = $3; }
1079 ;
1080
1081 threading_type:
1082 tAPARTMENT { $$ = THREADING_APARTMENT; }
1083 | tNEUTRAL { $$ = THREADING_NEUTRAL; }
1084 | tSINGLE { $$ = THREADING_SINGLE; }
1085 | tFREE { $$ = THREADING_FREE; }
1086 | tBOTH { $$ = THREADING_BOTH; }
1087 ;
1088
1089 pointer_type:
1090 tREF { $$ = FC_RP; }
1091 | tUNIQUE { $$ = FC_UP; }
1092 | tPTR { $$ = FC_FP; }
1093 ;
1094
1095 structdef: tSTRUCT t_ident '{' fields '}' { $$ = type_new_struct($2, current_namespace, TRUE, $4); }
1096 ;
1097
1098 type: tVOID { $$ = type_new_void(); }
1099 | aKNOWNTYPE { $$ = find_type_or_error($1, 0); }
1100 | base_type { $$ = $1; }
1101 | enumdef { $$ = $1; }
1102 | tENUM aIDENTIFIER { $$ = type_new_enum($2, current_namespace, FALSE, NULL); }
1103 | structdef { $$ = $1; }
1104 | tSTRUCT aIDENTIFIER { $$ = type_new_struct($2, current_namespace, FALSE, NULL); }
1105 | uniondef { $$ = $1; }
1106 | tUNION aIDENTIFIER { $$ = type_new_nonencapsulated_union($2, FALSE, NULL); }
1107 | tSAFEARRAY '(' type ')' { $$ = make_safearray($3); }
1108 ;
1109
1110 typedef: m_attributes tTYPEDEF m_attributes decl_spec declarator_list
1111 { $1 = append_attribs($1, $3);
1112 reg_typedefs($4, $5, check_typedef_attrs($1));
1113 $$ = make_statement_typedef($5, !$4->type->defined);
1114 }
1115 ;
1116
1117 uniondef: tUNION t_ident '{' ne_union_fields '}'
1118 { $$ = type_new_nonencapsulated_union($2, TRUE, $4); }
1119 | tUNION t_ident
1120 tSWITCH '(' s_field ')'
1121 m_ident '{' cases '}' { $$ = type_new_encapsulated_union($2, $5, $7, $9); }
1122 ;
1123
1124 version:
1125 aNUM { $$ = MAKEVERSION($1, 0); }
1126 | aNUM '.' aNUM { $$ = MAKEVERSION($1, $3); }
1127 | aHEXNUM { $$ = $1; }
1128 ;
1129
1130 acf_statements
1131 : /* empty */
1132 | acf_interface acf_statements
1133
1134 acf_int_statements
1135 : /* empty */
1136 | acf_int_statement acf_int_statements
1137
1138 acf_int_statement
1139 : tTYPEDEF acf_attributes aKNOWNTYPE ';'
1140 { type_t *type = find_type_or_error($3, 0);
1141 type->attrs = append_attr_list(type->attrs, $2);
1142 }
1143 acf_interface
1144 : acf_attributes tINTERFACE aKNOWNTYPE '{' acf_int_statements '}'
1145 { type_t *iface = find_type_or_error2($3, 0);
1146 if (type_get_type(iface) != TYPE_INTERFACE)
1147 error_loc("%s is not an interface\n", iface->name);
1148 iface->attrs = append_attr_list(iface->attrs, $1);
1149 }
1150
1151 acf_attributes
1152 : /* empty */ { $$ = NULL; };
1153 | '[' acf_attribute_list ']' { $$ = $2; };
1154
1155 acf_attribute_list
1156 : acf_attribute { $$ = append_attr(NULL, $1); }
1157 | acf_attribute_list ',' acf_attribute { $$ = append_attr($1, $3); }
1158
1159 acf_attribute
1160 : tENCODE { $$ = make_attr(ATTR_ENCODE); }
1161 | tDECODE { $$ = make_attr(ATTR_DECODE); }
1162 | tEXPLICITHANDLE { $$ = make_attr(ATTR_EXPLICIT_HANDLE); }
1163
1164 %%
1165
1166 static void decl_builtin_basic(const char *name, enum type_basic_type type)
1167 {
1168 type_t *t = type_new_basic(type);
1169 reg_type(t, name, NULL, 0);
1170 }
1171
1172 static void decl_builtin_alias(const char *name, type_t *t)
1173 {
1174 const decl_spec_t ds = {.type = t};
1175 reg_type(type_new_alias(&ds, name), name, NULL, 0);
1176 }
1177
1178 void init_types(void)
1179 {
1180 decl_builtin_basic("byte", TYPE_BASIC_BYTE);
1181 decl_builtin_basic("wchar_t", TYPE_BASIC_WCHAR);
1182 decl_builtin_basic("float", TYPE_BASIC_FLOAT);
1183 decl_builtin_basic("double", TYPE_BASIC_DOUBLE);
1184 decl_builtin_basic("error_status_t", TYPE_BASIC_ERROR_STATUS_T);
1185 decl_builtin_basic("handle_t", TYPE_BASIC_HANDLE);
1186 decl_builtin_alias("boolean", type_new_basic(TYPE_BASIC_CHAR));
1187 }
1188
1189 static str_list_t *append_str(str_list_t *list, char *str)
1190 {
1191 struct str_list_entry_t *entry;
1192
1193 if (!str) return list;
1194 if (!list)
1195 {
1196 list = xmalloc( sizeof(*list) );
1197 list_init( list );
1198 }
1199 entry = xmalloc( sizeof(*entry) );
1200 entry->str = str;
1201 list_add_tail( list, &entry->entry );
1202 return list;
1203 }
1204
1205 static attr_list_t *append_attr(attr_list_t *list, attr_t *attr)
1206 {
1207 attr_t *attr_existing;
1208 if (!attr) return list;
1209 if (!list)
1210 {
1211 list = xmalloc( sizeof(*list) );
1212 list_init( list );
1213 }
1214 LIST_FOR_EACH_ENTRY(attr_existing, list, attr_t, entry)
1215 if (attr_existing->type == attr->type)
1216 {
1217 parser_warning("duplicate attribute %s\n", get_attr_display_name(attr->type));
1218 /* use the last attribute, like MIDL does */
1219 list_remove(&attr_existing->entry);
1220 break;
1221 }
1222 list_add_tail( list, &attr->entry );
1223 return list;
1224 }
1225
1226 static attr_list_t *move_attr(attr_list_t *dst, attr_list_t *src, enum attr_type type)
1227 {
1228 attr_t *attr;
1229 if (!src) return dst;
1230 LIST_FOR_EACH_ENTRY(attr, src, attr_t, entry)
1231 if (attr->type == type)
1232 {
1233 list_remove(&attr->entry);
1234 return append_attr(dst, attr);
1235 }
1236 return dst;
1237 }
1238
1239 static attr_list_t *append_attr_list(attr_list_t *new_list, attr_list_t *old_list)
1240 {
1241 struct list *entry;
1242
1243 if (!old_list) return new_list;
1244
1245 while ((entry = list_head(old_list)))
1246 {
1247 attr_t *attr = LIST_ENTRY(entry, attr_t, entry);
1248 list_remove(entry);
1249 new_list = append_attr(new_list, attr);
1250 }
1251 return new_list;
1252 }
1253
1254 typedef int (*map_attrs_filter_t)(attr_list_t*,const attr_t*);
1255
1256 static attr_list_t *map_attrs(const attr_list_t *list, map_attrs_filter_t filter)
1257 {
1258 attr_list_t *new_list;
1259 const attr_t *attr;
1260 attr_t *new_attr;
1261
1262 if (!list) return NULL;
1263
1264 new_list = xmalloc( sizeof(*list) );
1265 list_init( new_list );
1266 LIST_FOR_EACH_ENTRY(attr, list, const attr_t, entry)
1267 {
1268 if (filter && !filter(new_list, attr)) continue;
1269 new_attr = xmalloc(sizeof(*new_attr));
1270 *new_attr = *attr;
1271 list_add_tail(new_list, &new_attr->entry);
1272 }
1273 return new_list;
1274 }
1275
1276 static decl_spec_t *make_decl_spec(type_t *type, decl_spec_t *left, decl_spec_t *right,
1277 enum storage_class stgclass, enum type_qualifier qual, enum function_specifier func_specifier)
1278 {
1279 decl_spec_t *declspec = left ? left : right;
1280 if (!declspec)
1281 {
1282 declspec = xmalloc(sizeof(*declspec));
1283 declspec->type = NULL;
1284 declspec->stgclass = STG_NONE;
1285 declspec->qualifier = 0;
1286 declspec->func_specifier = 0;
1287 }
1288 declspec->type = type;
1289 if (left && declspec != left)
1290 {
1291 if (declspec->stgclass == STG_NONE)
1292 declspec->stgclass = left->stgclass;
1293 else if (left->stgclass != STG_NONE)
1294 error_loc("only one storage class can be specified\n");
1295 declspec->qualifier |= left->qualifier;
1296 declspec->func_specifier |= left->func_specifier;
1297 assert(!left->type);
1298 free(left);
1299 }
1300 if (right && declspec != right)
1301 {
1302 if (declspec->stgclass == STG_NONE)
1303 declspec->stgclass = right->stgclass;
1304 else if (right->stgclass != STG_NONE)
1305 error_loc("only one storage class can be specified\n");
1306 declspec->qualifier |= right->qualifier;
1307 declspec->func_specifier |= right->func_specifier;
1308 assert(!right->type);
1309 free(right);
1310 }
1311
1312 if (declspec->stgclass == STG_NONE)
1313 declspec->stgclass = stgclass;
1314 else if (stgclass != STG_NONE)
1315 error_loc("only one storage class can be specified\n");
1316 declspec->qualifier |= qual;
1317 declspec->func_specifier |= func_specifier;
1318
1319 return declspec;
1320 }
1321
1322 static attr_t *make_attr(enum attr_type type)
1323 {
1324 attr_t *a = xmalloc(sizeof(attr_t));
1325 a->type = type;
1326 a->u.ival = 0;
1327 return a;
1328 }
1329
1330 static attr_t *make_attrv(enum attr_type type, unsigned int val)
1331 {
1332 attr_t *a = xmalloc(sizeof(attr_t));
1333 a->type = type;
1334 a->u.ival = val;
1335 return a;
1336 }
1337
1338 static attr_t *make_attrp(enum attr_type type, void *val)
1339 {
1340 attr_t *a = xmalloc(sizeof(attr_t));
1341 a->type = type;
1342 a->u.pval = val;
1343 return a;
1344 }
1345
1346 static expr_list_t *append_expr(expr_list_t *list, expr_t *expr)
1347 {
1348 if (!expr) return list;
1349 if (!list)
1350 {
1351 list = xmalloc( sizeof(*list) );
1352 list_init( list );
1353 }
1354 list_add_tail( list, &expr->entry );
1355 return list;
1356 }
1357
1358 static void append_array(declarator_t *decl, expr_t *expr)
1359 {
1360 type_t *array;
1361
1362 if (!expr)
1363 return;
1364
1365 /* An array is always a reference pointer unless explicitly marked otherwise
1366 * (regardless of what the default pointer attribute is). */
1367 array = type_new_array(NULL, NULL, FALSE, expr->is_const ? expr->cval : 0,
1368 expr->is_const ? NULL : expr, NULL);
1369
1370 append_chain_type(decl, array, 0);
1371 }
1372
1373 static struct list type_pool = LIST_INIT(type_pool);
1374 typedef struct
1375 {
1376 type_t data;
1377 struct list link;
1378 } type_pool_node_t;
1379
1380 type_t *alloc_type(void)
1381 {
1382 type_pool_node_t *node = xmalloc(sizeof *node);
1383 list_add_tail(&type_pool, &node->link);
1384 return &node->data;
1385 }
1386
1387 void set_all_tfswrite(int val)
1388 {
1389 type_pool_node_t *node;
1390 LIST_FOR_EACH_ENTRY(node, &type_pool, type_pool_node_t, link)
1391 node->data.tfswrite = val;
1392 }
1393
1394 void clear_all_offsets(void)
1395 {
1396 type_pool_node_t *node;
1397 LIST_FOR_EACH_ENTRY(node, &type_pool, type_pool_node_t, link)
1398 node->data.typestring_offset = node->data.ptrdesc = 0;
1399 }
1400
1401 static void type_function_add_head_arg(type_t *type, var_t *arg)
1402 {
1403 if (!type->details.function->args)
1404 {
1405 type->details.function->args = xmalloc( sizeof(*type->details.function->args) );
1406 list_init( type->details.function->args );
1407 }
1408 list_add_head( type->details.function->args, &arg->entry );
1409 }
1410
1411 static int is_allowed_range_type(const type_t *type)
1412 {
1413 switch (type_get_type(type))
1414 {
1415 case TYPE_ENUM:
1416 return TRUE;
1417 case TYPE_BASIC:
1418 switch (type_basic_get_type(type))
1419 {
1420 case TYPE_BASIC_INT8:
1421 case TYPE_BASIC_INT16:
1422 case TYPE_BASIC_INT32:
1423 case TYPE_BASIC_INT64:
1424 case TYPE_BASIC_INT:
1425 case TYPE_BASIC_INT3264:
1426 case TYPE_BASIC_LONG:
1427 case TYPE_BASIC_BYTE:
1428 case TYPE_BASIC_CHAR:
1429 case TYPE_BASIC_WCHAR:
1430 case TYPE_BASIC_HYPER:
1431 return TRUE;
1432 case TYPE_BASIC_FLOAT:
1433 case TYPE_BASIC_DOUBLE:
1434 case TYPE_BASIC_ERROR_STATUS_T:
1435 case TYPE_BASIC_HANDLE:
1436 return FALSE;
1437 }
1438 return FALSE;
1439 default:
1440 return FALSE;
1441 }
1442 }
1443
1444 static type_t *get_chain_ref(type_t *type)
1445 {
1446 if (is_ptr(type))
1447 return type_pointer_get_ref_type(type);
1448 else if (is_array(type))
1449 return type_array_get_element_type(type);
1450 else if (is_func(type))
1451 return type_function_get_rettype(type);
1452 return NULL;
1453 }
1454
1455 static type_t *get_chain_end(type_t *type)
1456 {
1457 type_t *inner;
1458 while ((inner = get_chain_ref(type)))
1459 type = inner;
1460 return type;
1461 }
1462
1463 static void append_chain_type(declarator_t *decl, type_t *type, enum type_qualifier qual)
1464 {
1465 type_t *chain_type;
1466
1467 if (!decl->type)
1468 {
1469 decl->type = type;
1470 decl->qualifier = qual;
1471 return;
1472 }
1473 chain_type = get_chain_end(decl->type);
1474
1475 if (is_ptr(chain_type))
1476 {
1477 chain_type->details.pointer.ref.type = type;
1478 chain_type->details.pointer.ref.qualifier = qual;
1479 }
1480 else if (is_array(chain_type))
1481 {
1482 chain_type->details.array.elem.type = type;
1483 chain_type->details.array.elem.qualifier = qual;
1484 }
1485 else if (is_func(chain_type))
1486 {
1487 chain_type->details.function->retval->declspec.type = type;
1488 chain_type->details.function->retval->declspec.qualifier = qual;
1489 }
1490 else
1491 assert(0);
1492
1493 if (!is_func(chain_type))
1494 type->attrs = move_attr(type->attrs, chain_type->attrs, ATTR_CALLCONV);
1495 }
1496
1497 static void append_chain_callconv(type_t *chain, char *callconv)
1498 {
1499 type_t *chain_end;
1500
1501 if (chain && (chain_end = get_chain_end(chain)))
1502 chain_end->attrs = append_attr(chain_end->attrs, make_attrp(ATTR_CALLCONV, callconv));
1503 else
1504 error_loc("calling convention applied to non-function type\n");
1505 }
1506
1507 static warning_list_t *append_warning(warning_list_t *list, int num)
1508 {
1509 warning_t *entry;
1510
1511 if(!list)
1512 {
1513 list = xmalloc( sizeof(*list) );
1514 list_init( list );
1515 }
1516 entry = xmalloc( sizeof(*entry) );
1517 entry->num = num;
1518 list_add_tail( list, &entry->entry );
1519 return list;
1520 }
1521
1522 static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, declarator_t *decl,
1523 int top)
1524 {
1525 var_t *v = decl->var;
1526 expr_list_t *sizes = get_attrp(attrs, ATTR_SIZEIS);
1527 expr_list_t *lengs = get_attrp(attrs, ATTR_LENGTHIS);
1528 expr_t *dim;
1529 type_t **ptype;
1530 type_t *type = decl_spec->type;
1531
1532 if (decl_spec->func_specifier & FUNCTION_SPECIFIER_INLINE)
1533 {
1534 if (!decl || !is_func(decl->type))
1535 error_loc("inline attribute applied to non-function type\n");
1536 }
1537
1538 /* add type onto the end of the pointers in pident->type */
1539 append_chain_type(decl, type, decl_spec->qualifier);
1540 v->declspec = *decl_spec;
1541 v->declspec.type = decl->type;
1542 v->declspec.qualifier = decl->qualifier;
1543 v->attrs = attrs;
1544 v->declonly = !type->defined;
1545
1546 if (is_attr(type->attrs, ATTR_CALLCONV) && !is_func(type))
1547 error_loc("calling convention applied to non-function type\n");
1548
1549 /* check for pointer attribute being applied to non-pointer, non-array
1550 * type */
1551 if (!is_array(v->declspec.type))
1552 {
1553 int ptr_attr = get_attrv(v->attrs, ATTR_POINTERTYPE);
1554 const type_t *ptr = NULL;
1555 for (ptr = v->declspec.type; ptr && !ptr_attr; )
1556 {
1557 ptr_attr = get_attrv(ptr->attrs, ATTR_POINTERTYPE);
1558 if (!ptr_attr && type_is_alias(ptr))
1559 ptr = type_alias_get_aliasee_type(ptr);
1560 else
1561 break;
1562 }
1563 if (is_ptr(ptr))
1564 {
1565 if (ptr_attr && ptr_attr != FC_UP &&
1566 type_get_type(type_pointer_get_ref_type(ptr)) == TYPE_INTERFACE)
1567 warning_loc_info(&v->loc_info,
1568 "%s: pointer attribute applied to interface "
1569 "pointer type has no effect\n", v->name);
1570 if (!ptr_attr && top)
1571 {
1572 /* FIXME: this is a horrible hack to cope with the issue that we
1573 * store an offset to the typeformat string in the type object, but
1574 * two typeformat strings may be written depending on whether the
1575 * pointer is a toplevel parameter or not */
1576 v->declspec.type = duptype(v->declspec.type, 1);
1577 }
1578 }
1579 else if (ptr_attr)
1580 error_loc("%s: pointer attribute applied to non-pointer type\n", v->name);
1581 }
1582
1583 if (is_attr(v->attrs, ATTR_STRING))
1584 {
1585 type_t *t = type;
1586
1587 if (!is_ptr(v->declspec.type) && !is_array(v->declspec.type))
1588 error_loc("'%s': [string] attribute applied to non-pointer, non-array type\n",
1589 v->name);
1590
1591 for (;;)
1592 {
1593 if (is_ptr(t))
1594 t = type_pointer_get_ref_type(t);
1595 else if (is_array(t))
1596 t = type_array_get_element_type(t);
1597 else
1598 break;
1599 }
1600
1601 if (type_get_type(t) != TYPE_BASIC &&
1602 (get_basic_fc(t) != FC_CHAR &&
1603 get_basic_fc(t) != FC_BYTE &&
1604 get_basic_fc(t) != FC_WCHAR))
1605 {
1606 error_loc("'%s': [string] attribute is only valid on 'char', 'byte', or 'wchar_t' pointers and arrays\n",
1607 v->name);
1608 }
1609 }
1610
1611 if (is_attr(v->attrs, ATTR_V1ENUM))
1612 {
1613 if (type_get_type_detect_alias(v->declspec.type) != TYPE_ENUM)
1614 error_loc("'%s': [v1_enum] attribute applied to non-enum type\n", v->name);
1615 }
1616
1617 if (is_attr(v->attrs, ATTR_RANGE) && !is_allowed_range_type(v->declspec.type))
1618 error_loc("'%s': [range] attribute applied to non-integer type\n",
1619 v->name);
1620
1621 ptype = &v->declspec.type;
1622 if (sizes) LIST_FOR_EACH_ENTRY(dim, sizes, expr_t, entry)
1623 {
1624 if (dim->type != EXPR_VOID)
1625 {
1626 if (is_array(*ptype))
1627 {
1628 if (!type_array_get_conformance(*ptype) ||
1629 type_array_get_conformance(*ptype)->type != EXPR_VOID)
1630 error_loc("%s: cannot specify size_is for an already sized array\n", v->name);
1631 else
1632 *ptype = type_new_array((*ptype)->name,
1633 type_array_get_element(*ptype), FALSE,
1634 0, dim, NULL);
1635 }
1636 else if (is_ptr(*ptype))
1637 *ptype = type_new_array((*ptype)->name, type_pointer_get_ref(*ptype), TRUE,
1638 0, dim, NULL);
1639 else
1640 error_loc("%s: size_is attribute applied to illegal type\n", v->name);
1641 }
1642
1643 if (is_ptr(*ptype))
1644 ptype = &(*ptype)->details.pointer.ref.type;
1645 else if (is_array(*ptype))
1646 ptype = &(*ptype)->details.array.elem.type;
1647 else
1648 error_loc("%s: too many expressions in size_is attribute\n", v->name);
1649 }
1650
1651 ptype = &v->declspec.type;
1652 if (lengs) LIST_FOR_EACH_ENTRY(dim, lengs, expr_t, entry)
1653 {
1654 if (dim->type != EXPR_VOID)
1655 {
1656 if (is_array(*ptype))
1657 {
1658 *ptype = type_new_array((*ptype)->name,
1659 type_array_get_element(*ptype),
1660 type_array_is_decl_as_ptr(*ptype),
1661 type_array_get_dim(*ptype),
1662 type_array_get_conformance(*ptype), dim);
1663 }
1664 else
1665 error_loc("%s: length_is attribute applied to illegal type\n", v->name);
1666 }
1667
1668 if (is_ptr(*ptype))
1669 ptype = &(*ptype)->details.pointer.ref.type;
1670 else if (is_array(*ptype))
1671 ptype = &(*ptype)->details.array.elem.type;
1672 else
1673 error_loc("%s: too many expressions in length_is attribute\n", v->name);
1674 }
1675
1676 if (decl->bits)
1677 v->declspec.type = type_new_bitfield(v->declspec.type, decl->bits);
1678
1679 return v;
1680 }
1681
1682 static var_list_t *set_var_types(attr_list_t *attrs, decl_spec_t *decl_spec, declarator_list_t *decls)
1683 {
1684 declarator_t *decl, *next;
1685 var_list_t *var_list = NULL;
1686
1687 LIST_FOR_EACH_ENTRY_SAFE( decl, next, decls, declarator_t, entry )
1688 {
1689 var_t *var = declare_var(attrs, decl_spec, decl, 0);
1690 var_list = append_var(var_list, var);
1691 free(decl);
1692 }
1693 free(decl_spec);
1694 return var_list;
1695 }
1696
1697 static ifref_list_t *append_ifref(ifref_list_t *list, ifref_t *iface)
1698 {
1699 if (!iface) return list;
1700 if (!list)
1701 {
1702 list = xmalloc( sizeof(*list) );
1703 list_init( list );
1704 }
1705 list_add_tail( list, &iface->entry );
1706 return list;
1707 }
1708
1709 static ifref_t *make_ifref(type_t *iface)
1710 {
1711 ifref_t *l = xmalloc(sizeof(ifref_t));
1712 l->iface = iface;
1713 l->attrs = NULL;
1714 return l;
1715 }
1716
1717 var_list_t *append_var(var_list_t *list, var_t *var)
1718 {
1719 if (!var) return list;
1720 if (!list)
1721 {
1722 list = xmalloc( sizeof(*list) );
1723 list_init( list );
1724 }
1725 list_add_tail( list, &var->entry );
1726 return list;
1727 }
1728
1729 static var_list_t *append_var_list(var_list_t *list, var_list_t *vars)
1730 {
1731 if (!vars) return list;
1732 if (!list)
1733 {
1734 list = xmalloc( sizeof(*list) );
1735 list_init( list );
1736 }
1737 list_move_tail( list, vars );
1738 return list;
1739 }
1740
1741 var_t *make_var(char *name)
1742 {
1743 var_t *v = xmalloc(sizeof(var_t));
1744 v->name = name;
1745 init_declspec(&v->declspec, NULL);
1746 v->attrs = NULL;
1747 v->eval = NULL;
1748 init_loc_info(&v->loc_info);
1749 v->declonly = FALSE;
1750 return v;
1751 }
1752
1753 static var_t *copy_var(var_t *src, char *name, map_attrs_filter_t attr_filter)
1754 {
1755 var_t *v = xmalloc(sizeof(var_t));
1756 v->name = name;
1757 v->declspec = src->declspec;
1758 v->attrs = map_attrs(src->attrs, attr_filter);
1759 v->eval = src->eval;
1760 v->loc_info = src->loc_info;
1761 return v;
1762 }
1763
1764 static declarator_list_t *append_declarator(declarator_list_t *list, declarator_t *d)
1765 {
1766 if (!d) return list;
1767 if (!list) {
1768 list = xmalloc(sizeof(*list));
1769 list_init(list);
1770 }
1771 list_add_tail(list, &d->entry);
1772 return list;
1773 }
1774
1775 static declarator_t *make_declarator(var_t *var)
1776 {
1777 declarator_t *d = xmalloc(sizeof(*d));
1778 d->var = var ? var : make_var(NULL);
1779 d->type = NULL;
1780 d->qualifier = 0;
1781 d->bits = NULL;
1782 return d;
1783 }
1784
1785 static type_t *make_safearray(type_t *type)
1786 {
1787 decl_spec_t ds = {.type = type};
1788 ds.type = type_new_alias(&ds, "SAFEARRAY");
1789 return type_new_array(NULL, &ds, TRUE, 0, NULL, NULL);
1790 }
1791
1792 static typelib_t *make_library(const char *name, const attr_list_t *attrs)
1793 {
1794 typelib_t *typelib = xmalloc(sizeof(*typelib));
1795 memset(typelib, 0, sizeof(*typelib));
1796 typelib->name = xstrdup(name);
1797 typelib->attrs = attrs;
1798 list_init( &typelib->importlibs );
1799 return typelib;
1800 }
1801
1802 static int hash_ident(const char *name)
1803 {
1804 const char *p = name;
1805 int sum = 0;
1806 /* a simple sum hash is probably good enough */
1807 while (*p) {
1808 sum += *p;
1809 p++;
1810 }
1811 return sum & (HASHMAX-1);
1812 }
1813
1814 /***** type repository *****/
1815
1816 static struct namespace *find_sub_namespace(struct namespace *namespace, const char *name)
1817 {
1818 struct namespace *cur;
1819
1820 LIST_FOR_EACH_ENTRY(cur, &namespace->children, struct namespace, entry) {
1821 if(!strcmp(cur->name, name))
1822 return cur;
1823 }
1824
1825 return NULL;
1826 }
1827
1828 static void push_namespace(const char *name)
1829 {
1830 struct namespace *namespace;
1831
1832 namespace = find_sub_namespace(current_namespace, name);
1833 if(!namespace) {
1834 namespace = xmalloc(sizeof(*namespace));
1835 namespace->name = xstrdup(name);
1836 namespace->parent = current_namespace;
1837 list_add_tail(&current_namespace->children, &namespace->entry);
1838 list_init(&namespace->children);
1839 memset(namespace->type_hash, 0, sizeof(namespace->type_hash));
1840 }
1841
1842 current_namespace = namespace;
1843 }
1844
1845 static void pop_namespace(const char *name)
1846 {
1847 assert(!strcmp(current_namespace->name, name) && current_namespace->parent);
1848 current_namespace = current_namespace->parent;
1849 }
1850
1851 struct rtype {
1852 const char *name;
1853 type_t *type;
1854 int t;
1855 struct rtype *next;
1856 };
1857
1858 type_t *reg_type(type_t *type, const char *name, struct namespace *namespace, int t)
1859 {
1860 struct rtype *nt;
1861 int hash;
1862 if (!name) {
1863 error_loc("registering named type without name\n");
1864 return type;
1865 }
1866 if (!namespace)
1867 namespace = &global_namespace;
1868 hash = hash_ident(name);
1869 nt = xmalloc(sizeof(struct rtype));
1870 nt->name = name;
1871 if (is_global_namespace(namespace))
1872 type->c_name = name;
1873 else
1874 type->c_name = format_namespace(namespace, "__x_", "_C", name);
1875 nt->type = type;
1876 nt->t = t;
1877 nt->next = namespace->type_hash[hash];
1878 namespace->type_hash[hash] = nt;
1879 return type;
1880 }
1881
1882 static type_t *reg_typedefs(decl_spec_t *decl_spec, declarator_list_t *decls, attr_list_t *attrs)
1883 {
1884 declarator_t *decl;
1885 type_t *type = decl_spec->type;
1886
1887 if (is_attr(attrs, ATTR_UUID) && !is_attr(attrs, ATTR_PUBLIC))
1888 attrs = append_attr( attrs, make_attr(ATTR_PUBLIC) );
1889
1890 /* We must generate names for tagless enum, struct or union.
1891 Typedef-ing a tagless enum, struct or union means we want the typedef
1892 to be included in a library hence the public attribute. */
1893 if (type_get_type_detect_alias(type) == TYPE_ENUM ||
1894 type_get_type_detect_alias(type) == TYPE_STRUCT ||
1895 type_get_type_detect_alias(type) == TYPE_UNION ||
1896 type_get_type_detect_alias(type) == TYPE_ENCAPSULATED_UNION)
1897 {
1898 if (!type->name)
1899 {
1900 type->name = gen_name();
1901 if (!is_attr(attrs, ATTR_PUBLIC))
1902 attrs = append_attr(attrs, make_attr(ATTR_PUBLIC));
1903 }
1904
1905 /* replace existing attributes when generating a typelib */
1906 if (do_typelib)
1907 type->attrs = attrs;
1908 }
1909
1910 LIST_FOR_EACH_ENTRY( decl, decls, declarator_t, entry )
1911 {
1912
1913 if (decl->var->name) {
1914 type_t *cur;
1915 var_t *name;
1916
1917 cur = find_type(decl->var->name, current_namespace, 0);
1918
1919 /*
1920 * MIDL allows shadowing types that are declared in imported files.
1921 * We don't throw an error in this case and instead add a new type
1922 * (which is earlier on the list in hash table, so it will be used
1923 * instead of shadowed type).
1924 *
1925 * FIXME: We may consider string separated type tables for each input
1926 * for cleaner solution.
1927 */
1928 if (cur && input_name == cur->loc_info.input_name)
1929 error_loc("%s: redefinition error; original definition was at %s:%d\n",
1930 cur->name, cur->loc_info.input_name,
1931 cur->loc_info.line_number);
1932
1933 name = declare_var(attrs, decl_spec, decl, 0);
1934 cur = type_new_alias(&name->declspec, name->name);
1935 cur->attrs = attrs;
1936
1937 reg_type(cur, cur->name, current_namespace, 0);
1938 }
1939 }
1940 return type;
1941 }
1942
1943 type_t *find_type(const char *name, struct namespace *namespace, int t)
1944 {
1945 struct rtype *cur;
1946
1947 if(namespace && namespace != &global_namespace) {
1948 for(cur = namespace->type_hash[hash_ident(name)]; cur; cur = cur->next) {
1949 if(cur->t == t && !strcmp(cur->name, name))
1950 return cur->type;
1951 }
1952 }
1953 for(cur = global_namespace.type_hash[hash_ident(name)]; cur; cur = cur->next) {
1954 if(cur->t == t && !strcmp(cur->name, name))
1955 return cur->type;
1956 }
1957 return NULL;
1958 }
1959
1960 static type_t *find_type_or_error(const char *name, int t)
1961 {
1962 type_t *type = find_type(name, NULL, t);
1963 if (!type) {
1964 error_loc("type '%s' not found\n", name);
1965 return NULL;
1966 }
1967 return type;
1968 }
1969
1970 static type_t *find_type_or_error2(char *name, int t)
1971 {
1972 type_t *tp = find_type_or_error(name, t);
1973 free(name);
1974 return tp;
1975 }
1976
1977 int is_type(const char *name)
1978 {
1979 return find_type(name, current_namespace, 0) != NULL;
1980 }
1981
1982 type_t *get_type(enum type_type type, char *name, struct namespace *namespace, int t)
1983 {
1984 type_t *tp;
1985 if (!namespace)
1986 namespace = &global_namespace;
1987 if (name) {
1988 tp = find_type(name, namespace, t);
1989 if (tp) {
1990 free(name);
1991 return tp;
1992 }
1993 }
1994 tp = make_type(type);
1995 tp->name = name;
1996 tp->namespace = namespace;
1997 if (!name) return tp;
1998 return reg_type(tp, name, namespace, t);
1999 }
2000
2001 /***** constant repository *****/
2002
2003 struct rconst {
2004 char *name;
2005 var_t *var;
2006 struct rconst *next;
2007 };
2008
2009 struct rconst *const_hash[HASHMAX];
2010
2011 static var_t *reg_const(var_t *var)
2012 {
2013 struct rconst *nc;
2014 int hash;
2015 if (!var->name) {
2016 error_loc("registering constant without name\n");
2017 return var;
2018 }
2019 hash = hash_ident(var->name);
2020 nc = xmalloc(sizeof(struct rconst));
2021 nc->name = var->name;
2022 nc->var = var;
2023 nc->next = const_hash[hash];
2024 const_hash[hash] = nc;
2025 return var;
2026 }
2027
2028 var_t *find_const(const char *name, int f)
2029 {
2030 struct rconst *cur = const_hash[hash_ident(name)];
2031 while (cur && strcmp(cur->name, name))
2032 cur = cur->next;
2033 if (!cur) {
2034 if (f) error_loc("constant '%s' not found\n", name);
2035 return NULL;
2036 }
2037 return cur->var;
2038 }
2039
2040 char *gen_name(void)
2041 {
2042 static unsigned long n = 0;
2043 static const char *file_id;
2044
2045 if (! file_id)
2046 {
2047 char *dst = dup_basename(input_idl_name, ".idl");
2048 file_id = dst;
2049
2050 for (; *dst; ++dst)
2051 if (! isalnum((unsigned char) *dst))
2052 *dst = '_';
2053 }
2054 return strmake("__WIDL_%s_generated_name_%08lX", file_id, n++);
2055 }
2056
2057 struct allowed_attr
2058 {
2059 unsigned int dce_compatible : 1;
2060 unsigned int acf : 1;
2061 unsigned int on_interface : 1;
2062 unsigned int on_function : 1;
2063 unsigned int on_arg : 1;
2064 unsigned int on_type : 1;
2065 unsigned int on_enum : 1;
2066 unsigned int on_struct : 2;
2067 unsigned int on_union : 1;
2068 unsigned int on_field : 1;
2069 unsigned int on_library : 1;
2070 unsigned int on_dispinterface : 1;
2071 unsigned int on_module : 1;
2072 unsigned int on_coclass : 1;
2073 const char *display_name;
2074 };
2075
2076 struct allowed_attr allowed_attr[] =
2077 {
2078 /* attr { D ACF I Fn ARG T En St Un Fi L DI M C <display name> } */
2079 /* ATTR_AGGREGATABLE */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "aggregatable" },
2080 /* ATTR_ANNOTATION */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "annotation" },
2081 /* ATTR_APPOBJECT */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "appobject" },
2082 /* ATTR_ASYNC */ { 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "async" },
2083 /* ATTR_ASYNCUUID */ { 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, "async_uuid" },
2084 /* ATTR_AUTO_HANDLE */ { 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "auto_handle" },
2085 /* ATTR_BINDABLE */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "bindable" },
2086 /* ATTR_BROADCAST */ { 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "broadcast" },
2087 /* ATTR_CALLAS */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "call_as" },
2088 /* ATTR_CALLCONV */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL },
2089 /* ATTR_CASE */ { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, "case" },
2090 /* ATTR_CODE */ { 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "code" },
2091 /* ATTR_COMMSTATUS */ { 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "comm_status" },
2092 /* ATTR_CONTEXTHANDLE */ { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "context_handle" },
2093 /* ATTR_CONTROL */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, "control" },
2094 /* ATTR_DECODE */ { 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "decode" },
2095 /* ATTR_DEFAULT */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, "default" },
2096 /* ATTR_DEFAULTBIND */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "defaultbind" },
2097 /* ATTR_DEFAULTCOLLELEM */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "defaultcollelem" },
2098 /* ATTR_DEFAULTVALUE */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "defaultvalue" },
2099 /* ATTR_DEFAULTVTABLE */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "defaultvtable" },
2100 /* ATTR_DISABLECONSISTENCYCHECK */{ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "disable_consistency_check" },
2101 /* ATTR_DISPINTERFACE */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL },
2102 /* ATTR_DISPLAYBIND */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "displaybind" },
2103 /* ATTR_DLLNAME */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, "dllname" },
2104 /* ATTR_DUAL */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "dual" },
2105 /* ATTR_ENABLEALLOCATE */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "enable_allocate" },
2106 /* ATTR_ENCODE */ { 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "encode" },
2107 /* ATTR_ENDPOINT */ { 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "endpoint" },
2108 /* ATTR_ENTRY */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "entry" },
2109 /* ATTR_EXPLICIT_HANDLE */ { 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "explicit_handle" },
2110 /* ATTR_FAULTSTATUS */ { 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "fault_status" },
2111 /* ATTR_FORCEALLOCATE */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "force_allocate" },
2112 /* ATTR_HANDLE */ { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "handle" },
2113 /* ATTR_HELPCONTEXT */ { 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, "helpcontext" },
2114 /* ATTR_HELPFILE */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, "helpfile" },
2115 /* ATTR_HELPSTRING */ { 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, "helpstring" },
2116 /* ATTR_HELPSTRINGCONTEXT */ { 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, "helpstringcontext" },
2117 /* ATTR_HELPSTRINGDLL */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, "helpstringdll" },
2118 /* ATTR_HIDDEN */ { 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, "hidden" },
2119 /* ATTR_ID */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, "id" },
2120 /* ATTR_IDEMPOTENT */ { 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "idempotent" },
2121 /* ATTR_IGNORE */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, "ignore" },
2122 /* ATTR_IIDIS */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, "iid_is" },
2123 /* ATTR_IMMEDIATEBIND */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "immediatebind" },
2124 /* ATTR_IMPLICIT_HANDLE */ { 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "implicit_handle" },
2125 /* ATTR_IN */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "in" },
2126 /* ATTR_INPUTSYNC */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "inputsync" },
2127 /* ATTR_LENGTHIS */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, "length_is" },
2128 /* ATTR_LIBLCID */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, "lcid" },
2129 /* ATTR_LICENSED */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "licensed" },
2130 /* ATTR_LOCAL */ { 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "local" },
2131 /* ATTR_MAYBE */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "maybe" },
2132 /* ATTR_MESSAGE */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "message" },
2133 /* ATTR_NOCODE */ { 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "nocode" },
2134 /* ATTR_NONBROWSABLE */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "nonbrowsable" },
2135 /* ATTR_NONCREATABLE */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "noncreatable" },
2136 /* ATTR_NONEXTENSIBLE */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "nonextensible" },
2137 /* ATTR_NOTIFY */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "notify" },
2138 /* ATTR_NOTIFYFLAG */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "notify_flag" },
2139 /* ATTR_OBJECT */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "object" },
2140 /* ATTR_ODL */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, "odl" },
2141 /* ATTR_OLEAUTOMATION */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "oleautomation" },
2142 /* ATTR_OPTIMIZE */ { 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "optimize" },
2143 /* ATTR_OPTIONAL */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "optional" },
2144 /* ATTR_OUT */ { 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "out" },
2145 /* ATTR_PARAMLCID */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "lcid" },
2146 /* ATTR_PARTIALIGNORE */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "partial_ignore" },
2147 /* ATTR_POINTERDEFAULT */ { 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "pointer_default" },
2148 /* ATTR_POINTERTYPE */ { 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, "ref, unique or ptr" },
2149 /* ATTR_PROGID */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "progid" },
2150 /* ATTR_PROPGET */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "propget" },
2151 /* ATTR_PROPPUT */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "propput" },
2152 /* ATTR_PROPPUTREF */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "propputref" },
2153 /* ATTR_PROXY */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "proxy" },
2154 /* ATTR_PUBLIC */ { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "public" },
2155 /* ATTR_RANGE */ { 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, "range" },
2156 /* ATTR_READONLY */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, "readonly" },
2157 /* ATTR_REPRESENTAS */ { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "represent_as" },
2158 /* ATTR_REQUESTEDIT */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "requestedit" },
2159 /* ATTR_RESTRICTED */ { 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, "restricted" },
2160 /* ATTR_RETVAL */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "retval" },
2161 /* ATTR_SIZEIS */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, "size_is" },
2162 /* ATTR_SOURCE */ { 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, "source" },
2163 /* ATTR_STRICTCONTEXTHANDLE */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "strict_context_handle" },
2164 /* ATTR_STRING */ { 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, "string" },
2165 /* ATTR_SWITCHIS */ { 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, "switch_is" },
2166 /* ATTR_SWITCHTYPE */ { 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, "switch_type" },
2167 /* ATTR_THREADING */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "threading" },
2168 /* ATTR_TRANSMITAS */ { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "transmit_as" },
2169 /* ATTR_UIDEFAULT */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "uidefault" },
2170 /* ATTR_USESGETLASTERROR */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "usesgetlasterror" },
2171 /* ATTR_USERMARSHAL */ { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "user_marshal" },
2172 /* ATTR_UUID */ { 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, "uuid" },
2173 /* ATTR_V1ENUM */ { 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, "v1_enum" },
2174 /* ATTR_VARARG */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "vararg" },
2175 /* ATTR_VERSION */ { 1, 0, 1, 0, 0, 1, 1, 2, 0, 0, 1, 0, 0, 1, "version" },
2176 /* ATTR_VIPROGID */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "vi_progid" },
2177 /* ATTR_WIREMARSHAL */ { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "wire_marshal" },
2178 };
2179
2180 const char *get_attr_display_name(enum attr_type type)
2181 {
2182 return allowed_attr[type].display_name;
2183 }
2184
2185 static attr_list_t *check_iface_attrs(const char *name, attr_list_t *attrs)
2186 {
2187 const attr_t *attr;
2188 if (!attrs) return attrs;
2189 LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
2190 {
2191 if (!allowed_attr[attr->type].on_interface)
2192 error_loc("inapplicable attribute %s for interface %s\n",
2193 allowed_attr[attr->type].display_name, name);
2194 if (attr->type == ATTR_IMPLICIT_HANDLE)
2195 {
2196 const var_t *var = attr->u.pval;
2197 if (type_get_type( var->declspec.type) == TYPE_BASIC &&
2198 type_basic_get_type( var->declspec.type ) == TYPE_BASIC_HANDLE)
2199 continue;
2200 if (is_aliaschain_attr( var->declspec.type, ATTR_HANDLE ))
2201 continue;
2202 error_loc("attribute %s requires a handle type in interface %s\n",
2203 allowed_attr[attr->type].display_name, name);
2204 }
2205 }
2206 return attrs;
2207 }
2208
2209 static attr_list_t *check_function_attrs(const char *name, attr_list_t *attrs)
2210 {
2211 const attr_t *attr;
2212 if (!attrs) return attrs;
2213 LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
2214 {
2215 if (!allowed_attr[attr->type].on_function)
2216 error_loc("inapplicable attribute %s for function %s\n",
2217 allowed_attr[attr->type].display_name, name);
2218 }
2219 return attrs;
2220 }
2221
2222 static void check_arg_attrs(const var_t *arg)
2223 {
2224 const attr_t *attr;
2225
2226 if (arg->attrs)
2227 {
2228 LIST_FOR_EACH_ENTRY(attr, arg->attrs, const attr_t, entry)
2229 {
2230 if (!allowed_attr[attr->type].on_arg)
2231 error_loc("inapplicable attribute %s for argument %s\n",
2232 allowed_attr[attr->type].display_name, arg->name);
2233 }
2234 }
2235 }
2236
2237 static attr_list_t *check_typedef_attrs(attr_list_t *attrs)
2238 {
2239 const attr_t *attr;
2240 if (!attrs) return attrs;
2241 LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
2242 {
2243 if (!allowed_attr[attr->type].on_type)
2244 error_loc("inapplicable attribute %s for typedef\n",
2245 allowed_attr[attr->type].display_name);
2246 }
2247 return attrs;
2248 }
2249
2250 static attr_list_t *check_enum_attrs(attr_list_t *attrs)
2251 {
2252 const attr_t *attr;
2253 if (!attrs) return attrs;
2254 LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
2255 {
2256 if (!allowed_attr[attr->type].on_enum)
2257 error_loc("inapplicable attribute %s for enum\n",
2258 allowed_attr[attr->type].display_name);
2259 }
2260 return attrs;
2261 }
2262
2263 static attr_list_t *check_struct_attrs(attr_list_t *attrs)
2264 {
2265 int mask = winrt_mode ? 3 : 1;
2266 const attr_t *attr;
2267 if (!attrs) return attrs;
2268 LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
2269 {
2270 if (!(allowed_attr[attr->type].on_struct & mask))
2271 error_loc("inapplicable attribute %s for struct\n",
2272 allowed_attr[attr->type].display_name);
2273 }
2274 return attrs;
2275 }
2276
2277 static attr_list_t *check_union_attrs(attr_list_t *attrs)
2278 {
2279 const attr_t *attr;
2280 if (!attrs) return attrs;
2281 LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
2282 {
2283 if (!allowed_attr[attr->type].on_union)
2284 error_loc("inapplicable attribute %s for union\n",
2285 allowed_attr[attr->type].display_name);
2286 }
2287 return attrs;
2288 }
2289
2290 static attr_list_t *check_field_attrs(const char *name, attr_list_t *attrs)
2291 {
2292 const attr_t *attr;
2293 if (!attrs) return attrs;
2294 LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
2295 {
2296 if (!allowed_attr[attr->type].on_field)
2297 error_loc("inapplicable attribute %s for field %s\n",
2298 allowed_attr[attr->type].display_name, name);
2299 }
2300 return attrs;
2301 }
2302
2303 static attr_list_t *check_library_attrs(const char *name, attr_list_t *attrs)
2304 {
2305 const attr_t *attr;
2306 if (!attrs) return attrs;
2307 LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
2308 {
2309 if (!allowed_attr[attr->type].on_library)
2310 error_loc("inapplicable attribute %s for library %s\n",
2311 allowed_attr[attr->type].display_name, name);
2312 }
2313 return attrs;
2314 }
2315
2316 static attr_list_t *check_dispiface_attrs(const char *name, attr_list_t *attrs)
2317 {
2318 const attr_t *attr;
2319 if (!attrs) return attrs;
2320 LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
2321 {
2322 if (!allowed_attr[attr->type].on_dispinterface)
2323 error_loc("inapplicable attribute %s for dispinterface %s\n",
2324 allowed_attr[attr->type].display_name, name);
2325 }
2326 return attrs;
2327 }
2328
2329 static attr_list_t *check_module_attrs(const char *name, attr_list_t *attrs)
2330 {
2331 const attr_t *attr;
2332 if (!attrs) return attrs;
2333 LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
2334 {
2335 if (!allowed_attr[attr->type].on_module)
2336 error_loc("inapplicable attribute %s for module %s\n",
2337 allowed_attr[attr->type].display_name, name);
2338 }
2339 return attrs;
2340 }
2341
2342 static attr_list_t *check_coclass_attrs(const char *name, attr_list_t *attrs)
2343 {
2344 const attr_t *attr;
2345 if (!attrs) return attrs;
2346 LIST_FOR_EACH_ENTRY(attr, attrs, const attr_t, entry)
2347 {
2348 if (!allowed_attr[attr->type].on_coclass)
2349 error_loc("inapplicable attribute %s for coclass %s\n",
2350 allowed_attr[attr->type].display_name, name);
2351 }
2352 return attrs;
2353 }
2354
2355 static int is_allowed_conf_type(const type_t *type)
2356 {
2357 switch (type_get_type(type))
2358 {
2359 case TYPE_ENUM:
2360 return TRUE;
2361 case TYPE_BASIC:
2362 switch (type_basic_get_type(type))
2363 {
2364 case TYPE_BASIC_INT8:
2365 case TYPE_BASIC_INT16:
2366 case TYPE_BASIC_INT32:
2367 case TYPE_BASIC_INT64:
2368 case TYPE_BASIC_INT:
2369 case TYPE_BASIC_LONG:
2370 case TYPE_BASIC_CHAR:
2371 case TYPE_BASIC_HYPER:
2372 case TYPE_BASIC_BYTE:
2373 case TYPE_BASIC_WCHAR:
2374 return TRUE;
2375 default:
2376 return FALSE;
2377 }
2378 case TYPE_ALIAS:
2379 /* shouldn't get here because of type_get_type call above */
2380 assert(0);
2381 /* fall through */
2382 case TYPE_STRUCT:
2383 case TYPE_UNION:
2384 case TYPE_ENCAPSULATED_UNION:
2385 case TYPE_ARRAY:
2386 case TYPE_POINTER:
2387 case TYPE_VOID:
2388 case TYPE_MODULE:
2389 case TYPE_COCLASS:
2390 case TYPE_FUNCTION:
2391 case TYPE_INTERFACE:
2392 case TYPE_BITFIELD:
2393 return FALSE;
2394 }
2395 return FALSE;
2396 }
2397
2398 static int is_ptr_guid_type(const type_t *type)
2399 {
2400 /* first, make sure it is a pointer to something */
2401 if (!is_ptr(type)) return FALSE;
2402
2403 /* second, make sure it is a pointer to something of size sizeof(GUID),
2404 * i.e. 16 bytes */
2405 return (type_memsize(type_pointer_get_ref_type(type)) == 16);
2406 }
2407
2408 static void check_conformance_expr_list(const char *attr_name, const var_t *arg, const type_t *container_type, expr_list_t *expr_list)
2409 {
2410 expr_t *dim;
2411 struct expr_loc expr_loc;
2412 expr_loc.v = arg;
2413 expr_loc.attr = attr_name;
2414 if (expr_list) LIST_FOR_EACH_ENTRY(dim, expr_list, expr_t, entry)
2415 {
2416 if (dim->type != EXPR_VOID)
2417 {
2418 const type_t *expr_type = expr_resolve_type(&expr_loc, container_type, dim);
2419 if (!is_allowed_conf_type(expr_type))
2420 error_loc_info(&arg->loc_info, "expression must resolve to integral type <= 32bits for attribute %s\n",
2421 attr_name);
2422 }
2423 }
2424 }
2425
2426 static void check_remoting_fields(const var_t *var, type_t *type);
2427
2428 /* checks that properties common to fields and arguments are consistent */
2429 static void check_field_common(const type_t *container_type,
2430 const char *container_name, const var_t *arg)
2431 {
2432 type_t *type = arg->declspec.type;
2433 int more_to_do;
2434 const char *container_type_name;
2435 const char *var_type;
2436
2437 switch (type_get_type(container_type))
2438 {
2439 case TYPE_STRUCT:
2440 container_type_name = "struct";
2441 var_type = "field";
2442 break;
2443 case TYPE_UNION:
2444 container_type_name = "union";
2445 var_type = "arm";
2446 break;
2447 case TYPE_ENCAPSULATED_UNION:
2448 container_type_name = "encapsulated union";
2449 var_type = "arm";
2450 break;
2451 case TYPE_FUNCTION:
2452 container_type_name = "function";
2453 var_type = "parameter";
2454 break;
2455 default:
2456 /* should be no other container types */
2457 assert(0);
2458 return;
2459 }
2460
2461 if (is_attr(arg->attrs, ATTR_LENGTHIS) &&
2462 (is_attr(arg->attrs, ATTR_STRING) || is_aliaschain_attr(arg->declspec.type, ATTR_STRING)))
2463 error_loc_info(&arg->loc_info,
2464 "string and length_is specified for argument %s are mutually exclusive attributes\n",
2465 arg->name);
2466
2467 if (is_attr(arg->attrs, ATTR_SIZEIS))
2468 {
2469 expr_list_t *size_is_exprs = get_attrp(arg->attrs, ATTR_SIZEIS);
2470 check_conformance_expr_list("size_is", arg, container_type, size_is_exprs);
2471 }
2472 if (is_attr(arg->attrs, ATTR_LENGTHIS))
2473 {
2474 expr_list_t *length_is_exprs = get_attrp(arg->attrs, ATTR_LENGTHIS);
2475 check_conformance_expr_list("length_is", arg, container_type, length_is_exprs);
2476 }
2477 if (is_attr(arg->attrs, ATTR_IIDIS))
2478 {
2479 struct expr_loc expr_loc;
2480 expr_t *expr = get_attrp(arg->attrs, ATTR_IIDIS);
2481 if (expr->type != EXPR_VOID)
2482 {
2483 const type_t *expr_type;
2484 expr_loc.v = arg;
2485 expr_loc.attr = "iid_is";
2486 expr_type = expr_resolve_type(&expr_loc, container_type, expr);
2487 if (!expr_type || !is_ptr_guid_type(expr_type))
2488 error_loc_info(&arg->loc_info, "expression must resolve to pointer to GUID type for attribute iid_is\n");
2489 }
2490 }
2491 if (is_attr(arg->attrs, ATTR_SWITCHIS))
2492 {
2493 struct expr_loc expr_loc;
2494 expr_t *expr = get_attrp(arg->attrs, ATTR_SWITCHIS);
2495 if (expr->type != EXPR_VOID)
2496 {
2497 const type_t *expr_type;
2498 expr_loc.v = arg;
2499 expr_loc.attr = "switch_is";
2500 expr_type = expr_resolve_type(&expr_loc, container_type, expr);
2501 if (!expr_type || !is_allowed_conf_type(expr_type))
2502 error_loc_info(&arg->loc_info, "expression must resolve to integral type <= 32bits for attribute %s\n",
2503 expr_loc.attr);
2504 }
2505 }
2506
2507 do
2508 {
2509 more_to_do = FALSE;
2510
2511 switch (typegen_detect_type(type, arg->attrs, TDT_IGNORE_STRINGS))
2512 {
2513 case TGT_STRUCT:
2514 case TGT_UNION:
2515 check_remoting_fields(arg, type);
2516 break;
2517 case TGT_INVALID:
2518 {
2519 const char *reason = "is invalid";
2520 switch (type_get_type(type))
2521 {
2522 case TYPE_VOID:
2523 reason = "cannot derive from void *";
2524 break;
2525 case TYPE_FUNCTION:
2526 reason = "cannot be a function pointer";
2527 break;
2528 case TYPE_BITFIELD:
2529 reason = "cannot be a bit-field";
2530 break;
2531 case TYPE_COCLASS:
2532 reason = "cannot be a class";
2533 break;
2534 case TYPE_INTERFACE:
2535 reason = "cannot be a non-pointer to an interface";
2536 break;
2537 case TYPE_MODULE:
2538 reason = "cannot be a module";
2539 break;
2540 default:
2541 break;
2542 }
2543 error_loc_info(&arg->loc_info, "%s \'%s\' of %s \'%s\' %s\n",
2544 var_type, arg->name, container_type_name, container_name, reason);
2545 break;
2546 }
2547 case TGT_CTXT_HANDLE:
2548 case TGT_CTXT_HANDLE_POINTER:
2549 if (type_get_type(container_type) != TYPE_FUNCTION)
2550 error_loc_info(&arg->loc_info,
2551 "%s \'%s\' of %s \'%s\' cannot be a context handle\n",
2552 var_type, arg->name, container_type_name,
2553 container_name);
2554 break;
2555 case TGT_STRING:
2556 {
2557 const type_t *t = type;
2558 while (is_ptr(t))
2559 t = type_pointer_get_ref_type(t);
2560 if (is_aliaschain_attr(t, ATTR_RANGE))
2561 warning_loc_info(&arg->loc_info, "%s: range not verified for a string of ranged types\n", arg->name);
2562 break;
2563 }
2564 case TGT_POINTER:
2565 type = type_pointer_get_ref_type(type);
2566 more_to_do = TRUE;
2567 break;
2568 case TGT_ARRAY:
2569 type = type_array_get_element_type(type);
2570 more_to_do = TRUE;
2571 break;
2572 case TGT_ENUM:
2573 type = type_get_real_type(type);
2574 if (!type_is_complete(type))
2575 {
2576 error_loc_info(&arg->loc_info, "undefined type declaration \"enum %s\"\n", type->name);
2577 }
2578 case TGT_USER_TYPE:
2579 case TGT_IFACE_POINTER:
2580 case TGT_BASIC:
2581 case TGT_RANGE:
2582 /* nothing to do */
2583 break;
2584 }
2585 } while (more_to_do);
2586 }
2587
2588 static void check_remoting_fields(const var_t *var, type_t *type)
2589 {
2590 const var_t *field;
2591 const var_list_t *fields = NULL;
2592
2593 type = type_get_real_type(type);
2594
2595 if (type->checked)
2596 return;
2597
2598 type->checked = TRUE;
2599
2600 if (type_get_type(type) == TYPE_STRUCT)
2601 {
2602 if (type_is_complete(type))
2603 fields = type_struct_get_fields(type);
2604 else
2605 error_loc_info(&var->loc_info, "undefined type declaration \"struct %s\"\n", type->name);
2606 }
2607 else if (type_get_type(type) == TYPE_UNION || type_get_type(type) == TYPE_ENCAPSULATED_UNION)
2608 {
2609 if (type_is_complete(type))
2610 fields = type_union_get_cases(type);
2611 else
2612 error_loc_info(&var->loc_info, "undefined type declaration \"union %s\"\n", type->name);
2613 }
2614
2615 if (fields) LIST_FOR_EACH_ENTRY( field, fields, const var_t, entry )
2616 if (field->declspec.type) check_field_common(type, type->name, field);
2617 }
2618
2619 /* checks that arguments for a function make sense for marshalling and unmarshalling */
2620 static void check_remoting_args(const var_t *func)
2621 {
2622 const char *funcname = func->name;
2623 const var_t *arg;
2624
2625 if (!type_function_get_args(func->declspec.type))
2626 return;
2627
2628 LIST_FOR_EACH_ENTRY( arg, type_function_get_args(func->declspec.type), const var_t, entry )
2629 {
2630 const type_t *type = arg->declspec.type;
2631
2632 /* check that [out] parameters have enough pointer levels */
2633 if (is_attr(arg->attrs, ATTR_OUT))
2634 {
2635 switch (typegen_detect_type(type, arg->attrs, TDT_ALL_TYPES))
2636 {
2637 case TGT_BASIC:
2638 case TGT_ENUM:
2639 case TGT_RANGE:
2640 case TGT_STRUCT:
2641 case TGT_UNION:
2642 case TGT_CTXT_HANDLE:
2643 case TGT_USER_TYPE:
2644 error_loc_info(&arg->loc_info, "out parameter \'%s\' of function \'%s\' is not a pointer\n", arg->name, funcname);
2645 break;
2646 case TGT_IFACE_POINTER:
2647 error_loc_info(&arg->loc_info, "out interface pointer \'%s\' of function \'%s\' is not a double pointer\n", arg->name, funcname);
2648 break;
2649 case TGT_STRING:
2650 if (is_array(type))
2651 {
2652 /* needs conformance or fixed dimension */
2653 if (type_array_has_conformance(type) &&
2654 type_array_get_conformance(type)->type != EXPR_VOID) break;
2655 if (!type_array_has_conformance(type) && type_array_get_dim(type)) break;
2656 }
2657 if (is_attr( arg->attrs, ATTR_IN )) break;
2658 error_loc_info(&arg->loc_info, "out parameter \'%s\' of function \'%s\' cannot be an unsized string\n", arg->name, funcname);
2659 break;
2660 case TGT_INVALID:
2661 /* already error'd before we get here */
2662 case TGT_CTXT_HANDLE_POINTER:
2663 case TGT_POINTER:
2664 case TGT_ARRAY:
2665 /* OK */
2666 break;
2667 }
2668 }
2669
2670 check_field_common(func->declspec.type, funcname, arg);
2671 }
2672
2673 if (type_get_type(type_function_get_rettype(func->declspec.type)) != TYPE_VOID)
2674 {
2675 var_t var;
2676 var = *func;
2677 var.declspec.type = type_function_get_rettype(func->declspec.type);
2678 var.name = xstrdup("return value");
2679 check_field_common(func->declspec.type, funcname, &var);
2680 free(var.name);
2681 }
2682 }
2683
2684 static void add_explicit_handle_if_necessary(const type_t *iface, var_t *func)
2685 {
2686 unsigned char explicit_fc, implicit_fc;
2687
2688 /* check for a defined binding handle */
2689 if (!get_func_handle_var( iface, func, &explicit_fc, &implicit_fc ) || !explicit_fc)
2690 {
2691 /* no explicit handle specified so add
2692 * "[in] handle_t IDL_handle" as the first parameter to the
2693 * function */
2694 var_t *idl_handle = make_var(xstrdup("IDL_handle"));
2695 idl_handle->attrs = append_attr(NULL, make_attr(ATTR_IN));
2696 idl_handle->declspec.type = find_type_or_error("handle_t", 0);
2697 type_function_add_head_arg(func->declspec.type, idl_handle);
2698 }
2699 }
2700
2701 static void check_functions(const type_t *iface, int is_inside_library)
2702 {
2703 const statement_t *stmt;
2704 /* check for duplicates */
2705 if (is_attr(iface->attrs, ATTR_DISPINTERFACE))
2706 {
2707 var_list_t *methods = type_dispiface_get_methods(iface);
2708 var_t *func, *func_iter;
2709
2710 if (methods) LIST_FOR_EACH_ENTRY( func, methods, var_t, entry )
2711 {
2712 LIST_FOR_EACH_ENTRY( func_iter, methods, var_t, entry )
2713 {
2714 if (func == func_iter) break;
2715 if (strcmp(func->name, func_iter->name)) continue;
2716 if (is_attr(func->attrs, ATTR_PROPGET) != is_attr(func_iter->attrs, ATTR_PROPGET)) continue;
2717 if (is_attr(func->attrs, ATTR_PROPPUT) != is_attr(func_iter->attrs, ATTR_PROPPUT)) continue;
2718 if (is_attr(func->attrs, ATTR_PROPPUTREF) != is_attr(func_iter->attrs, ATTR_PROPPUTREF)) continue;
2719 error_loc_info(&func->loc_info, "duplicated function \'%s\'\n", func->name);
2720 }
2721 }
2722 }
2723 if (is_attr(iface->attrs, ATTR_EXPLICIT_HANDLE))
2724 {
2725 STATEMENTS_FOR_EACH_FUNC( stmt, type_iface_get_stmts(iface) )
2726 {
2727 var_t *func = stmt->u.var;
2728 add_explicit_handle_if_necessary(iface, func);
2729 }
2730 }
2731 if (!is_inside_library && !is_attr(iface->attrs, ATTR_LOCAL))
2732 {
2733 STATEMENTS_FOR_EACH_FUNC( stmt, type_iface_get_stmts(iface) )
2734 {
2735 const var_t *func = stmt->u.var;
2736 if (!is_attr(func->attrs, ATTR_LOCAL))
2737 check_remoting_args(func);
2738 }
2739 }
2740 }
2741
2742 static int async_iface_attrs(attr_list_t *attrs, const attr_t *attr)
2743 {
2744 switch(attr->type)
2745 {
2746 case ATTR_UUID:
2747 return 0;
2748 case ATTR_ASYNCUUID:
2749 append_attr(attrs, make_attrp(ATTR_UUID, attr->u.pval));
2750 return 0;
2751 default:
2752 return 1;
2753 }
2754 }
2755
2756 static int arg_in_attrs(attr_list_t *attrs, const attr_t *attr)
2757 {
2758 return attr->type != ATTR_OUT && attr->type != ATTR_RETVAL;
2759 }
2760
2761 static int arg_out_attrs(attr_list_t *attrs, const attr_t *attr)
2762 {
2763 return attr->type != ATTR_IN;
2764 }
2765
2766 static void check_async_uuid(type_t *iface)
2767 {
2768 statement_list_t *stmts = NULL;
2769 statement_t *stmt;
2770 type_t *async_iface;
2771 type_t *inherit;
2772
2773 if (!is_attr(iface->attrs, ATTR_ASYNCUUID)) return;
2774
2775 inherit = type_iface_get_inherit(iface);
2776 if (inherit && strcmp(inherit->name, "IUnknown"))
2777 inherit = type_iface_get_async_iface(inherit);
2778 if (!inherit)
2779 error_loc("async_uuid applied to an interface with incompatible parent\n");
2780
2781 async_iface = get_type(TYPE_INTERFACE, strmake("Async%s", iface->name), iface->namespace, 0);
2782 async_iface->attrs = map_attrs(iface->attrs, async_iface_attrs);
2783
2784 STATEMENTS_FOR_EACH_FUNC( stmt, type_iface_get_stmts(iface) )
2785 {
2786 var_t *begin_func, *finish_func, *func = stmt->u.var, *arg;
2787 var_list_t *begin_args = NULL, *finish_args = NULL, *args;
2788
2789 args = type_function_get_args(func->declspec.type);
2790 if (args) LIST_FOR_EACH_ENTRY(arg, args, var_t, entry)
2791 {
2792 if (is_attr(arg->attrs, ATTR_IN) || !is_attr(arg->attrs, ATTR_OUT))
2793 begin_args = append_var(begin_args, copy_var(arg, strdup(arg->name), arg_in_attrs));
2794 if (is_attr(arg->attrs, ATTR_OUT))
2795 finish_args = append_var(finish_args, copy_var(arg, strdup(arg->name), arg_out_attrs));
2796 }
2797
2798 begin_func = copy_var(func, strmake("Begin_%s", func->name), NULL);
2799 begin_func->declspec.type = type_new_function(begin_args);
2800 begin_func->declspec.type->attrs = func->attrs;
2801 begin_func->declspec.type->details.function->retval = func->declspec.type->details.function->retval;
2802 stmts = append_statement(stmts, make_statement_declaration(begin_func));
2803
2804 finish_func = copy_var(func, strmake("Finish_%s", func->name), NULL);
2805 finish_func->declspec.type = type_new_function(finish_args);
2806 finish_func->declspec.type->attrs = func->attrs;
2807 finish_func->declspec.type->details.function->retval = func->declspec.type->details.function->retval;
2808 stmts = append_statement(stmts, make_statement_declaration(finish_func));
2809 }
2810
2811 type_interface_define(async_iface, inherit, stmts);
2812 iface->details.iface->async_iface = async_iface->details.iface->async_iface = async_iface;
2813 }
2814
2815 static void check_statements(const statement_list_t *stmts, int is_inside_library)
2816 {
2817 const statement_t *stmt;
2818
2819 if (stmts) LIST_FOR_EACH_ENTRY(stmt, stmts, const statement_t, entry)
2820 {
2821 switch(stmt->type) {
2822 case STMT_LIBRARY:
2823 check_statements(stmt->u.lib->stmts, TRUE);
2824 break;
2825 case STMT_TYPE:
2826 switch(type_get_type(stmt->u.type)) {
2827 case TYPE_INTERFACE:
2828 check_functions(stmt->u.type, is_inside_library);
2829 break;
2830 case TYPE_COCLASS:
2831 if(winrt_mode)
2832 error_loc("coclass is not allowed in Windows Runtime mode\n");
2833 break;
2834 default:
2835 break;
2836 }
2837 break;
2838 default:
2839 break;
2840 }
2841 }
2842 }
2843
2844 static void check_all_user_types(const statement_list_t *stmts)
2845 {
2846 const statement_t *stmt;
2847 const var_t *v;
2848
2849 if (stmts) LIST_FOR_EACH_ENTRY(stmt, stmts, const statement_t, entry)
2850 {
2851 if (stmt->type == STMT_LIBRARY)
2852 check_all_user_types(stmt->u.lib->stmts);
2853 else if (stmt->type == STMT_TYPE && type_get_type(stmt->u.type) == TYPE_INTERFACE &&
2854 !is_local(stmt->u.type->attrs))
2855 {
2856 const statement_t *stmt_func;
2857 STATEMENTS_FOR_EACH_FUNC(stmt_func, type_iface_get_stmts(stmt->u.type)) {
2858 const var_t *func = stmt_func->u.var;
2859 if (type_function_get_args(func->declspec.type))
2860 LIST_FOR_EACH_ENTRY( v, type_function_get_args(func->declspec.type), const var_t, entry )
2861 check_for_additional_prototype_types(v->declspec.type);
2862 check_for_additional_prototype_types(type_function_get_rettype(func->declspec.type));
2863 }
2864 }
2865 }
2866 }
2867
2868 int is_valid_uuid(const char *s)
2869 {
2870 int i;
2871
2872 for (i = 0; i < 36; ++i)
2873 if (i == 8 || i == 13 || i == 18 || i == 23)
2874 {
2875 if (s[i] != '-')
2876 return FALSE;
2877 }
2878 else
2879 if (!isxdigit(s[i]))
2880 return FALSE;
2881
2882 return s[i] == '\0';
2883 }
2884
2885 static statement_t *make_statement(enum statement_type type)
2886 {
2887 statement_t *stmt = xmalloc(sizeof(*stmt));
2888 stmt->type = type;
2889 return stmt;
2890 }
2891
2892 static statement_t *make_statement_type_decl(type_t *type)
2893 {
2894 statement_t *stmt = make_statement(STMT_TYPE);
2895 stmt->u.type = type;
2896 stmt->declonly = !type->defined;
2897 return stmt;
2898 }
2899
2900 static statement_t *make_statement_reference(type_t *type)
2901 {
2902 statement_t *stmt = make_statement(STMT_TYPEREF);
2903 stmt->u.type = type;
2904 return stmt;
2905 }
2906
2907 static statement_t *make_statement_declaration(var_t *var)
2908 {
2909 statement_t *stmt = make_statement(STMT_DECLARATION);
2910 stmt->u.var = var;
2911 if (var->declspec.stgclass == STG_EXTERN && var->eval)
2912 warning("'%s' initialised and declared extern\n", var->name);
2913 if (is_const_decl(var))
2914 {
2915 if (var->eval)
2916 reg_const(var);
2917 }
2918 else if (type_get_type(var->declspec.type) == TYPE_FUNCTION)
2919 check_function_attrs(var->name, var->attrs);
2920 else if (var->declspec.stgclass == STG_NONE || var->declspec.stgclass == STG_REGISTER)
2921 error_loc("instantiation of data is illegal\n");
2922 return stmt;
2923 }
2924
2925 static statement_t *make_statement_library(typelib_t *typelib)
2926 {
2927 statement_t *stmt = make_statement(STMT_LIBRARY);
2928 stmt->u.lib = typelib;
2929 return stmt;
2930 }
2931
2932 static statement_t *make_statement_pragma(const char *str)
2933 {
2934 statement_t *stmt = make_statement(STMT_PRAGMA);
2935 stmt->u.str = str;
2936 return stmt;
2937 }
2938
2939 static statement_t *make_statement_cppquote(const char *str)
2940 {
2941 statement_t *stmt = make_statement(STMT_CPPQUOTE);
2942 stmt->u.str = str;
2943 return stmt;
2944 }
2945
2946 static statement_t *make_statement_importlib(const char *str)
2947 {
2948 statement_t *stmt = make_statement(STMT_IMPORTLIB);
2949 stmt->u.str = str;
2950 return stmt;
2951 }
2952
2953 static statement_t *make_statement_import(const char *str)
2954 {
2955 statement_t *stmt = make_statement(STMT_IMPORT);
2956 stmt->u.str = str;
2957 return stmt;
2958 }
2959
2960 static statement_t *make_statement_module(type_t *type)
2961 {
2962 statement_t *stmt = make_statement(STMT_MODULE);
2963 stmt->u.type = type;
2964 return stmt;
2965 }
2966
2967 static statement_t *make_statement_typedef(declarator_list_t *decls, int declonly)
2968 {
2969 declarator_t *decl, *next;
2970 statement_t *stmt;
2971 type_list_t **type_list;
2972
2973 if (!decls) return NULL;
2974
2975 stmt = make_statement(STMT_TYPEDEF);
2976 stmt->u.type_list = NULL;
2977 type_list = &stmt->u.type_list;
2978 stmt->declonly = declonly;
2979
2980 LIST_FOR_EACH_ENTRY_SAFE( decl, next, decls, declarator_t, entry )
2981 {
2982 var_t *var = decl->var;
2983 type_t *type = find_type_or_error(var->name, 0);
2984 *type_list = xmalloc(sizeof(type_list_t));
2985 (*type_list)->type = type;
2986 (*type_list)->next = NULL;
2987
2988 type_list = &(*type_list)->next;
2989 free(decl);
2990 free(var);
2991 }
2992
2993 return stmt;
2994 }
2995
2996 static statement_list_t *append_statements(statement_list_t *l1, statement_list_t *l2)
2997 {
2998 if (!l2) return l1;
2999 if (!l1 || l1 == l2) return l2;
3000 list_move_tail (l1, l2);
3001 return l1;
3002 }
3003
3004 static attr_list_t *append_attribs(attr_list_t *l1, attr_list_t *l2)
3005 {
3006 if (!l2) return l1;
3007 if (!l1 || l1 == l2) return l2;
3008 list_move_tail (l1, l2);
3009 return l1;
3010 }
3011
3012 static statement_list_t *append_statement(statement_list_t *list, statement_t *stmt)
3013 {
3014 if (!stmt) return list;
3015 if (!list)
3016 {
3017 list = xmalloc( sizeof(*list) );
3018 list_init( list );
3019 }
3020 list_add_tail( list, &stmt->entry );
3021 return list;
3022 }
3023
3024 void init_loc_info(loc_info_t *i)
3025 {
3026 i->input_name = input_name ? input_name : "stdin";
3027 i->line_number = line_number;
3028 i->near_text = parser_text;
3029 }
3030
3031 static void check_def(const type_t *t)
3032 {
3033 if (t->defined)
3034 error_loc("%s: redefinition error; original definition was at %s:%d\n",
3035 t->name, t->loc_info.input_name, t->loc_info.line_number);
3036 }
Zebediah Figura's local tree