5 * Copyright 2002 Ove Kaaven
6 * Copyright 2006-2008 Robert Shearman
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.
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.
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
41 typedef
struct list typelist_t
;
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 attr_t
*make_custom_attr
(UUID
*id
, expr_t
*pval
);
62 static expr_list_t
*append_expr
(expr_list_t
*list
, expr_t
*expr
);
63 static var_t
*declare_var
(attr_list_t
*attrs
, decl_spec_t
*decl_spec
, declarator_t
*decl
, int top
);
64 static var_list_t
*set_var_types
(attr_list_t
*attrs
, decl_spec_t
*decl_spec
, declarator_list_t
*decls
);
65 static ifref_list_t
*append_ifref
(ifref_list_t
*list
, ifref_t
*iface
);
66 static ifref_t
*make_ifref
(type_t
*iface
);
67 static var_list_t
*append_var_list
(var_list_t
*list
, var_list_t
*vars
);
68 static declarator_list_t
*append_declarator
(declarator_list_t
*list
, declarator_t
*p
);
69 static declarator_t
*make_declarator
(var_t
*var
);
70 static type_t
*make_safearray
(type_t
*type
);
71 static typelib_t
*make_library
(const char *name
, const attr_list_t
*attrs
);
72 static void append_array
(declarator_t
*decl
, expr_t
*expr
);
73 static void append_chain_type
(declarator_t
*decl
, type_t
*type
, enum type_qualifier qual
);
74 static void append_chain_callconv
(type_t
*chain
, char *callconv
);
75 static warning_list_t
*append_warning
(warning_list_t
*, int);
77 static type_t
*reg_typedefs
(decl_spec_t
*decl_spec
, var_list_t
*names
, attr_list_t
*attrs
);
78 static type_t
*find_type_or_error
(const char *name
, int t
);
79 static type_t
*find_type_or_error2
(char *name
, int t
);
81 static var_t
*reg_const
(var_t
*var
);
83 static void push_namespace
(const char *name
);
84 static void pop_namespace
(const char *name
);
85 static void init_lookup_namespace
(const char *name
);
86 static void push_lookup_namespace
(const char *name
);
88 static void check_arg_attrs
(const var_t
*arg
);
89 static void check_statements
(const statement_list_t
*stmts
, int is_inside_library
);
90 static void check_all_user_types
(const statement_list_t
*stmts
);
91 static attr_list_t
*check_iface_attrs
(const char *name
, attr_list_t
*attrs
);
92 static attr_list_t
*check_function_attrs
(const char *name
, attr_list_t
*attrs
);
93 static attr_list_t
*check_typedef_attrs
(attr_list_t
*attrs
);
94 static attr_list_t
*check_enum_attrs
(attr_list_t
*attrs
);
95 static attr_list_t
*check_enum_member_attrs
(attr_list_t
*attrs
);
96 static attr_list_t
*check_struct_attrs
(attr_list_t
*attrs
);
97 static attr_list_t
*check_union_attrs
(attr_list_t
*attrs
);
98 static attr_list_t
*check_field_attrs
(const char *name
, attr_list_t
*attrs
);
99 static attr_list_t
*check_library_attrs
(const char *name
, attr_list_t
*attrs
);
100 static attr_list_t
*check_dispiface_attrs
(const char *name
, attr_list_t
*attrs
);
101 static attr_list_t
*check_module_attrs
(const char *name
, attr_list_t
*attrs
);
102 static attr_list_t
*check_coclass_attrs
(const char *name
, attr_list_t
*attrs
);
103 const char *get_attr_display_name
(enum attr_type type
);
104 static void add_explicit_handle_if_necessary
(const type_t
*iface
, var_t
*func
);
105 static void check_def
(const type_t
*t
);
107 static void check_async_uuid
(type_t
*iface
);
109 static statement_t
*make_statement
(enum statement_type type
);
110 static statement_t
*make_statement_type_decl
(type_t
*type
);
111 static statement_t
*make_statement_reference
(type_t
*type
);
112 static statement_t
*make_statement_declaration
(var_t
*var
);
113 static statement_t
*make_statement_library
(typelib_t
*typelib
);
114 static statement_t
*make_statement_pragma
(const char *str
);
115 static statement_t
*make_statement_cppquote
(const char *str
);
116 static statement_t
*make_statement_importlib
(const char *str
);
117 static statement_t
*make_statement_module
(type_t
*type
);
118 static statement_t
*make_statement_typedef
(var_list_t
*names
, int declonly
);
119 static statement_t
*make_statement_import
(const char *str
);
120 static statement_list_t
*append_statement
(statement_list_t
*list
, statement_t
*stmt
);
121 static statement_list_t
*append_statements
(statement_list_t
*, statement_list_t
*);
122 static attr_list_t
*append_attribs
(attr_list_t
*, attr_list_t
*);
124 static struct namespace global_namespace
= {
125 NULL
, NULL
, LIST_INIT
(global_namespace.entry
), LIST_INIT
(global_namespace.children
)
128 static struct namespace
*current_namespace
= &global_namespace
;
129 static struct namespace
*lookup_namespace
= &global_namespace
;
131 static typelib_t
*current_typelib
;
136 attr_list_t
*attr_list
;
137 str_list_t
*str_list
;
139 expr_list_t
*expr_list
;
142 var_list_t
*var_list
;
143 declarator_t
*declarator
;
144 declarator_list_t
*declarator_list
;
145 statement_t
*statement
;
146 statement_list_t
*stmt_list
;
148 warning_list_t
*warning_list
;
150 ifref_list_t
*ifref_list
;
156 struct _import_t
*import
;
157 struct _decl_spec_t
*declspec
;
158 enum storage_class stgclass
;
159 enum type_qualifier type_qualifier
;
160 enum function_specifier function_specifier
;
163 %token
<str
> aIDENTIFIER aPRAGMA
164 %token
<str
> aKNOWNTYPE aNAMESPACE
165 %token
<num
> aNUM aHEXNUM
167 %token
<str
> aSTRING aWSTRING aSQSTRING
172 %token EQUALITY INEQUALITY
173 %token GREATEREQUAL LESSEQUAL
174 %token LOGICALOR LOGICALAND
176 %token tAGGREGATABLE tALLNODES tALLOCATE tANNOTATION tAPPOBJECT tASYNC tASYNCUUID
177 %token tAUTOHANDLE tBINDABLE tBOOLEAN tBROADCAST tBYTE tBYTECOUNT
178 %token tCALLAS tCALLBACK tCASE tCDECL tCHAR tCOCLASS tCODE tCOMMSTATUS
179 %token tCONST tCONTEXTHANDLE tCONTEXTHANDLENOSERIALIZE
180 %token tCONTEXTHANDLESERIALIZE tCONTROL tCPPQUOTE
182 %token tDECODE tDEFAULT tDEFAULTBIND
183 %token tDEFAULTCOLLELEM
185 %token tDEFAULTVTABLE
186 %token tDISABLECONSISTENCYCHECK tDISPLAYBIND
187 %token tDISPINTERFACE
188 %token tDLLNAME tDONTFREE tDOUBLE tDUAL
189 %token tENABLEALLOCATE tENCODE tENDPOINT
190 %token tENTRY tENUM tERRORSTATUST
191 %token tEXPLICITHANDLE tEXTERN
193 %token tFASTCALL tFAULTSTATUS
194 %token tFLOAT tFORCEALLOCATE
197 %token tHELPCONTEXT tHELPFILE
198 %token tHELPSTRING tHELPSTRINGCONTEXT tHELPSTRINGDLL
200 %token tHYPER tID tIDEMPOTENT
201 %token tIGNORE tIIDIS
202 %token tIMMEDIATEBIND
203 %token tIMPLICITHANDLE
204 %token tIMPORT tIMPORTLIB
205 %token tIN tIN_LINE tINLINE
207 %token tINT tINT32 tINT3264 tINT64
210 %token tLENGTHIS tLIBRARY
211 %token tLICENSED tLOCAL
213 %token tMAYBE tMESSAGE
217 %token tNOCODE tNONBROWSABLE
219 %token tNONEXTENSIBLE
220 %token tNOTIFY tNOTIFYFLAG
222 %token tOBJECT tODL tOLEAUTOMATION
223 %token tOPTIMIZE tOPTIONAL
225 %token tPARTIALIGNORE tPASCAL
226 %token tPOINTERDEFAULT
227 %token tPRAGMA_WARNING
228 %token tPROGID tPROPERTIES
229 %token tPROPGET tPROPPUT tPROPPUTREF
233 %token tREADONLY tREF
234 %token tREGISTER tREPRESENTAS
240 %token tSIGNED tSINGLENODE
241 %token tSIZEIS tSIZEOF
246 %token tSTRICTCONTEXTHANDLE
247 %token tSTRING tSTRUCT
248 %token tSWITCH tSWITCHIS tSWITCHTYPE
249 %token tTHREADING tTRANSMITAS
252 %token tUIDEFAULT tUNION
255 %token tUSESGETLASTERROR tUSERMARSHAL tUUID
258 %token tVERSION tVIPROGID
260 %token tWCHAR tWIREMARSHAL
261 %token tAPARTMENT tNEUTRAL tSINGLE tFREE tBOTH
263 %type
<attr
> attribute acf_attribute
264 %type
<attr_list
> m_attributes attributes attrib_list
265 %type
<attr_list
> acf_attributes acf_attribute_list
266 %type
<str_list
> str_list
267 %type
<expr
> m_expr expr expr_const expr_int_const array m_bitfield
268 %type
<expr_list
> m_exprs
/* exprs expr_list */ expr_list_int_const
269 %type
<type
> interfacehdr
270 %type
<stgclass
> storage_cls_spec
271 %type
<type_qualifier
> type_qualifier m_type_qual_list
272 %type
<function_specifier
> function_specifier
273 %type
<declspec
> decl_spec decl_spec_no_type m_decl_spec_no_type
274 %type
<type
> inherit interface interfacedef interfacedec
275 %type
<type
> dispinterface dispinterfacehdr dispinterfacedef
276 %type
<type
> module modulehdr moduledef
277 %type
<str
> namespacedef
278 %type
<type
> base_type int_std
279 %type
<type
> enumdef structdef uniondef typedecl
280 %type
<type
> type qualified_seq qualified_type
281 %type
<ifref
> coclass_int
282 %type
<ifref_list
> coclass_ints
283 %type
<var
> arg ne_union_field union_field s_field case
enum enum_member declaration
285 %type
<var_list
> m_args arg_list args dispint_meths
286 %type
<var_list
> fields ne_union_fields cases enums enum_list dispint_props field
287 %type
<var
> m_ident ident
288 %type
<declarator
> declarator direct_declarator init_declarator struct_declarator
289 %type
<declarator
> m_any_declarator any_declarator any_declarator_no_direct any_direct_declarator
290 %type
<declarator
> m_abstract_declarator abstract_declarator abstract_declarator_no_direct abstract_direct_declarator
291 %type
<declarator_list
> declarator_list struct_declarator_list
292 %type
<type
> coclass coclasshdr coclassdef
293 %type
<num
> pointer_type threading_type version
294 %type
<str
> libraryhdr callconv cppquote importlib import t_ident
295 %type
<uuid
> uuid_string
296 %type
<import
> import_start
297 %type
<typelib
> library_start librarydef
298 %type
<statement
> statement typedef pragma_warning
299 %type
<stmt_list
> gbl_statements imp_statements int_statements
300 %type
<warning_list
> warnings
301 %type
<num
> allocate_option_list allocate_option
310 %left EQUALITY INEQUALITY
311 %left
'<' '>' LESSEQUAL GREATEREQUAL
315 %right
'!' '~' CAST PPTR POS NEG ADDRESSOF tSIZEOF
316 %left
'.' MEMBERPTR
'[' ']'
318 %define parse.
error verbose
322 input: gbl_statements m_acf
{ check_statements
($1, FALSE
);
323 check_all_user_types
($1);
330 write_typelib_regscript
($1);
332 write_local_stubs
($1);
336 m_acf: /* empty */ | aACF acf_statements
338 gbl_statements: { $$
= NULL
; }
339 | gbl_statements namespacedef
'{' { push_namespace
($2); } gbl_statements
'}'
340 { pop_namespace
($2); $$
= append_statements
($1, $5); }
341 | gbl_statements interfacedec
{ $$
= append_statement
($1, make_statement_reference
($2)); }
342 | gbl_statements interfacedef
{ $$
= append_statement
($1, make_statement_type_decl
($2)); }
343 | gbl_statements coclass
';' { $$
= $1;
344 reg_type
($2, $2->name
, current_namespace
, 0);
346 | gbl_statements coclassdef
{ $$
= append_statement
($1, make_statement_type_decl
($2));
347 reg_type
($2, $2->name
, current_namespace
, 0);
349 | gbl_statements moduledef
{ $$
= append_statement
($1, make_statement_module
($2)); }
350 | gbl_statements librarydef
{ $$
= append_statement
($1, make_statement_library
($2)); }
351 | gbl_statements statement
{ $$
= append_statement
($1, $2); }
354 imp_statements: { $$
= NULL
; }
355 | imp_statements interfacedec
{ $$
= append_statement
($1, make_statement_reference
($2)); }
356 | imp_statements namespacedef
'{' { push_namespace
($2); } imp_statements
'}'
357 { pop_namespace
($2); $$
= append_statements
($1, $5); }
358 | imp_statements interfacedef
{ $$
= append_statement
($1, make_statement_type_decl
($2)); }
359 | imp_statements coclass
';' { $$
= $1; reg_type
($2, $2->name
, current_namespace
, 0); }
360 | imp_statements coclassdef
{ $$
= append_statement
($1, make_statement_type_decl
($2));
361 reg_type
($2, $2->name
, current_namespace
, 0);
363 | imp_statements moduledef
{ $$
= append_statement
($1, make_statement_module
($2)); }
364 | imp_statements statement
{ $$
= append_statement
($1, $2); }
365 | imp_statements importlib
{ $$
= append_statement
($1, make_statement_importlib
($2)); }
366 | imp_statements librarydef
{ $$
= append_statement
($1, make_statement_library
($2)); }
369 int_statements: { $$
= NULL
; }
370 | int_statements statement
{ $$
= append_statement
($1, $2); }
378 cppquote
{ $$
= make_statement_cppquote
($1); }
379 | typedecl
';' { $$
= make_statement_type_decl
($1); }
380 | declaration
';' { $$
= make_statement_declaration
($1); }
381 | import
{ $$
= make_statement_import
($1); }
382 | typedef
';' { $$
= $1; }
383 | aPRAGMA
{ $$
= make_statement_pragma
($1); }
384 | pragma_warning
{ $$
= NULL
; }
387 pragma_warning: tPRAGMA_WARNING
'(' aIDENTIFIER
':' warnings
')'
391 result
= do_warning
($3, $5);
393 error_loc
("expected \"disable\" or \"enable\"\n");
398 aNUM
{ $$
= append_warning
(NULL
, $1); }
399 | warnings aNUM
{ $$
= append_warning
($1, $2); }
404 | tENUM aIDENTIFIER
{ $$
= type_new_enum
($2, current_namespace
, FALSE
, NULL
); }
406 | tSTRUCT aIDENTIFIER
{ $$
= type_new_struct
($2, current_namespace
, FALSE
, NULL
); }
408 | tUNION aIDENTIFIER
{ $$
= type_new_nonencapsulated_union
($2, FALSE
, NULL
); }
409 | attributes enumdef
{ $$
= $2; $$
->attrs
= check_enum_attrs
($1); }
410 | attributes structdef
{ $$
= $2; $$
->attrs
= check_struct_attrs
($1); }
411 | attributes uniondef
{ $$
= $2; $$
->attrs
= check_union_attrs
($1); }
414 cppquote: tCPPQUOTE
'(' aSTRING
')' { $$
= $3; }
416 import_start: tIMPORT aSTRING
';' { assert
(yychar == YYEMPTY
);
417 $$
= xmalloc
(sizeof
(struct _import_t
));
419 $$
->import_performed
= do_import
($2);
420 if
(!$$
->import_performed
) yychar = aEOF
;
424 import: import_start imp_statements aEOF
{ $$
= $1->name
;
425 if
($1->import_performed
) pop_import
();
430 importlib: tIMPORTLIB
'(' aSTRING
')'
431 semicolon_opt
{ $$
= $3; if
(!parse_only
) add_importlib
($3, current_typelib
); }
434 libraryhdr: tLIBRARY aIDENTIFIER
{ $$
= $2; }
435 | tLIBRARY aKNOWNTYPE
{ $$
= $2; }
437 library_start: attributes libraryhdr
'{' { $$
= make_library
($2, check_library_attrs
($2, $1));
438 if
(!parse_only
&& do_typelib
) current_typelib
= $$
;
441 librarydef: library_start imp_statements
'}'
442 semicolon_opt
{ $$
= $1; $$
->stmts
= $2; }
445 m_args: { $$
= NULL
; }
449 arg_list: arg
{ check_arg_attrs
($1); $$
= append_var
( NULL
, $1 ); }
450 | arg_list
',' arg
{ check_arg_attrs
($3); $$
= append_var
( $1, $3 ); }
454 | arg_list
',' ELLIPSIS
{ $$
= append_var
( $1, make_var
(strdup
("...")) ); }
457 /* split into two rules to get bison to resolve a tVOID conflict */
458 arg: attributes decl_spec m_any_declarator
{ if
($2->stgclass
!= STG_NONE
&& $2->stgclass
!= STG_REGISTER
)
459 error_loc
("invalid storage class for function parameter\n");
460 $$
= declare_var
($1, $2, $3, TRUE
);
463 | decl_spec m_any_declarator
{ if
($1->stgclass
!= STG_NONE
&& $1->stgclass
!= STG_REGISTER
)
464 error_loc
("invalid storage class for function parameter\n");
465 $$
= declare_var
(NULL
, $1, $2, TRUE
);
470 array: '[' expr
']' { $$
= $2;
471 if
(!$$
->is_const || $$
->cval
<= 0)
472 error_loc
("array dimension is not a positive integer constant\n");
474 |
'[' '*' ']' { $$
= make_expr
(EXPR_VOID
); }
475 |
'[' ']' { $$
= make_expr
(EXPR_VOID
); }
478 m_attributes: { $$
= NULL
; }
483 '[' attrib_list
']' { $$
= $2; }
486 attrib_list: attribute
{ $$
= append_attr
( NULL
, $1 ); }
487 | attrib_list
',' attribute
{ $$
= append_attr
( $1, $3 ); }
488 | attrib_list
']' '[' attribute
{ $$
= append_attr
( $1, $4 ); }
491 str_list: aSTRING
{ $$
= append_str
( NULL
, $1 ); }
492 | str_list
',' aSTRING
{ $$
= append_str
( $1, $3 ); }
495 attribute: { $$
= NULL
; }
496 | tAGGREGATABLE
{ $$
= make_attr
(ATTR_AGGREGATABLE
); }
497 | tANNOTATION
'(' aSTRING
')' { $$
= make_attrp
(ATTR_ANNOTATION
, $3); }
498 | tAPPOBJECT
{ $$
= make_attr
(ATTR_APPOBJECT
); }
499 | tASYNC
{ $$
= make_attr
(ATTR_ASYNC
); }
500 | tAUTOHANDLE
{ $$
= make_attr
(ATTR_AUTO_HANDLE
); }
501 | tBINDABLE
{ $$
= make_attr
(ATTR_BINDABLE
); }
502 | tBROADCAST
{ $$
= make_attr
(ATTR_BROADCAST
); }
503 | tCALLAS
'(' ident
')' { $$
= make_attrp
(ATTR_CALLAS
, $3); }
504 | tCASE
'(' expr_list_int_const
')' { $$
= make_attrp
(ATTR_CASE
, $3); }
505 | tCODE
{ $$
= make_attr
(ATTR_CODE
); }
506 | tCOMMSTATUS
{ $$
= make_attr
(ATTR_COMMSTATUS
); }
507 | tCONTEXTHANDLE
{ $$
= make_attrv
(ATTR_CONTEXTHANDLE
, 0); }
508 | tCONTEXTHANDLENOSERIALIZE
{ $$
= make_attrv
(ATTR_CONTEXTHANDLE
, 0); /* RPC_CONTEXT_HANDLE_DONT_SERIALIZE */ }
509 | tCONTEXTHANDLESERIALIZE
{ $$
= make_attrv
(ATTR_CONTEXTHANDLE
, 0); /* RPC_CONTEXT_HANDLE_SERIALIZE */ }
510 | tCONTROL
{ $$
= make_attr
(ATTR_CONTROL
); }
511 | tCUSTOM
'(' uuid_string
',' expr_const
')' { $$
= make_custom_attr
($3, $5); }
512 | tDECODE
{ $$
= make_attr
(ATTR_DECODE
); }
513 | tDEFAULT
{ $$
= make_attr
(ATTR_DEFAULT
); }
514 | tDEFAULTBIND
{ $$
= make_attr
(ATTR_DEFAULTBIND
); }
515 | tDEFAULTCOLLELEM
{ $$
= make_attr
(ATTR_DEFAULTCOLLELEM
); }
516 | tDEFAULTVALUE
'(' expr_const
')' { $$
= make_attrp
(ATTR_DEFAULTVALUE
, $3); }
517 | tDEFAULTVTABLE
{ $$
= make_attr
(ATTR_DEFAULTVTABLE
); }
518 | tDISABLECONSISTENCYCHECK
{ $$
= make_attr
(ATTR_DISABLECONSISTENCYCHECK
); }
519 | tDISPLAYBIND
{ $$
= make_attr
(ATTR_DISPLAYBIND
); }
520 | tDLLNAME
'(' aSTRING
')' { $$
= make_attrp
(ATTR_DLLNAME
, $3); }
521 | tDUAL
{ $$
= make_attr
(ATTR_DUAL
); }
522 | tENABLEALLOCATE
{ $$
= make_attr
(ATTR_ENABLEALLOCATE
); }
523 | tENCODE
{ $$
= make_attr
(ATTR_ENCODE
); }
524 | tENDPOINT
'(' str_list
')' { $$
= make_attrp
(ATTR_ENDPOINT
, $3); }
525 | tENTRY
'(' expr_const
')' { $$
= make_attrp
(ATTR_ENTRY
, $3); }
526 | tEXPLICITHANDLE
{ $$
= make_attr
(ATTR_EXPLICIT_HANDLE
); }
527 | tFAULTSTATUS
{ $$
= make_attr
(ATTR_FAULTSTATUS
); }
528 | tFORCEALLOCATE
{ $$
= make_attr
(ATTR_FORCEALLOCATE
); }
529 | tHANDLE
{ $$
= make_attr
(ATTR_HANDLE
); }
530 | tHELPCONTEXT
'(' expr_int_const
')' { $$
= make_attrp
(ATTR_HELPCONTEXT
, $3); }
531 | tHELPFILE
'(' aSTRING
')' { $$
= make_attrp
(ATTR_HELPFILE
, $3); }
532 | tHELPSTRING
'(' aSTRING
')' { $$
= make_attrp
(ATTR_HELPSTRING
, $3); }
533 | tHELPSTRINGCONTEXT
'(' expr_int_const
')' { $$
= make_attrp
(ATTR_HELPSTRINGCONTEXT
, $3); }
534 | tHELPSTRINGDLL
'(' aSTRING
')' { $$
= make_attrp
(ATTR_HELPSTRINGDLL
, $3); }
535 | tHIDDEN
{ $$
= make_attr
(ATTR_HIDDEN
); }
536 | tID
'(' expr_int_const
')' { $$
= make_attrp
(ATTR_ID
, $3); }
537 | tIDEMPOTENT
{ $$
= make_attr
(ATTR_IDEMPOTENT
); }
538 | tIGNORE
{ $$
= make_attr
(ATTR_IGNORE
); }
539 | tIIDIS
'(' expr
')' { $$
= make_attrp
(ATTR_IIDIS
, $3); }
540 | tIMMEDIATEBIND
{ $$
= make_attr
(ATTR_IMMEDIATEBIND
); }
541 | tIMPLICITHANDLE
'(' arg
')' { $$
= make_attrp
(ATTR_IMPLICIT_HANDLE
, $3); }
542 | tIN
{ $$
= make_attr
(ATTR_IN
); }
543 | tINPUTSYNC
{ $$
= make_attr
(ATTR_INPUTSYNC
); }
544 | tLENGTHIS
'(' m_exprs
')' { $$
= make_attrp
(ATTR_LENGTHIS
, $3); }
545 | tLCID
'(' expr_int_const
')' { $$
= make_attrp
(ATTR_LIBLCID
, $3); }
546 | tLCID
{ $$
= make_attr
(ATTR_PARAMLCID
); }
547 | tLICENSED
{ $$
= make_attr
(ATTR_LICENSED
); }
548 | tLOCAL
{ $$
= make_attr
(ATTR_LOCAL
); }
549 | tMAYBE
{ $$
= make_attr
(ATTR_MAYBE
); }
550 | tMESSAGE
{ $$
= make_attr
(ATTR_MESSAGE
); }
551 | tNOCODE
{ $$
= make_attr
(ATTR_NOCODE
); }
552 | tNONBROWSABLE
{ $$
= make_attr
(ATTR_NONBROWSABLE
); }
553 | tNONCREATABLE
{ $$
= make_attr
(ATTR_NONCREATABLE
); }
554 | tNONEXTENSIBLE
{ $$
= make_attr
(ATTR_NONEXTENSIBLE
); }
555 | tNOTIFY
{ $$
= make_attr
(ATTR_NOTIFY
); }
556 | tNOTIFYFLAG
{ $$
= make_attr
(ATTR_NOTIFYFLAG
); }
557 | tOBJECT
{ $$
= make_attr
(ATTR_OBJECT
); }
558 | tODL
{ $$
= make_attr
(ATTR_ODL
); }
559 | tOLEAUTOMATION
{ $$
= make_attr
(ATTR_OLEAUTOMATION
); }
560 | tOPTIMIZE
'(' aSTRING
')' { $$
= make_attrp
(ATTR_OPTIMIZE
, $3); }
561 | tOPTIONAL
{ $$
= make_attr
(ATTR_OPTIONAL
); }
562 | tOUT
{ $$
= make_attr
(ATTR_OUT
); }
563 | tPARTIALIGNORE
{ $$
= make_attr
(ATTR_PARTIALIGNORE
); }
564 | tPOINTERDEFAULT
'(' pointer_type
')' { $$
= make_attrv
(ATTR_POINTERDEFAULT
, $3); }
565 | tPROGID
'(' aSTRING
')' { $$
= make_attrp
(ATTR_PROGID
, $3); }
566 | tPROPGET
{ $$
= make_attr
(ATTR_PROPGET
); }
567 | tPROPPUT
{ $$
= make_attr
(ATTR_PROPPUT
); }
568 | tPROPPUTREF
{ $$
= make_attr
(ATTR_PROPPUTREF
); }
569 | tPROXY
{ $$
= make_attr
(ATTR_PROXY
); }
570 | tPUBLIC
{ $$
= make_attr
(ATTR_PUBLIC
); }
571 | tRANGE
'(' expr_int_const
',' expr_int_const
')'
572 { expr_list_t
*list
= append_expr
( NULL
, $3 );
573 list
= append_expr
( list
, $5 );
574 $$
= make_attrp
(ATTR_RANGE
, list
); }
575 | tREADONLY
{ $$
= make_attr
(ATTR_READONLY
); }
576 | tREPRESENTAS
'(' type
')' { $$
= make_attrp
(ATTR_REPRESENTAS
, $3); }
577 | tREQUESTEDIT
{ $$
= make_attr
(ATTR_REQUESTEDIT
); }
578 | tRESTRICTED
{ $$
= make_attr
(ATTR_RESTRICTED
); }
579 | tRETVAL
{ $$
= make_attr
(ATTR_RETVAL
); }
580 | tSIZEIS
'(' m_exprs
')' { $$
= make_attrp
(ATTR_SIZEIS
, $3); }
581 | tSOURCE
{ $$
= make_attr
(ATTR_SOURCE
); }
582 | tSTRICTCONTEXTHANDLE
{ $$
= make_attr
(ATTR_STRICTCONTEXTHANDLE
); }
583 | tSTRING
{ $$
= make_attr
(ATTR_STRING
); }
584 | tSWITCHIS
'(' expr
')' { $$
= make_attrp
(ATTR_SWITCHIS
, $3); }
585 | tSWITCHTYPE
'(' type
')' { $$
= make_attrp
(ATTR_SWITCHTYPE
, $3); }
586 | tTRANSMITAS
'(' type
')' { $$
= make_attrp
(ATTR_TRANSMITAS
, $3); }
587 | tTHREADING
'(' threading_type
')' { $$
= make_attrv
(ATTR_THREADING
, $3); }
588 | tUIDEFAULT
{ $$
= make_attr
(ATTR_UIDEFAULT
); }
589 | tUSESGETLASTERROR
{ $$
= make_attr
(ATTR_USESGETLASTERROR
); }
590 | tUSERMARSHAL
'(' type
')' { $$
= make_attrp
(ATTR_USERMARSHAL
, $3); }
591 | tUUID
'(' uuid_string
')' { $$
= make_attrp
(ATTR_UUID
, $3); }
592 | tASYNCUUID
'(' uuid_string
')' { $$
= make_attrp
(ATTR_ASYNCUUID
, $3); }
593 | tV1ENUM
{ $$
= make_attr
(ATTR_V1ENUM
); }
594 | tVARARG
{ $$
= make_attr
(ATTR_VARARG
); }
595 | tVERSION
'(' version
')' { $$
= make_attrv
(ATTR_VERSION
, $3); }
596 | tVIPROGID
'(' aSTRING
')' { $$
= make_attrp
(ATTR_VIPROGID
, $3); }
597 | tWIREMARSHAL
'(' type
')' { $$
= make_attrp
(ATTR_WIREMARSHAL
, $3); }
598 | pointer_type
{ $$
= make_attrv
(ATTR_POINTERTYPE
, $1); }
603 | aSTRING
{ if
(!is_valid_uuid
($1))
604 error_loc
("invalid UUID: %s\n", $1);
605 $$
= parse_uuid
($1); }
608 callconv: tCDECL
{ $$
= xstrdup
("__cdecl"); }
609 | tFASTCALL
{ $$
= xstrdup
("__fastcall"); }
610 | tPASCAL
{ $$
= xstrdup
("__pascal"); }
611 | tSTDCALL
{ $$
= xstrdup
("__stdcall"); }
614 cases: { $$
= NULL
; }
615 | cases case
{ $$
= append_var
( $1, $2 ); }
618 case: tCASE expr_int_const
':' union_field
{ attr_t
*a
= make_attrp
(ATTR_CASE
, append_expr
( NULL
, $2 ));
619 $$
= $4; if
(!$$
) $$
= make_var
(NULL
);
620 $$
->attrs
= append_attr
( $$
->attrs
, a
);
622 | tDEFAULT
':' union_field
{ attr_t
*a
= make_attr
(ATTR_DEFAULT
);
623 $$
= $3; if
(!$$
) $$
= make_var
(NULL
);
624 $$
->attrs
= append_attr
( $$
->attrs
, a
);
628 enums: { $$
= NULL
; }
629 | enum_list
',' { $$
= $1; }
633 enum_list: enum { if
(!$1->eval
)
634 $1->eval
= make_exprl
(EXPR_NUM
, 0 /* default for first enum entry */);
635 $$
= append_var
( NULL
, $1 );
637 | enum_list
',' enum { if
(!$3->eval
)
639 var_t
*last
= LIST_ENTRY
( list_tail
($$
), var_t
, entry
);
640 enum expr_type type
= EXPR_NUM
;
641 if
(last
->eval
->type
== EXPR_HEXNUM
) type
= EXPR_HEXNUM
;
642 if
(last
->eval
->cval
+ 1 < 0) type
= EXPR_HEXNUM
;
643 $3->eval
= make_exprl
(type
, last
->eval
->cval
+ 1);
645 $$
= append_var
( $1, $3 );
649 enum_member: m_attributes ident
{ $$
= $2;
650 $$
->attrs
= check_enum_member_attrs
($1);
654 enum: enum_member
'=' expr_int_const
{ $$
= reg_const
($1);
656 $$
->declspec.type
= type_new_int
(TYPE_BASIC_INT
, 0);
658 | enum_member
{ $$
= reg_const
($1);
659 $$
->declspec.type
= type_new_int
(TYPE_BASIC_INT
, 0);
663 enumdef: tENUM t_ident
'{' enums
'}' { $$
= type_new_enum
($2, current_namespace
, TRUE
, $4); }
666 m_exprs: m_expr
{ $$
= append_expr
( NULL
, $1 ); }
667 | m_exprs
',' m_expr
{ $$
= append_expr
( $1, $3 ); }
670 m_expr: { $$
= make_expr
(EXPR_VOID
); }
674 expr: aNUM
{ $$
= make_exprl
(EXPR_NUM
, $1); }
675 | aHEXNUM
{ $$
= make_exprl
(EXPR_HEXNUM
, $1); }
676 | aDOUBLE
{ $$
= make_exprd
(EXPR_DOUBLE
, $1); }
677 | tFALSE
{ $$
= make_exprl
(EXPR_TRUEFALSE
, 0); }
678 | tNULL
{ $$
= make_exprl
(EXPR_NUM
, 0); }
679 | tTRUE
{ $$
= make_exprl
(EXPR_TRUEFALSE
, 1); }
680 | aSTRING
{ $$
= make_exprs
(EXPR_STRLIT
, $1); }
681 | aWSTRING
{ $$
= make_exprs
(EXPR_WSTRLIT
, $1); }
682 | aSQSTRING
{ $$
= make_exprs
(EXPR_CHARCONST
, $1); }
683 | aIDENTIFIER
{ $$
= make_exprs
(EXPR_IDENTIFIER
, $1); }
684 | expr
'?' expr
':' expr
{ $$
= make_expr3
(EXPR_COND
, $1, $3, $5); }
685 | expr LOGICALOR expr
{ $$
= make_expr2
(EXPR_LOGOR
, $1, $3); }
686 | expr LOGICALAND expr
{ $$
= make_expr2
(EXPR_LOGAND
, $1, $3); }
687 | expr
'|' expr
{ $$
= make_expr2
(EXPR_OR
, $1, $3); }
688 | expr
'^' expr
{ $$
= make_expr2
(EXPR_XOR
, $1, $3); }
689 | expr
'&' expr
{ $$
= make_expr2
(EXPR_AND
, $1, $3); }
690 | expr EQUALITY expr
{ $$
= make_expr2
(EXPR_EQUALITY
, $1, $3); }
691 | expr INEQUALITY expr
{ $$
= make_expr2
(EXPR_INEQUALITY
, $1, $3); }
692 | expr
'>' expr
{ $$
= make_expr2
(EXPR_GTR
, $1, $3); }
693 | expr
'<' expr
{ $$
= make_expr2
(EXPR_LESS
, $1, $3); }
694 | expr GREATEREQUAL expr
{ $$
= make_expr2
(EXPR_GTREQL
, $1, $3); }
695 | expr LESSEQUAL expr
{ $$
= make_expr2
(EXPR_LESSEQL
, $1, $3); }
696 | expr SHL expr
{ $$
= make_expr2
(EXPR_SHL
, $1, $3); }
697 | expr SHR expr
{ $$
= make_expr2
(EXPR_SHR
, $1, $3); }
698 | expr
'+' expr
{ $$
= make_expr2
(EXPR_ADD
, $1, $3); }
699 | expr
'-' expr
{ $$
= make_expr2
(EXPR_SUB
, $1, $3); }
700 | expr
'%' expr
{ $$
= make_expr2
(EXPR_MOD
, $1, $3); }
701 | expr
'*' expr
{ $$
= make_expr2
(EXPR_MUL
, $1, $3); }
702 | expr
'/' expr
{ $$
= make_expr2
(EXPR_DIV
, $1, $3); }
703 |
'!' expr
{ $$
= make_expr1
(EXPR_LOGNOT
, $2); }
704 |
'~' expr
{ $$
= make_expr1
(EXPR_NOT
, $2); }
705 |
'+' expr %prec POS
{ $$
= make_expr1
(EXPR_POS
, $2); }
706 |
'-' expr %prec NEG
{ $$
= make_expr1
(EXPR_NEG
, $2); }
707 |
'&' expr %prec ADDRESSOF
{ $$
= make_expr1
(EXPR_ADDRESSOF
, $2); }
708 |
'*' expr %prec PPTR
{ $$
= make_expr1
(EXPR_PPTR
, $2); }
709 | expr MEMBERPTR aIDENTIFIER
{ $$
= make_expr2
(EXPR_MEMBER
, make_expr1
(EXPR_PPTR
, $1), make_exprs
(EXPR_IDENTIFIER
, $3)); }
710 | expr
'.' aIDENTIFIER
{ $$
= make_expr2
(EXPR_MEMBER
, $1, make_exprs
(EXPR_IDENTIFIER
, $3)); }
711 |
'(' decl_spec m_abstract_declarator
')' expr %prec CAST
712 { $$
= make_exprt
(EXPR_CAST
, declare_var
(NULL
, $2, $3, 0), $5); free
($2); free
($3); }
713 | tSIZEOF
'(' decl_spec m_abstract_declarator
')'
714 { $$
= make_exprt
(EXPR_SIZEOF
, declare_var
(NULL
, $3, $4, 0), NULL
); free
($3); free
($4); }
715 | expr
'[' expr
']' { $$
= make_expr2
(EXPR_ARRAY
, $1, $3); }
716 |
'(' expr
')' { $$
= $2; }
719 expr_list_int_const: expr_int_const
{ $$
= append_expr
( NULL
, $1 ); }
720 | expr_list_int_const
',' expr_int_const
{ $$
= append_expr
( $1, $3 ); }
723 expr_int_const: expr
{ $$
= $1;
725 error_loc
("expression is not an integer constant\n");
729 expr_const: expr
{ $$
= $1;
730 if
(!$$
->is_const
&& $$
->type
!= EXPR_STRLIT
&& $$
->type
!= EXPR_WSTRLIT
)
731 error_loc
("expression is not constant\n");
735 fields: { $$
= NULL
; }
736 | fields field
{ $$
= append_var_list
($1, $2); }
739 field: m_attributes decl_spec struct_declarator_list
';'
740 { const char *first
= LIST_ENTRY
(list_head
($3), declarator_t
, entry
)->var
->name
;
741 check_field_attrs
(first
, $1);
742 $$
= set_var_types
($1, $2, $3);
744 | m_attributes uniondef
';' { var_t
*v
= make_var
(NULL
);
745 v
->declspec.type
= $2; v
->attrs
= $1;
746 $$
= append_var
(NULL
, v
);
751 s_field
';' { $$
= $1; }
752 | attributes
';' { $$
= make_var
(NULL
); $$
->attrs
= $1; }
755 ne_union_fields: { $$
= NULL
; }
756 | ne_union_fields ne_union_field
{ $$
= append_var
( $1, $2 ); }
760 s_field
';' { $$
= $1; }
764 s_field: m_attributes decl_spec declarator
{ $$
= declare_var
(check_field_attrs
($3->var
->name
, $1),
768 | m_attributes structdef
{ var_t
*v
= make_var
(NULL
);
769 v
->declspec.type
= $2; v
->attrs
= $1;
774 funcdef: declaration
{ $$
= $1;
775 if
(type_get_type
($$
->declspec.type
) != TYPE_FUNCTION
)
776 error_loc
("only methods may be declared inside the methods section of a dispinterface\n");
777 check_function_attrs
($$
->name
, $$
->attrs
);
782 attributes decl_spec init_declarator
783 { $$
= declare_var
($1, $2, $3, FALSE
);
786 | decl_spec init_declarator
{ $$
= declare_var
(NULL
, $1, $2, FALSE
);
791 m_ident: { $$
= NULL
; }
795 t_ident: { $$
= NULL
; }
796 | aIDENTIFIER
{ $$
= $1; }
797 | aKNOWNTYPE
{ $$
= $1; }
800 ident: aIDENTIFIER
{ $$
= make_var
($1); }
801 /* some "reserved words" used in attributes are also used as field names in some MS IDL files */
802 | aKNOWNTYPE
{ $$
= make_var
($
<str
>1); }
805 base_type: tBYTE
{ $$
= find_type_or_error
($
<str
>1, 0); }
806 | tWCHAR
{ $$
= find_type_or_error
($
<str
>1, 0); }
808 | tSIGNED int_std
{ $$
= type_new_int
(type_basic_get_type
($2), -1); }
809 | tUNSIGNED int_std
{ $$
= type_new_int
(type_basic_get_type
($2), 1); }
810 | tUNSIGNED
{ $$
= type_new_int
(TYPE_BASIC_INT
, 1); }
811 | tFLOAT
{ $$
= find_type_or_error
($
<str
>1, 0); }
812 | tDOUBLE
{ $$
= find_type_or_error
($
<str
>1, 0); }
813 | tBOOLEAN
{ $$
= find_type_or_error
($
<str
>1, 0); }
814 | tERRORSTATUST
{ $$
= find_type_or_error
($
<str
>1, 0); }
815 | tHANDLET
{ $$
= find_type_or_error
($
<str
>1, 0); }
822 int_std: tINT
{ $$
= type_new_int
(TYPE_BASIC_INT
, 0); }
823 | tSHORT m_int
{ $$
= type_new_int
(TYPE_BASIC_INT16
, 0); }
824 | tSMALL
{ $$
= type_new_int
(TYPE_BASIC_INT8
, 0); }
825 | tLONG m_int
{ $$
= type_new_int
(TYPE_BASIC_LONG
, 0); }
826 | tHYPER m_int
{ $$
= type_new_int
(TYPE_BASIC_HYPER
, 0); }
827 | tINT64
{ $$
= type_new_int
(TYPE_BASIC_INT64
, 0); }
828 | tCHAR
{ $$
= type_new_int
(TYPE_BASIC_CHAR
, 0); }
829 | tINT32
{ $$
= type_new_int
(TYPE_BASIC_INT32
, 0); }
830 | tINT3264
{ $$
= type_new_int
(TYPE_BASIC_INT3264
, 0); }
834 aKNOWNTYPE
{ $$
= find_type_or_error
($1, 0); }
835 | aIDENTIFIER
'.' { push_lookup_namespace
($1); } qualified_seq
{ $$
= $4; }
839 aKNOWNTYPE
{ $$
= find_type_or_error
($1, 0); }
840 | aNAMESPACE
'.' { init_lookup_namespace
($1); } qualified_seq
{ $$
= $4; }
843 coclass: tCOCLASS aIDENTIFIER
{ $$
= type_new_coclass
($2); }
844 | tCOCLASS aKNOWNTYPE
{ $$
= find_type
($2, NULL
, 0);
845 if
(type_get_type_detect_alias
($$
) != TYPE_COCLASS
)
846 error_loc
("%s was not declared a coclass at %s:%d\n",
847 $2, $$
->loc_info.input_name
,
848 $$
->loc_info.line_number
);
852 coclasshdr: attributes coclass
{ $$
= $2;
854 $$
->attrs
= check_coclass_attrs
($2->name
, $1);
858 coclassdef: coclasshdr
'{' coclass_ints
'}' semicolon_opt
859 { $$
= type_coclass_define
($1, $3); }
862 namespacedef: tNAMESPACE aIDENTIFIER
{ $$
= $2; }
863 | tNAMESPACE aNAMESPACE
{ $$
= $2; }
866 coclass_ints: { $$
= NULL
; }
867 | coclass_ints coclass_int
{ $$
= append_ifref
( $1, $2 ); }
871 m_attributes interfacedec
{ $$
= make_ifref
($2); $$
->attrs
= $1; }
874 dispinterface: tDISPINTERFACE aIDENTIFIER
{ $$
= get_type
(TYPE_INTERFACE
, $2, current_namespace
, 0); }
875 | tDISPINTERFACE aKNOWNTYPE
{ $$
= get_type
(TYPE_INTERFACE
, $2, current_namespace
, 0); }
878 dispinterfacehdr: attributes dispinterface
{ attr_t
*attrs
;
881 attrs
= make_attr
(ATTR_DISPINTERFACE
);
882 $$
->attrs
= append_attr
( check_dispiface_attrs
($2->name
, $1), attrs
);
887 dispint_props: tPROPERTIES
':' { $$
= NULL
; }
888 | dispint_props s_field
';' { $$
= append_var
( $1, $2 ); }
891 dispint_meths: tMETHODS
':' { $$
= NULL
; }
892 | dispint_meths funcdef
';' { $$
= append_var
( $1, $2 ); }
895 dispinterfacedef: dispinterfacehdr
'{'
899 type_dispinterface_define
($$
, $3, $4);
902 '{' interface
';' '}' { $$
= $1;
903 type_dispinterface_define_from_iface
($$
, $3);
907 inherit: { $$
= NULL
; }
908 |
':' qualified_type
{ $$
= $2; }
911 interface: tINTERFACE aIDENTIFIER
{ $$
= get_type
(TYPE_INTERFACE
, $2, current_namespace
, 0); }
912 | tINTERFACE aKNOWNTYPE
{ $$
= get_type
(TYPE_INTERFACE
, $2, current_namespace
, 0); }
915 interfacehdr: attributes interface
{ $$
= $2;
917 $2->attrs
= check_iface_attrs
($2->name
, $1);
922 interfacedef: interfacehdr inherit
923 '{' int_statements
'}' semicolon_opt
{ $$
= $1;
925 error_loc
("Interface can't inherit from itself\n");
926 type_interface_define
($$
, $2, $4);
927 check_async_uuid
($$
);
929 /* MIDL is able to import the definition of a base class from inside the
930 * definition of a derived class, I'll try to support it with this rule */
931 | interfacehdr
':' aIDENTIFIER
932 '{' import int_statements
'}'
933 semicolon_opt
{ $$
= $1;
934 type_interface_define
($$
, find_type_or_error2
($3, 0), $6);
936 | dispinterfacedef semicolon_opt
{ $$
= $1; }
940 interface
';' { $$
= $1; }
941 | dispinterface
';' { $$
= $1; }
944 module: tMODULE aIDENTIFIER
{ $$
= type_new_module
($2); }
945 | tMODULE aKNOWNTYPE
{ $$
= type_new_module
($2); }
948 modulehdr: attributes module
{ $$
= $2;
949 $$
->attrs
= check_module_attrs
($2->name
, $1);
953 moduledef: modulehdr
'{' int_statements
'}'
954 semicolon_opt
{ $$
= $1;
955 type_module_define
($$
, $3);
960 tEXTERN
{ $$
= STG_EXTERN
; }
961 | tSTATIC
{ $$
= STG_STATIC
; }
962 | tREGISTER
{ $$
= STG_REGISTER
; }
966 tINLINE
{ $$
= FUNCTION_SPECIFIER_INLINE
; }
970 tCONST
{ $$
= TYPE_QUALIFIER_CONST
; }
973 m_type_qual_list: { $$
= 0; }
974 | m_type_qual_list type_qualifier
{ $$
= $1 |
$2; }
977 decl_spec: type m_decl_spec_no_type
{ $$
= make_decl_spec
($1, $2, NULL
, STG_NONE
, 0, 0); }
978 | decl_spec_no_type type m_decl_spec_no_type
979 { $$
= make_decl_spec
($2, $1, $3, STG_NONE
, 0, 0); }
982 m_decl_spec_no_type: { $$
= NULL
; }
987 type_qualifier m_decl_spec_no_type
{ $$
= make_decl_spec
(NULL
, $2, NULL
, STG_NONE
, $1, 0); }
988 | function_specifier m_decl_spec_no_type
{ $$
= make_decl_spec
(NULL
, $2, NULL
, STG_NONE
, 0, $1); }
989 | storage_cls_spec m_decl_spec_no_type
{ $$
= make_decl_spec
(NULL
, $2, NULL
, $1, 0, 0); }
993 '*' m_type_qual_list declarator %prec PPTR
994 { $$
= $3; append_chain_type
($$
, type_new_pointer
(NULL
), $2); }
995 | callconv declarator
{ $$
= $2; append_chain_callconv
($$
->type
, $1); }
1000 ident
{ $$
= make_declarator
($1); }
1001 |
'(' declarator
')' { $$
= $2; }
1002 | direct_declarator array
{ $$
= $1; append_array
($$
, $2); }
1003 | direct_declarator
'(' m_args
')' { $$
= $1; append_chain_type
($$
, type_new_function
($3), 0); }
1006 /* abstract declarator */
1007 abstract_declarator:
1008 '*' m_type_qual_list m_abstract_declarator %prec PPTR
1009 { $$
= $3; append_chain_type
($$
, type_new_pointer
(NULL
), $2); }
1010 | callconv m_abstract_declarator
{ $$
= $2; append_chain_callconv
($$
->type
, $1); }
1011 | abstract_direct_declarator
1014 /* abstract declarator without accepting direct declarator */
1015 abstract_declarator_no_direct:
1016 '*' m_type_qual_list m_any_declarator %prec PPTR
1017 { $$
= $3; append_chain_type
($$
, type_new_pointer
(NULL
), $2); }
1018 | callconv m_any_declarator
{ $$
= $2; append_chain_callconv
($$
->type
, $1); }
1021 /* abstract declarator or empty */
1022 m_abstract_declarator: { $$
= make_declarator
(NULL
); }
1023 | abstract_declarator
1026 /* abstract direct declarator */
1027 abstract_direct_declarator:
1028 '(' abstract_declarator_no_direct
')' { $$
= $2; }
1029 | abstract_direct_declarator array
{ $$
= $1; append_array
($$
, $2); }
1030 | array
{ $$
= make_declarator
(NULL
); append_array
($$
, $1); }
1032 { $$
= make_declarator
(NULL
);
1033 append_chain_type
($$
, type_new_function
($2), 0);
1035 | abstract_direct_declarator
'(' m_args
')'
1037 append_chain_type
($$
, type_new_function
($3), 0);
1041 /* abstract or non-abstract declarator */
1043 '*' m_type_qual_list m_any_declarator %prec PPTR
1044 { $$
= $3; append_chain_type
($$
, type_new_pointer
(NULL
), $2); }
1045 | callconv m_any_declarator
{ $$
= $2; append_chain_callconv
($$
->type
, $1); }
1046 | any_direct_declarator
1049 /* abstract or non-abstract declarator without accepting direct declarator */
1050 any_declarator_no_direct:
1051 '*' m_type_qual_list m_any_declarator %prec PPTR
1052 { $$
= $3; append_chain_type
($$
, type_new_pointer
(NULL
), $2); }
1053 | callconv m_any_declarator
{ $$
= $2; append_chain_callconv
($$
->type
, $1); }
1056 /* abstract or non-abstract declarator or empty */
1057 m_any_declarator: { $$
= make_declarator
(NULL
); }
1061 /* abstract or non-abstract direct declarator. note: direct declarators
1062 * aren't accepted inside brackets to avoid ambiguity with the rule for
1063 * function arguments */
1064 any_direct_declarator:
1065 ident
{ $$
= make_declarator
($1); }
1066 |
'(' any_declarator_no_direct
')' { $$
= $2; }
1067 | any_direct_declarator array
{ $$
= $1; append_array
($$
, $2); }
1068 | array
{ $$
= make_declarator
(NULL
); append_array
($$
, $1); }
1070 { $$
= make_declarator
(NULL
);
1071 append_chain_type
($$
, type_new_function
($2), 0);
1073 | any_direct_declarator
'(' m_args
')'
1075 append_chain_type
($$
, type_new_function
($3), 0);
1080 declarator
{ $$
= append_declarator
( NULL
, $1 ); }
1081 | declarator_list
',' declarator
{ $$
= append_declarator
( $1, $3 ); }
1084 m_bitfield: { $$
= NULL
; }
1085 |
':' expr_const
{ $$
= $2; }
1088 struct_declarator: any_declarator m_bitfield
{ $$
= $1; $$
->bits
= $2;
1089 if
(!$$
->bits
&& !$$
->var
->name
)
1090 error_loc
("unnamed fields are not allowed\n");
1094 struct_declarator_list:
1095 struct_declarator
{ $$
= append_declarator
( NULL
, $1 ); }
1096 | struct_declarator_list
',' struct_declarator
1097 { $$
= append_declarator
( $1, $3 ); }
1101 declarator
{ $$
= $1; }
1102 | declarator
'=' expr_const
{ $$
= $1; $1->var
->eval
= $3; }
1106 tAPARTMENT
{ $$
= THREADING_APARTMENT
; }
1107 | tNEUTRAL
{ $$
= THREADING_NEUTRAL
; }
1108 | tSINGLE
{ $$
= THREADING_SINGLE
; }
1109 | tFREE
{ $$
= THREADING_FREE
; }
1110 | tBOTH
{ $$
= THREADING_BOTH
; }
1114 tREF
{ $$
= FC_RP
; }
1115 | tUNIQUE
{ $$
= FC_UP
; }
1116 | tPTR
{ $$
= FC_FP
; }
1119 structdef: tSTRUCT t_ident
'{' fields
'}' { $$
= type_new_struct
($2, current_namespace
, TRUE
, $4); }
1122 type: tVOID
{ $$
= type_new_void
(); }
1123 | qualified_type
{ $$
= $1; }
1124 | base_type
{ $$
= $1; }
1125 | enumdef
{ $$
= $1; }
1126 | tENUM aIDENTIFIER
{ $$
= type_new_enum
($2, current_namespace
, FALSE
, NULL
); }
1127 | structdef
{ $$
= $1; }
1128 | tSTRUCT aIDENTIFIER
{ $$
= type_new_struct
($2, current_namespace
, FALSE
, NULL
); }
1129 | uniondef
{ $$
= $1; }
1130 | tUNION aIDENTIFIER
{ $$
= type_new_nonencapsulated_union
($2, FALSE
, NULL
); }
1131 | tSAFEARRAY
'(' type
')' { $$
= make_safearray
($3); }
1134 typedef: m_attributes tTYPEDEF m_attributes decl_spec declarator_list
1135 { $1 = append_attribs
($1, $3);
1136 reg_typedefs
($4, $5, check_typedef_attrs
($1));
1137 $$
= make_statement_typedef
($5, !$4->type
->defined
);
1141 uniondef: tUNION t_ident
'{' ne_union_fields
'}'
1142 { $$
= type_new_nonencapsulated_union
($2, TRUE
, $4); }
1144 tSWITCH
'(' s_field
')'
1145 m_ident
'{' cases
'}' { $$
= type_new_encapsulated_union
($2, $5, $7, $9); }
1149 aNUM
{ $$
= MAKEVERSION
($1, 0); }
1150 | aNUM
'.' aNUM
{ $$
= MAKEVERSION
($1, $3); }
1151 | aHEXNUM
{ $$
= $1; }
1156 | acf_interface acf_statements
1161 | acf_int_statement acf_int_statements
1165 : tTYPEDEF acf_attributes aKNOWNTYPE
';'
1166 { type_t
*type
= find_type_or_error
($3, 0);
1167 type
->attrs
= append_attr_list
(type
->attrs
, $2);
1172 : acf_attributes tINTERFACE aKNOWNTYPE
'{' acf_int_statements
'}'
1173 { type_t
*iface
= find_type_or_error2
($3, 0);
1174 if
(type_get_type
(iface
) != TYPE_INTERFACE
)
1175 error_loc
("%s is not an interface\n", iface
->name
);
1176 iface
->attrs
= append_attr_list
(iface
->attrs
, $1);
1181 : /* empty */ { $$
= NULL
; };
1182 |
'[' acf_attribute_list
']' { $$
= $2; };
1186 : acf_attribute
{ $$
= append_attr
(NULL
, $1); }
1187 | acf_attribute_list
',' acf_attribute
{ $$
= append_attr
($1, $3); }
1191 : tALLOCATE
'(' allocate_option_list
')'
1192 { $$
= make_attrv
(ATTR_ALLOCATE
, $3); }
1193 | tENCODE
{ $$
= make_attr
(ATTR_ENCODE
); }
1194 | tDECODE
{ $$
= make_attr
(ATTR_DECODE
); }
1195 | tEXPLICITHANDLE
{ $$
= make_attr
(ATTR_EXPLICIT_HANDLE
); }
1198 allocate_option_list
1199 : allocate_option
{ $$
= $1; }
1200 | allocate_option_list
',' allocate_option
1205 : tDONTFREE
{ $$
= FC_DONT_FREE
; }
1207 | tALLNODES
{ $$
= FC_ALLOCATE_ALL_NODES
; }
1208 | tSINGLENODE
{ $$
= 0; }
1213 static void decl_builtin_basic
(const char *name
, enum type_basic_type type
)
1215 type_t
*t
= type_new_basic
(type
);
1216 reg_type
(t
, name
, NULL
, 0);
1219 static void decl_builtin_alias
(const char *name
, type_t
*t
)
1221 const decl_spec_t ds
= {.type
= t
};
1222 reg_type
(type_new_alias
(&ds
, name
), name
, NULL
, 0);
1225 void init_types
(void)
1227 decl_builtin_basic
("byte", TYPE_BASIC_BYTE
);
1228 decl_builtin_basic
("wchar_t", TYPE_BASIC_WCHAR
);
1229 decl_builtin_basic
("float", TYPE_BASIC_FLOAT
);
1230 decl_builtin_basic
("double", TYPE_BASIC_DOUBLE
);
1231 decl_builtin_basic
("error_status_t", TYPE_BASIC_ERROR_STATUS_T
);
1232 decl_builtin_basic
("handle_t", TYPE_BASIC_HANDLE
);
1233 decl_builtin_alias
("boolean", type_new_basic
(TYPE_BASIC_CHAR
));
1236 static str_list_t
*append_str
(str_list_t
*list
, char *str
)
1238 struct str_list_entry_t
*entry
;
1240 if
(!str
) return list
;
1243 list
= xmalloc
( sizeof
(*list
) );
1246 entry
= xmalloc
( sizeof
(*entry
) );
1248 list_add_tail
( list
, &entry
->entry
);
1252 static attr_list_t
*move_attr
(attr_list_t
*dst
, attr_list_t
*src
, enum attr_type type
)
1255 if
(!src
) return dst
;
1256 LIST_FOR_EACH_ENTRY
(attr
, src
, attr_t
, entry
)
1257 if
(attr
->type
== type
)
1259 list_remove
(&attr
->entry
);
1260 return append_attr
(dst
, attr
);
1265 static attr_list_t
*append_attr_list
(attr_list_t
*new_list
, attr_list_t
*old_list
)
1269 if
(!old_list
) return new_list
;
1271 while
((entry
= list_head
(old_list
)))
1273 attr_t
*attr
= LIST_ENTRY
(entry
, attr_t
, entry
);
1275 new_list
= append_attr
(new_list
, attr
);
1280 typedef
int (*map_attrs_filter_t
)(attr_list_t
*,const attr_t
*);
1282 static attr_list_t
*map_attrs
(const attr_list_t
*list
, map_attrs_filter_t filter
)
1284 attr_list_t
*new_list
;
1288 if
(!list
) return NULL
;
1290 new_list
= xmalloc
( sizeof
(*list
) );
1291 list_init
( new_list
);
1292 LIST_FOR_EACH_ENTRY
(attr
, list
, const attr_t
, entry
)
1294 if
(filter
&& !filter
(new_list
, attr
)) continue
;
1295 new_attr
= xmalloc
(sizeof
(*new_attr
));
1297 list_add_tail
(new_list
, &new_attr
->entry
);
1302 static decl_spec_t
*make_decl_spec
(type_t
*type
, decl_spec_t
*left
, decl_spec_t
*right
,
1303 enum storage_class stgclass
, enum type_qualifier qual
, enum function_specifier func_specifier
)
1305 decl_spec_t
*declspec
= left ? left
: right
;
1308 declspec
= xmalloc
(sizeof
(*declspec
));
1309 declspec
->type
= NULL
;
1310 declspec
->stgclass
= STG_NONE
;
1311 declspec
->qualifier
= 0;
1312 declspec
->func_specifier
= 0;
1314 declspec
->type
= type
;
1315 if
(left
&& declspec
!= left
)
1317 if
(declspec
->stgclass
== STG_NONE
)
1318 declspec
->stgclass
= left
->stgclass
;
1319 else if
(left
->stgclass
!= STG_NONE
)
1320 error_loc
("only one storage class can be specified\n");
1321 declspec
->qualifier |
= left
->qualifier
;
1322 declspec
->func_specifier |
= left
->func_specifier
;
1323 assert
(!left
->type
);
1326 if
(right
&& declspec
!= right
)
1328 if
(declspec
->stgclass
== STG_NONE
)
1329 declspec
->stgclass
= right
->stgclass
;
1330 else if
(right
->stgclass
!= STG_NONE
)
1331 error_loc
("only one storage class can be specified\n");
1332 declspec
->qualifier |
= right
->qualifier
;
1333 declspec
->func_specifier |
= right
->func_specifier
;
1334 assert
(!right
->type
);
1338 if
(declspec
->stgclass
== STG_NONE
)
1339 declspec
->stgclass
= stgclass
;
1340 else if
(stgclass
!= STG_NONE
)
1341 error_loc
("only one storage class can be specified\n");
1342 declspec
->qualifier |
= qual
;
1343 declspec
->func_specifier |
= func_specifier
;
1348 static attr_t
*make_attr
(enum attr_type type
)
1350 attr_t
*a
= xmalloc
(sizeof
(attr_t
));
1356 static attr_t
*make_attrv
(enum attr_type type
, unsigned int val
)
1358 attr_t
*a
= xmalloc
(sizeof
(attr_t
));
1364 static attr_t
*make_attrp
(enum attr_type type
, void *val
)
1366 attr_t
*a
= xmalloc
(sizeof
(attr_t
));
1372 static attr_t
*make_custom_attr
(UUID
*id
, expr_t
*pval
)
1374 attr_t
*a
= xmalloc
(sizeof
(attr_t
));
1375 attr_custdata_t
*cstdata
= xmalloc
(sizeof
(attr_custdata_t
));
1376 a
->type
= ATTR_CUSTOM
;
1378 cstdata
->pval
= pval
;
1379 a
->u.pval
= cstdata
;
1383 static expr_list_t
*append_expr
(expr_list_t
*list
, expr_t
*expr
)
1385 if
(!expr
) return list
;
1388 list
= xmalloc
( sizeof
(*list
) );
1391 list_add_tail
( list
, &expr
->entry
);
1395 static void append_array
(declarator_t
*decl
, expr_t
*expr
)
1402 /* An array is always a reference pointer unless explicitly marked otherwise
1403 * (regardless of what the default pointer attribute is). */
1404 array
= type_new_array
(NULL
, NULL
, FALSE
, expr
->is_const ? expr
->cval
: 0,
1405 expr
->is_const ? NULL
: expr
, NULL
);
1407 append_chain_type
(decl
, array
, 0);
1410 static struct list type_pool
= LIST_INIT
(type_pool
);
1417 type_t
*alloc_type
(void)
1419 type_pool_node_t
*node
= xmalloc
(sizeof
*node
);
1420 list_add_tail
(&type_pool
, &node
->link
);
1424 void set_all_tfswrite
(int val
)
1426 type_pool_node_t
*node
;
1427 LIST_FOR_EACH_ENTRY
(node
, &type_pool
, type_pool_node_t
, link
)
1428 node
->data.tfswrite
= val
;
1431 void clear_all_offsets
(void)
1433 type_pool_node_t
*node
;
1434 LIST_FOR_EACH_ENTRY
(node
, &type_pool
, type_pool_node_t
, link
)
1435 node
->data.typestring_offset
= node
->data.ptrdesc
= 0;
1438 static void type_function_add_head_arg
(type_t
*type
, var_t
*arg
)
1440 if
(!type
->details.function
->args
)
1442 type
->details.function
->args
= xmalloc
( sizeof
(*type
->details.function
->args
) );
1443 list_init
( type
->details.function
->args
);
1445 list_add_head
( type
->details.function
->args
, &arg
->entry
);
1448 static int is_allowed_range_type
(const type_t
*type
)
1450 switch
(type_get_type
(type
))
1455 switch
(type_basic_get_type
(type
))
1457 case TYPE_BASIC_INT8
:
1458 case TYPE_BASIC_INT16
:
1459 case TYPE_BASIC_INT32
:
1460 case TYPE_BASIC_INT64
:
1461 case TYPE_BASIC_INT
:
1462 case TYPE_BASIC_INT3264
:
1463 case TYPE_BASIC_LONG
:
1464 case TYPE_BASIC_BYTE
:
1465 case TYPE_BASIC_CHAR
:
1466 case TYPE_BASIC_WCHAR
:
1467 case TYPE_BASIC_HYPER
:
1469 case TYPE_BASIC_FLOAT
:
1470 case TYPE_BASIC_DOUBLE
:
1471 case TYPE_BASIC_ERROR_STATUS_T
:
1472 case TYPE_BASIC_HANDLE
:
1481 static type_t
*get_chain_ref
(type_t
*type
)
1484 return type_pointer_get_ref_type
(type
);
1485 else if
(is_array
(type
))
1486 return type_array_get_element_type
(type
);
1487 else if
(is_func
(type
))
1488 return type_function_get_rettype
(type
);
1492 static type_t
*get_chain_end
(type_t
*type
)
1495 while
((inner
= get_chain_ref
(type
)))
1500 static void append_chain_type
(declarator_t
*decl
, type_t
*type
, enum type_qualifier qual
)
1507 decl
->qualifier
= qual
;
1510 chain_type
= get_chain_end
(decl
->type
);
1512 if
(is_ptr
(chain_type
))
1514 chain_type
->details.pointer.ref.type
= type
;
1515 chain_type
->details.pointer.ref.qualifier
= qual
;
1517 else if
(is_array
(chain_type
))
1519 chain_type
->details.array.elem.type
= type
;
1520 chain_type
->details.array.elem.qualifier
= qual
;
1522 else if
(is_func
(chain_type
))
1524 chain_type
->details.function
->retval
->declspec.type
= type
;
1525 chain_type
->details.function
->retval
->declspec.qualifier
= qual
;
1530 if
(!is_func
(chain_type
))
1531 type
->attrs
= move_attr
(type
->attrs
, chain_type
->attrs
, ATTR_CALLCONV
);
1534 static void append_chain_callconv
(type_t
*chain
, char *callconv
)
1538 if
(chain
&& (chain_end
= get_chain_end
(chain
)))
1539 chain_end
->attrs
= append_attr
(chain_end
->attrs
, make_attrp
(ATTR_CALLCONV
, callconv
));
1541 error_loc
("calling convention applied to non-function type\n");
1544 static warning_list_t
*append_warning
(warning_list_t
*list
, int num
)
1550 list
= xmalloc
( sizeof
(*list
) );
1553 entry
= xmalloc
( sizeof
(*entry
) );
1555 list_add_tail
( list
, &entry
->entry
);
1559 static var_t
*declare_var
(attr_list_t
*attrs
, decl_spec_t
*decl_spec
, declarator_t
*decl
,
1562 var_t
*v
= decl
->var
;
1563 expr_list_t
*sizes
= get_attrp
(attrs
, ATTR_SIZEIS
);
1564 expr_list_t
*lengs
= get_attrp
(attrs
, ATTR_LENGTHIS
);
1567 type_t
*type
= decl_spec
->type
;
1569 if
(decl_spec
->func_specifier
& FUNCTION_SPECIFIER_INLINE
)
1571 if
(!decl ||
!is_func
(decl
->type
))
1572 error_loc
("inline attribute applied to non-function type\n");
1575 /* add type onto the end of the pointers in pident->type */
1576 append_chain_type
(decl
, type
, decl_spec
->qualifier
);
1577 v
->declspec
= *decl_spec
;
1578 v
->declspec.type
= decl
->type
;
1579 v
->declspec.qualifier
= decl
->qualifier
;
1581 v
->declonly
= !type
->defined
;
1583 if
(is_attr
(type
->attrs
, ATTR_CALLCONV
) && !is_func
(type
))
1584 error_loc
("calling convention applied to non-function type\n");
1586 /* check for pointer attribute being applied to non-pointer, non-array
1588 if
(!is_array
(v
->declspec.type
))
1590 int ptr_attr
= get_attrv
(v
->attrs
, ATTR_POINTERTYPE
);
1591 const type_t
*ptr
= NULL
;
1592 for
(ptr
= v
->declspec.type
; ptr
&& !ptr_attr
; )
1594 ptr_attr
= get_attrv
(ptr
->attrs
, ATTR_POINTERTYPE
);
1595 if
(!ptr_attr
&& type_is_alias
(ptr
))
1596 ptr
= type_alias_get_aliasee_type
(ptr
);
1602 if
(ptr_attr
&& ptr_attr
!= FC_UP
&&
1603 type_get_type
(type_pointer_get_ref_type
(ptr
)) == TYPE_INTERFACE
)
1604 warning_loc_info
(&v
->loc_info
,
1605 "%s: pointer attribute applied to interface "
1606 "pointer type has no effect\n", v
->name
);
1607 if
(!ptr_attr
&& top
)
1609 /* FIXME: this is a horrible hack to cope with the issue that we
1610 * store an offset to the typeformat string in the type object, but
1611 * two typeformat strings may be written depending on whether the
1612 * pointer is a toplevel parameter or not */
1613 v
->declspec.type
= duptype
(v
->declspec.type
, 1);
1617 error_loc
("%s: pointer attribute applied to non-pointer type\n", v
->name
);
1620 if
(is_attr
(v
->attrs
, ATTR_STRING
))
1624 if
(!is_ptr
(v
->declspec.type
) && !is_array
(v
->declspec.type
))
1625 error_loc
("'%s': [string] attribute applied to non-pointer, non-array type\n",
1631 t
= type_pointer_get_ref_type
(t
);
1632 else if
(is_array
(t
))
1633 t
= type_array_get_element_type
(t
);
1638 if
(type_get_type
(t
) != TYPE_BASIC
&&
1639 (get_basic_fc
(t
) != FC_CHAR
&&
1640 get_basic_fc
(t
) != FC_BYTE
&&
1641 get_basic_fc
(t
) != FC_WCHAR
))
1643 error_loc
("'%s': [string] attribute is only valid on 'char', 'byte', or 'wchar_t' pointers and arrays\n",
1648 if
(is_attr
(v
->attrs
, ATTR_V1ENUM
))
1650 if
(type_get_type_detect_alias
(v
->declspec.type
) != TYPE_ENUM
)
1651 error_loc
("'%s': [v1_enum] attribute applied to non-enum type\n", v
->name
);
1654 if
(is_attr
(v
->attrs
, ATTR_RANGE
) && !is_allowed_range_type
(v
->declspec.type
))
1655 error_loc
("'%s': [range] attribute applied to non-integer type\n",
1658 ptype
= &v
->declspec.type
;
1659 if
(sizes
) LIST_FOR_EACH_ENTRY
(dim
, sizes
, expr_t
, entry
)
1661 if
(dim
->type
!= EXPR_VOID
)
1663 if
(is_array
(*ptype
))
1665 if
(!type_array_get_conformance
(*ptype
) ||
1666 type_array_get_conformance
(*ptype
)->type
!= EXPR_VOID
)
1667 error_loc
("%s: cannot specify size_is for an already sized array\n", v
->name
);
1669 *ptype
= type_new_array
((*ptype
)->name
,
1670 type_array_get_element
(*ptype
), FALSE
,
1673 else if
(is_ptr
(*ptype
))
1674 *ptype
= type_new_array
((*ptype
)->name
, type_pointer_get_ref
(*ptype
), TRUE
,
1677 error_loc
("%s: size_is attribute applied to illegal type\n", v
->name
);
1681 ptype
= &(*ptype
)->details.pointer.ref.type
;
1682 else if
(is_array
(*ptype
))
1683 ptype
= &(*ptype
)->details.array.elem.type
;
1685 error_loc
("%s: too many expressions in size_is attribute\n", v
->name
);
1688 ptype
= &v
->declspec.type
;
1689 if
(lengs
) LIST_FOR_EACH_ENTRY
(dim
, lengs
, expr_t
, entry
)
1691 if
(dim
->type
!= EXPR_VOID
)
1693 if
(is_array
(*ptype
))
1695 *ptype
= type_new_array
((*ptype
)->name
,
1696 type_array_get_element
(*ptype
),
1697 type_array_is_decl_as_ptr
(*ptype
),
1698 type_array_get_dim
(*ptype
),
1699 type_array_get_conformance
(*ptype
), dim
);
1702 error_loc
("%s: length_is attribute applied to illegal type\n", v
->name
);
1706 ptype
= &(*ptype
)->details.pointer.ref.type
;
1707 else if
(is_array
(*ptype
))
1708 ptype
= &(*ptype
)->details.array.elem.type
;
1710 error_loc
("%s: too many expressions in length_is attribute\n", v
->name
);
1714 v
->declspec.type
= type_new_bitfield
(v
->declspec.type
, decl
->bits
);
1719 static var_list_t
*set_var_types
(attr_list_t
*attrs
, decl_spec_t
*decl_spec
, declarator_list_t
*decls
)
1721 declarator_t
*decl
, *next
;
1722 var_list_t
*var_list
= NULL
;
1724 LIST_FOR_EACH_ENTRY_SAFE
( decl
, next
, decls
, declarator_t
, entry
)
1726 var_t
*var
= declare_var
(attrs
, decl_spec
, decl
, 0);
1727 var_list
= append_var
(var_list
, var
);
1734 static ifref_list_t
*append_ifref
(ifref_list_t
*list
, ifref_t
*iface
)
1736 if
(!iface
) return list
;
1739 list
= xmalloc
( sizeof
(*list
) );
1742 list_add_tail
( list
, &iface
->entry
);
1746 static ifref_t
*make_ifref
(type_t
*iface
)
1748 ifref_t
*l
= xmalloc
(sizeof
(ifref_t
));
1754 var_list_t
*append_var
(var_list_t
*list
, var_t
*var
)
1756 if
(!var
) return list
;
1759 list
= xmalloc
( sizeof
(*list
) );
1762 list_add_tail
( list
, &var
->entry
);
1766 static var_list_t
*append_var_list
(var_list_t
*list
, var_list_t
*vars
)
1768 if
(!vars
) return list
;
1771 list
= xmalloc
( sizeof
(*list
) );
1774 list_move_tail
( list
, vars
);
1778 var_t
*make_var
(char *name
)
1780 var_t
*v
= xmalloc
(sizeof
(var_t
));
1782 init_declspec
(&v
->declspec
, NULL
);
1785 init_loc_info
(&v
->loc_info
);
1786 v
->declonly
= FALSE
;
1790 static var_t
*copy_var
(var_t
*src
, char *name
, map_attrs_filter_t attr_filter
)
1792 var_t
*v
= xmalloc
(sizeof
(var_t
));
1794 v
->declspec
= src
->declspec
;
1795 v
->attrs
= map_attrs
(src
->attrs
, attr_filter
);
1796 v
->eval
= src
->eval
;
1797 v
->loc_info
= src
->loc_info
;
1801 static declarator_list_t
*append_declarator
(declarator_list_t
*list
, declarator_t
*d
)
1803 if
(!d
) return list
;
1805 list
= xmalloc
(sizeof
(*list
));
1808 list_add_tail
(list
, &d
->entry
);
1812 static declarator_t
*make_declarator
(var_t
*var
)
1814 declarator_t
*d
= xmalloc
(sizeof
(*d
));
1815 d
->var
= var ? var
: make_var
(NULL
);
1822 static type_t
*make_safearray
(type_t
*type
)
1824 decl_spec_t ds
= {.type
= type
};
1825 ds.type
= type_new_alias
(&ds
, "SAFEARRAY");
1826 return type_new_array
(NULL
, &ds
, TRUE
, 0, NULL
, NULL
);
1829 static typelib_t
*make_library
(const char *name
, const attr_list_t
*attrs
)
1831 typelib_t
*typelib
= xmalloc
(sizeof
(*typelib
));
1832 memset
(typelib
, 0, sizeof
(*typelib
));
1833 typelib
->name
= xstrdup
(name
);
1834 typelib
->attrs
= attrs
;
1835 list_init
( &typelib
->importlibs
);
1839 static int hash_ident
(const char *name
)
1841 const char *p
= name
;
1843 /* a simple sum hash is probably good enough */
1848 return sum
& (HASHMAX
-1);
1851 /***** type repository *****/
1853 static struct namespace
*find_sub_namespace
(struct namespace
*namespace
, const char *name
)
1855 struct namespace
*cur
;
1857 LIST_FOR_EACH_ENTRY
(cur
, &namespace
->children
, struct namespace
, entry
) {
1858 if
(!strcmp
(cur
->name
, name
))
1865 static void push_namespace
(const char *name
)
1867 struct namespace
*namespace
;
1869 namespace
= find_sub_namespace
(current_namespace
, name
);
1871 namespace
= xmalloc
(sizeof
(*namespace
));
1872 namespace
->name
= xstrdup
(name
);
1873 namespace
->parent
= current_namespace
;
1874 list_add_tail
(¤t_namespace
->children
, &namespace
->entry
);
1875 list_init
(&namespace
->children
);
1876 memset
(namespace
->type_hash
, 0, sizeof
(namespace
->type_hash
));
1879 current_namespace
= namespace
;
1882 static void pop_namespace
(const char *name
)
1884 assert
(!strcmp
(current_namespace
->name
, name
) && current_namespace
->parent
);
1885 current_namespace
= current_namespace
->parent
;
1888 static void init_lookup_namespace
(const char *name
)
1890 if
(!(lookup_namespace
= find_sub_namespace
(&global_namespace
, name
)))
1891 error_loc
("namespace '%s' not found\n", name
);
1894 static void push_lookup_namespace
(const char *name
)
1896 struct namespace
*namespace
;
1897 if
(!(namespace
= find_sub_namespace
(lookup_namespace
, name
)))
1898 error_loc
("namespace '%s' not found\n", name
);
1899 lookup_namespace
= namespace
;
1909 type_t
*reg_type
(type_t
*type
, const char *name
, struct namespace
*namespace
, int t
)
1914 error_loc
("registering named type without name\n");
1918 namespace
= &global_namespace
;
1919 hash
= hash_ident
(name
);
1920 nt
= xmalloc
(sizeof
(struct rtype
));
1922 if
(is_global_namespace
(namespace
))
1923 type
->c_name
= name
;
1925 type
->c_name
= format_namespace
(namespace
, "__x_", "_C", name
);
1928 nt
->next
= namespace
->type_hash
[hash
];
1929 namespace
->type_hash
[hash
] = nt
;
1933 static type_t
*reg_typedefs
(decl_spec_t
*decl_spec
, declarator_list_t
*decls
, attr_list_t
*attrs
)
1936 type_t
*type
= decl_spec
->type
;
1938 if
(is_attr
(attrs
, ATTR_UUID
) && !is_attr
(attrs
, ATTR_PUBLIC
))
1939 attrs
= append_attr
( attrs
, make_attr
(ATTR_PUBLIC
) );
1941 /* We must generate names for tagless enum, struct or union.
1942 Typedef-ing a tagless enum, struct or union means we want the typedef
1943 to be included in a library hence the public attribute. */
1944 if
(type_get_type_detect_alias
(type
) == TYPE_ENUM ||
1945 type_get_type_detect_alias
(type
) == TYPE_STRUCT ||
1946 type_get_type_detect_alias
(type
) == TYPE_UNION ||
1947 type_get_type_detect_alias
(type
) == TYPE_ENCAPSULATED_UNION
)
1951 type
->name
= gen_name
();
1952 if
(!is_attr
(attrs
, ATTR_PUBLIC
))
1953 attrs
= append_attr
(attrs
, make_attr
(ATTR_PUBLIC
));
1956 /* replace existing attributes when generating a typelib */
1958 type
->attrs
= attrs
;
1961 LIST_FOR_EACH_ENTRY
( decl
, decls
, declarator_t
, entry
)
1964 if
(decl
->var
->name
) {
1968 cur
= find_type
(decl
->var
->name
, current_namespace
, 0);
1971 * MIDL allows shadowing types that are declared in imported files.
1972 * We don't throw an error in this case and instead add a new type
1973 * (which is earlier on the list in hash table, so it will be used
1974 * instead of shadowed type).
1976 * FIXME: We may consider string separated type tables for each input
1977 * for cleaner solution.
1979 if
(cur
&& input_name
== cur
->loc_info.input_name
)
1980 error_loc
("%s: redefinition error; original definition was at %s:%d\n",
1981 cur
->name
, cur
->loc_info.input_name
,
1982 cur
->loc_info.line_number
);
1984 name
= declare_var
(attrs
, decl_spec
, decl
, 0);
1985 cur
= type_new_alias
(&name
->declspec
, name
->name
);
1988 reg_type
(cur
, cur
->name
, current_namespace
, 0);
1994 type_t
*find_type
(const char *name
, struct namespace
*namespace
, int t
)
1998 if
(namespace
&& namespace
!= &global_namespace
) {
1999 for
(cur
= namespace
->type_hash
[hash_ident
(name
)]; cur
; cur
= cur
->next
) {
2000 if
(cur
->t
== t
&& !strcmp
(cur
->name
, name
))
2004 for
(cur
= global_namespace.type_hash
[hash_ident
(name
)]; cur
; cur
= cur
->next
) {
2005 if
(cur
->t
== t
&& !strcmp
(cur
->name
, name
))
2011 static type_t
*find_type_or_error
(const char *name
, int t
)
2014 if
(!(type
= find_type
(name
, current_namespace
, t
)) &&
2015 !(type
= find_type
(name
, lookup_namespace
, t
)))
2017 error_loc
("type '%s' not found\n", name
);
2023 static type_t
*find_type_or_error2
(char *name
, int t
)
2025 type_t
*tp
= find_type_or_error
(name
, t
);
2030 int is_type
(const char *name
)
2032 return find_type
(name
, current_namespace
, 0) != NULL ||
2033 find_type
(name
, lookup_namespace
, 0) != NULL
;
2036 int is_namespace
(const char *name
)
2038 if
(!winrt_mode
) return
0;
2039 return find_sub_namespace
(current_namespace
, name
) != NULL ||
2040 find_sub_namespace
(&global_namespace
, name
) != NULL
;
2043 type_t
*get_type
(enum type_type type
, char *name
, struct namespace
*namespace
, int t
)
2047 namespace
= &global_namespace
;
2049 tp
= find_type
(name
, namespace
, t
);
2055 tp
= make_type
(type
);
2057 tp
->namespace
= namespace
;
2058 if
(!name
) return tp
;
2059 return reg_type
(tp
, name
, namespace
, t
);
2062 /***** constant repository *****/
2067 struct rconst
*next
;
2070 struct rconst
*const_hash
[HASHMAX
];
2072 static var_t
*reg_const
(var_t
*var
)
2077 error_loc
("registering constant without name\n");
2080 hash
= hash_ident
(var
->name
);
2081 nc
= xmalloc
(sizeof
(struct rconst
));
2082 nc
->name
= var
->name
;
2084 nc
->next
= const_hash
[hash
];
2085 const_hash
[hash
] = nc
;
2089 var_t
*find_const
(const char *name
, int f
)
2091 struct rconst
*cur
= const_hash
[hash_ident
(name
)];
2092 while
(cur
&& strcmp
(cur
->name
, name
))
2095 if
(f
) error_loc
("constant '%s' not found\n", name
);
2101 char *gen_name
(void)
2103 static unsigned long n
= 0;
2104 static const char *file_id
;
2108 char *dst
= dup_basename
(input_idl_name
, ".idl");
2112 if
(! isalnum
((unsigned char) *dst
))
2115 return strmake
("__WIDL_%s_generated_name_%08lX", file_id
, n
++);
2120 unsigned int dce_compatible
: 1;
2121 unsigned int acf
: 1;
2122 unsigned int multiple
: 1;
2124 unsigned int on_interface
: 1;
2125 unsigned int on_function
: 1;
2126 unsigned int on_arg
: 1;
2127 unsigned int on_type
: 1;
2128 unsigned int on_enum
: 1;
2129 unsigned int on_enum_member
: 1;
2130 unsigned int on_struct
: 2;
2131 unsigned int on_union
: 1;
2132 unsigned int on_field
: 1;
2133 unsigned int on_library
: 1;
2134 unsigned int on_dispinterface
: 1;
2135 unsigned int on_module
: 1;
2136 unsigned int on_coclass
: 1;
2137 const char *display_name
;
2140 struct allowed_attr allowed_attr
[] =
2142 /* attr { D ACF M I Fn ARG T En Enm St Un Fi L DI M C <display name> } */
2143 /* ATTR_AGGREGATABLE */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "aggregatable" },
2144 /* ATTR_ALLOCATE */ { 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "allocate" },
2145 /* ATTR_ANNOTATION */ { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "annotation" },
2146 /* ATTR_APPOBJECT */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "appobject" },
2147 /* ATTR_ASYNC */ { 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "async" },
2148 /* ATTR_ASYNCUUID */ { 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, "async_uuid" },
2149 /* ATTR_AUTO_HANDLE */ { 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "auto_handle" },
2150 /* ATTR_BINDABLE */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "bindable" },
2151 /* ATTR_BROADCAST */ { 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "broadcast" },
2152 /* ATTR_CALLAS */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "call_as" },
2153 /* ATTR_CALLCONV */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL
},
2154 /* ATTR_CASE */ { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, "case" },
2155 /* ATTR_CODE */ { 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "code" },
2156 /* ATTR_COMMSTATUS */ { 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "comm_status" },
2157 /* ATTR_CONTEXTHANDLE */ { 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "context_handle" },
2158 /* ATTR_CONTROL */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, "control" },
2159 /* ATTR_CUSTOM */ { 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, "custom" },
2160 /* ATTR_DECODE */ { 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "decode" },
2161 /* ATTR_DEFAULT */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, "default" },
2162 /* ATTR_DEFAULTBIND */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "defaultbind" },
2163 /* ATTR_DEFAULTCOLLELEM */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "defaultcollelem" },
2164 /* ATTR_DEFAULTVALUE */ { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "defaultvalue" },
2165 /* ATTR_DEFAULTVTABLE */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "defaultvtable" },
2166 /* ATTR_DISABLECONSISTENCYCHECK */{ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "disable_consistency_check" },
2167 /* ATTR_DISPINTERFACE */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL
},
2168 /* ATTR_DISPLAYBIND */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "displaybind" },
2169 /* ATTR_DLLNAME */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, "dllname" },
2170 /* ATTR_DUAL */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "dual" },
2171 /* ATTR_ENABLEALLOCATE */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "enable_allocate" },
2172 /* ATTR_ENCODE */ { 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "encode" },
2173 /* ATTR_ENDPOINT */ { 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "endpoint" },
2174 /* ATTR_ENTRY */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "entry" },
2175 /* ATTR_EXPLICIT_HANDLE */ { 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "explicit_handle" },
2176 /* ATTR_FAULTSTATUS */ { 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "fault_status" },
2177 /* ATTR_FORCEALLOCATE */ { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "force_allocate" },
2178 /* ATTR_HANDLE */ { 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "handle" },
2179 /* ATTR_HELPCONTEXT */ { 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, "helpcontext" },
2180 /* ATTR_HELPFILE */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, "helpfile" },
2181 /* ATTR_HELPSTRING */ { 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, "helpstring" },
2182 /* ATTR_HELPSTRINGCONTEXT */ { 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, "helpstringcontext" },
2183 /* ATTR_HELPSTRINGDLL */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, "helpstringdll" },
2184 /* ATTR_HIDDEN */ { 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, "hidden" },
2185 /* ATTR_ID */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, "id" },
2186 /* ATTR_IDEMPOTENT */ { 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "idempotent" },
2187 /* ATTR_IGNORE */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, "ignore" },
2188 /* ATTR_IIDIS */ { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, "iid_is" },
2189 /* ATTR_IMMEDIATEBIND */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "immediatebind" },
2190 /* ATTR_IMPLICIT_HANDLE */ { 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "implicit_handle" },
2191 /* ATTR_IN */ { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "in" },
2192 /* ATTR_INPUTSYNC */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "inputsync" },
2193 /* ATTR_LENGTHIS */ { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, "length_is" },
2194 /* ATTR_LIBLCID */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, "lcid" },
2195 /* ATTR_LICENSED */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "licensed" },
2196 /* ATTR_LOCAL */ { 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "local" },
2197 /* ATTR_MAYBE */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "maybe" },
2198 /* ATTR_MESSAGE */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "message" },
2199 /* ATTR_NOCODE */ { 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "nocode" },
2200 /* ATTR_NONBROWSABLE */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "nonbrowsable" },
2201 /* ATTR_NONCREATABLE */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "noncreatable" },
2202 /* ATTR_NONEXTENSIBLE */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "nonextensible" },
2203 /* ATTR_NOTIFY */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "notify" },
2204 /* ATTR_NOTIFYFLAG */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "notify_flag" },
2205 /* ATTR_OBJECT */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "object" },
2206 /* ATTR_ODL */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, "odl" },
2207 /* ATTR_OLEAUTOMATION */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "oleautomation" },
2208 /* ATTR_OPTIMIZE */ { 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "optimize" },
2209 /* ATTR_OPTIONAL */ { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "optional" },
2210 /* ATTR_OUT */ { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "out" },
2211 /* ATTR_PARAMLCID */ { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "lcid" },
2212 /* ATTR_PARTIALIGNORE */ { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "partial_ignore" },
2213 /* ATTR_POINTERDEFAULT */ { 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "pointer_default" },
2214 /* ATTR_POINTERTYPE */ { 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, "ref, unique or ptr" },
2215 /* ATTR_PROGID */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "progid" },
2216 /* ATTR_PROPGET */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "propget" },
2217 /* ATTR_PROPPUT */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "propput" },
2218 /* ATTR_PROPPUTREF */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "propputref" },
2219 /* ATTR_PROXY */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "proxy" },
2220 /* ATTR_PUBLIC */ { 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "public" },
2221 /* ATTR_RANGE */ { 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, "range" },
2222 /* ATTR_READONLY */ { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, "readonly" },
2223 /* ATTR_REPRESENTAS */ { 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "represent_as" },
2224 /* ATTR_REQUESTEDIT */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "requestedit" },
2225 /* ATTR_RESTRICTED */ { 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, "restricted" },
2226 /* ATTR_RETVAL */ { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "retval" },
2227 /* ATTR_SIZEIS */ { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, "size_is" },
2228 /* ATTR_SOURCE */ { 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, "source" },
2229 /* ATTR_STRICTCONTEXTHANDLE */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "strict_context_handle" },
2230 /* ATTR_STRING */ { 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, "string" },
2231 /* ATTR_SWITCHIS */ { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, "switch_is" },
2232 /* ATTR_SWITCHTYPE */ { 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, "switch_type" },
2233 /* ATTR_THREADING */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "threading" },
2234 /* ATTR_TRANSMITAS */ { 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "transmit_as" },
2235 /* ATTR_UIDEFAULT */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "uidefault" },
2236 /* ATTR_USESGETLASTERROR */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "usesgetlasterror" },
2237 /* ATTR_USERMARSHAL */ { 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "user_marshal" },
2238 /* ATTR_UUID */ { 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, "uuid" },
2239 /* ATTR_V1ENUM */ { 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, "v1_enum" },
2240 /* ATTR_VARARG */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "vararg" },
2241 /* ATTR_VERSION */ { 1, 0, 0, 1, 0, 0, 1, 1, 0, 2, 0, 0, 1, 0, 0, 1, "version" },
2242 /* ATTR_VIPROGID */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "vi_progid" },
2243 /* ATTR_WIREMARSHAL */ { 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "wire_marshal" },
2246 static attr_list_t
*append_attr
(attr_list_t
*list
, attr_t
*attr
)
2248 attr_t
*attr_existing
;
2249 if
(!attr
) return list
;
2252 list
= xmalloc
( sizeof
(*list
) );
2255 if
(!allowed_attr
[attr
->type
].multiple
)
2257 LIST_FOR_EACH_ENTRY
(attr_existing
, list
, attr_t
, entry
)
2258 if
(attr_existing
->type
== attr
->type
)
2260 parser_warning
("duplicate attribute %s\n", get_attr_display_name
(attr
->type
));
2261 /* use the last attribute, like MIDL does */
2262 list_remove
(&attr_existing
->entry
);
2266 list_add_tail
( list
, &attr
->entry
);
2270 const char *get_attr_display_name
(enum attr_type type
)
2272 return allowed_attr
[type
].display_name
;
2275 static attr_list_t
*check_iface_attrs
(const char *name
, attr_list_t
*attrs
)
2278 if
(!attrs
) return attrs
;
2279 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2281 if
(!allowed_attr
[attr
->type
].on_interface
)
2282 error_loc
("inapplicable attribute %s for interface %s\n",
2283 allowed_attr
[attr
->type
].display_name
, name
);
2284 if
(attr
->type
== ATTR_IMPLICIT_HANDLE
)
2286 const var_t
*var
= attr
->u.pval
;
2287 if
(type_get_type
( var
->declspec.type
) == TYPE_BASIC
&&
2288 type_basic_get_type
( var
->declspec.type
) == TYPE_BASIC_HANDLE
)
2290 if
(is_aliaschain_attr
( var
->declspec.type
, ATTR_HANDLE
))
2292 error_loc
("attribute %s requires a handle type in interface %s\n",
2293 allowed_attr
[attr
->type
].display_name
, name
);
2299 static attr_list_t
*check_function_attrs
(const char *name
, attr_list_t
*attrs
)
2302 if
(!attrs
) return attrs
;
2303 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2305 if
(!allowed_attr
[attr
->type
].on_function
)
2306 error_loc
("inapplicable attribute %s for function %s\n",
2307 allowed_attr
[attr
->type
].display_name
, name
);
2312 static void check_arg_attrs
(const var_t
*arg
)
2318 LIST_FOR_EACH_ENTRY
(attr
, arg
->attrs
, const attr_t
, entry
)
2320 if
(!allowed_attr
[attr
->type
].on_arg
)
2321 error_loc
("inapplicable attribute %s for argument %s\n",
2322 allowed_attr
[attr
->type
].display_name
, arg
->name
);
2327 static attr_list_t
*check_typedef_attrs
(attr_list_t
*attrs
)
2330 if
(!attrs
) return attrs
;
2331 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2333 if
(!allowed_attr
[attr
->type
].on_type
)
2334 error_loc
("inapplicable attribute %s for typedef\n",
2335 allowed_attr
[attr
->type
].display_name
);
2340 static attr_list_t
*check_enum_attrs
(attr_list_t
*attrs
)
2343 if
(!attrs
) return attrs
;
2344 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2346 if
(!allowed_attr
[attr
->type
].on_enum
)
2347 error_loc
("inapplicable attribute %s for enum\n",
2348 allowed_attr
[attr
->type
].display_name
);
2353 static attr_list_t
*check_enum_member_attrs
(attr_list_t
*attrs
)
2356 if
(!attrs
) return attrs
;
2357 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2359 if
(!allowed_attr
[attr
->type
].on_enum_member
)
2360 error_loc
("inapplicable attribute %s for enum member\n",
2361 allowed_attr
[attr
->type
].display_name
);
2366 static attr_list_t
*check_struct_attrs
(attr_list_t
*attrs
)
2368 int mask
= winrt_mode ?
3 : 1;
2370 if
(!attrs
) return attrs
;
2371 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2373 if
(!(allowed_attr
[attr
->type
].on_struct
& mask
))
2374 error_loc
("inapplicable attribute %s for struct\n",
2375 allowed_attr
[attr
->type
].display_name
);
2380 static attr_list_t
*check_union_attrs
(attr_list_t
*attrs
)
2383 if
(!attrs
) return attrs
;
2384 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2386 if
(!allowed_attr
[attr
->type
].on_union
)
2387 error_loc
("inapplicable attribute %s for union\n",
2388 allowed_attr
[attr
->type
].display_name
);
2393 static attr_list_t
*check_field_attrs
(const char *name
, attr_list_t
*attrs
)
2396 if
(!attrs
) return attrs
;
2397 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2399 if
(!allowed_attr
[attr
->type
].on_field
)
2400 error_loc
("inapplicable attribute %s for field %s\n",
2401 allowed_attr
[attr
->type
].display_name
, name
);
2406 static attr_list_t
*check_library_attrs
(const char *name
, attr_list_t
*attrs
)
2409 if
(!attrs
) return attrs
;
2410 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2412 if
(!allowed_attr
[attr
->type
].on_library
)
2413 error_loc
("inapplicable attribute %s for library %s\n",
2414 allowed_attr
[attr
->type
].display_name
, name
);
2419 static attr_list_t
*check_dispiface_attrs
(const char *name
, attr_list_t
*attrs
)
2422 if
(!attrs
) return attrs
;
2423 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2425 if
(!allowed_attr
[attr
->type
].on_dispinterface
)
2426 error_loc
("inapplicable attribute %s for dispinterface %s\n",
2427 allowed_attr
[attr
->type
].display_name
, name
);
2432 static attr_list_t
*check_module_attrs
(const char *name
, attr_list_t
*attrs
)
2435 if
(!attrs
) return attrs
;
2436 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2438 if
(!allowed_attr
[attr
->type
].on_module
)
2439 error_loc
("inapplicable attribute %s for module %s\n",
2440 allowed_attr
[attr
->type
].display_name
, name
);
2445 static attr_list_t
*check_coclass_attrs
(const char *name
, attr_list_t
*attrs
)
2448 if
(!attrs
) return attrs
;
2449 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2451 if
(!allowed_attr
[attr
->type
].on_coclass
)
2452 error_loc
("inapplicable attribute %s for coclass %s\n",
2453 allowed_attr
[attr
->type
].display_name
, name
);
2458 static int is_allowed_conf_type
(const type_t
*type
)
2460 switch
(type_get_type
(type
))
2465 switch
(type_basic_get_type
(type
))
2467 case TYPE_BASIC_INT8
:
2468 case TYPE_BASIC_INT16
:
2469 case TYPE_BASIC_INT32
:
2470 case TYPE_BASIC_INT64
:
2471 case TYPE_BASIC_INT
:
2472 case TYPE_BASIC_LONG
:
2473 case TYPE_BASIC_CHAR
:
2474 case TYPE_BASIC_HYPER
:
2475 case TYPE_BASIC_BYTE
:
2476 case TYPE_BASIC_WCHAR
:
2482 /* shouldn't get here because of type_get_type call above */
2487 case TYPE_ENCAPSULATED_UNION
:
2494 case TYPE_INTERFACE
:
2501 static int is_ptr_guid_type
(const type_t
*type
)
2503 /* first, make sure it is a pointer to something */
2504 if
(!is_ptr
(type
)) return FALSE
;
2506 /* second, make sure it is a pointer to something of size sizeof(GUID),
2508 return
(type_memsize
(type_pointer_get_ref_type
(type
)) == 16);
2511 static void check_conformance_expr_list
(const char *attr_name
, const var_t
*arg
, const type_t
*container_type
, expr_list_t
*expr_list
)
2514 struct expr_loc expr_loc
;
2516 expr_loc.attr
= attr_name
;
2517 if
(expr_list
) LIST_FOR_EACH_ENTRY
(dim
, expr_list
, expr_t
, entry
)
2519 if
(dim
->type
!= EXPR_VOID
)
2521 const type_t
*expr_type
= expr_resolve_type
(&expr_loc
, container_type
, dim
);
2522 if
(!is_allowed_conf_type
(expr_type
))
2523 error_loc_info
(&arg
->loc_info
, "expression must resolve to integral type <= 32bits for attribute %s\n",
2529 static void check_remoting_fields
(const var_t
*var
, type_t
*type
);
2531 /* checks that properties common to fields and arguments are consistent */
2532 static void check_field_common
(const type_t
*container_type
,
2533 const char *container_name
, const var_t
*arg
)
2535 type_t
*type
= arg
->declspec.type
;
2537 const char *container_type_name
;
2538 const char *var_type
;
2540 switch
(type_get_type
(container_type
))
2543 container_type_name
= "struct";
2547 container_type_name
= "union";
2550 case TYPE_ENCAPSULATED_UNION
:
2551 container_type_name
= "encapsulated union";
2555 container_type_name
= "function";
2556 var_type
= "parameter";
2559 /* should be no other container types */
2564 if
(is_attr
(arg
->attrs
, ATTR_LENGTHIS
) &&
2565 (is_attr
(arg
->attrs
, ATTR_STRING
) || is_aliaschain_attr
(arg
->declspec.type
, ATTR_STRING
)))
2566 error_loc_info
(&arg
->loc_info
,
2567 "string and length_is specified for argument %s are mutually exclusive attributes\n",
2570 if
(is_attr
(arg
->attrs
, ATTR_SIZEIS
))
2572 expr_list_t
*size_is_exprs
= get_attrp
(arg
->attrs
, ATTR_SIZEIS
);
2573 check_conformance_expr_list
("size_is", arg
, container_type
, size_is_exprs
);
2575 if
(is_attr
(arg
->attrs
, ATTR_LENGTHIS
))
2577 expr_list_t
*length_is_exprs
= get_attrp
(arg
->attrs
, ATTR_LENGTHIS
);
2578 check_conformance_expr_list
("length_is", arg
, container_type
, length_is_exprs
);
2580 if
(is_attr
(arg
->attrs
, ATTR_IIDIS
))
2582 struct expr_loc expr_loc
;
2583 expr_t
*expr
= get_attrp
(arg
->attrs
, ATTR_IIDIS
);
2584 if
(expr
->type
!= EXPR_VOID
)
2586 const type_t
*expr_type
;
2588 expr_loc.attr
= "iid_is";
2589 expr_type
= expr_resolve_type
(&expr_loc
, container_type
, expr
);
2590 if
(!expr_type ||
!is_ptr_guid_type
(expr_type
))
2591 error_loc_info
(&arg
->loc_info
, "expression must resolve to pointer to GUID type for attribute iid_is\n");
2594 if
(is_attr
(arg
->attrs
, ATTR_SWITCHIS
))
2596 struct expr_loc expr_loc
;
2597 expr_t
*expr
= get_attrp
(arg
->attrs
, ATTR_SWITCHIS
);
2598 if
(expr
->type
!= EXPR_VOID
)
2600 const type_t
*expr_type
;
2602 expr_loc.attr
= "switch_is";
2603 expr_type
= expr_resolve_type
(&expr_loc
, container_type
, expr
);
2604 if
(!expr_type ||
!is_allowed_conf_type
(expr_type
))
2605 error_loc_info
(&arg
->loc_info
, "expression must resolve to integral type <= 32bits for attribute %s\n",
2614 switch
(typegen_detect_type
(type
, arg
->attrs
, TDT_IGNORE_STRINGS
))
2618 check_remoting_fields
(arg
, type
);
2622 const char *reason
= "is invalid";
2623 switch
(type_get_type
(type
))
2626 reason
= "cannot derive from void *";
2629 reason
= "cannot be a function pointer";
2632 reason
= "cannot be a bit-field";
2635 reason
= "cannot be a class";
2637 case TYPE_INTERFACE
:
2638 reason
= "cannot be a non-pointer to an interface";
2641 reason
= "cannot be a module";
2646 error_loc_info
(&arg
->loc_info
, "%s \'%s\' of %s \'%s\' %s\n",
2647 var_type
, arg
->name
, container_type_name
, container_name
, reason
);
2650 case TGT_CTXT_HANDLE
:
2651 case TGT_CTXT_HANDLE_POINTER
:
2652 if
(type_get_type
(container_type
) != TYPE_FUNCTION
)
2653 error_loc_info
(&arg
->loc_info
,
2654 "%s \'%s\' of %s \'%s\' cannot be a context handle\n",
2655 var_type
, arg
->name
, container_type_name
,
2660 const type_t
*t
= type
;
2662 t
= type_pointer_get_ref_type
(t
);
2663 if
(is_aliaschain_attr
(t
, ATTR_RANGE
))
2664 warning_loc_info
(&arg
->loc_info
, "%s: range not verified for a string of ranged types\n", arg
->name
);
2668 type
= type_pointer_get_ref_type
(type
);
2672 type
= type_array_get_element_type
(type
);
2676 type
= type_get_real_type
(type
);
2677 if
(!type_is_complete
(type
))
2679 error_loc_info
(&arg
->loc_info
, "undefined type declaration \"enum %s\"\n", type
->name
);
2682 case TGT_IFACE_POINTER
:
2688 } while
(more_to_do
);
2691 static void check_remoting_fields
(const var_t
*var
, type_t
*type
)
2694 const var_list_t
*fields
= NULL
;
2696 type
= type_get_real_type
(type
);
2701 type
->checked
= TRUE
;
2703 if
(type_get_type
(type
) == TYPE_STRUCT
)
2705 if
(type_is_complete
(type
))
2706 fields
= type_struct_get_fields
(type
);
2708 error_loc_info
(&var
->loc_info
, "undefined type declaration \"struct %s\"\n", type
->name
);
2710 else if
(type_get_type
(type
) == TYPE_UNION || type_get_type
(type
) == TYPE_ENCAPSULATED_UNION
)
2712 if
(type_is_complete
(type
))
2713 fields
= type_union_get_cases
(type
);
2715 error_loc_info
(&var
->loc_info
, "undefined type declaration \"union %s\"\n", type
->name
);
2718 if
(fields
) LIST_FOR_EACH_ENTRY
( field
, fields
, const var_t
, entry
)
2719 if
(field
->declspec.type
) check_field_common
(type
, type
->name
, field
);
2722 /* checks that arguments for a function make sense for marshalling and unmarshalling */
2723 static void check_remoting_args
(const var_t
*func
)
2725 const char *funcname
= func
->name
;
2728 if
(!type_function_get_args
(func
->declspec.type
))
2731 LIST_FOR_EACH_ENTRY
( arg
, type_function_get_args
(func
->declspec.type
), const var_t
, entry
)
2733 const type_t
*type
= arg
->declspec.type
;
2735 /* check that [out] parameters have enough pointer levels */
2736 if
(is_attr
(arg
->attrs
, ATTR_OUT
))
2738 switch
(typegen_detect_type
(type
, arg
->attrs
, TDT_ALL_TYPES
))
2745 case TGT_CTXT_HANDLE
:
2747 error_loc_info
(&arg
->loc_info
, "out parameter \'%s\' of function \'%s\' is not a pointer\n", arg
->name
, funcname
);
2749 case TGT_IFACE_POINTER
:
2750 error_loc_info
(&arg
->loc_info
, "out interface pointer \'%s\' of function \'%s\' is not a double pointer\n", arg
->name
, funcname
);
2755 /* needs conformance or fixed dimension */
2756 if
(type_array_has_conformance
(type
) &&
2757 type_array_get_conformance
(type
)->type
!= EXPR_VOID
) break
;
2758 if
(!type_array_has_conformance
(type
) && type_array_get_dim
(type
)) break
;
2760 if
(is_attr
( arg
->attrs
, ATTR_IN
)) break
;
2761 error_loc_info
(&arg
->loc_info
, "out parameter \'%s\' of function \'%s\' cannot be an unsized string\n", arg
->name
, funcname
);
2764 /* already error'd before we get here */
2765 case TGT_CTXT_HANDLE_POINTER
:
2773 check_field_common
(func
->declspec.type
, funcname
, arg
);
2776 if
(type_get_type
(type_function_get_rettype
(func
->declspec.type
)) != TYPE_VOID
)
2780 var.declspec.type
= type_function_get_rettype
(func
->declspec.type
);
2781 var.name
= xstrdup
("return value");
2782 check_field_common
(func
->declspec.type
, funcname
, &var
);
2787 static void add_explicit_handle_if_necessary
(const type_t
*iface
, var_t
*func
)
2789 unsigned char explicit_fc
, implicit_fc
;
2791 /* check for a defined binding handle */
2792 if
(!get_func_handle_var
( iface
, func
, &explicit_fc
, &implicit_fc
) ||
!explicit_fc
)
2794 /* no explicit handle specified so add
2795 * "[in] handle_t IDL_handle" as the first parameter to the
2797 var_t
*idl_handle
= make_var
(xstrdup
("IDL_handle"));
2798 idl_handle
->attrs
= append_attr
(NULL
, make_attr
(ATTR_IN
));
2799 idl_handle
->declspec.type
= find_type_or_error
("handle_t", 0);
2800 type_function_add_head_arg
(func
->declspec.type
, idl_handle
);
2804 static void check_functions
(const type_t
*iface
, int is_inside_library
)
2806 const statement_t
*stmt
;
2807 /* check for duplicates */
2808 if
(is_attr
(iface
->attrs
, ATTR_DISPINTERFACE
))
2810 var_list_t
*methods
= type_dispiface_get_methods
(iface
);
2811 var_t
*func
, *func_iter
;
2813 if
(methods
) LIST_FOR_EACH_ENTRY
( func
, methods
, var_t
, entry
)
2815 LIST_FOR_EACH_ENTRY
( func_iter
, methods
, var_t
, entry
)
2817 if
(func
== func_iter
) break
;
2818 if
(strcmp
(func
->name
, func_iter
->name
)) continue
;
2819 if
(is_attr
(func
->attrs
, ATTR_PROPGET
) != is_attr
(func_iter
->attrs
, ATTR_PROPGET
)) continue
;
2820 if
(is_attr
(func
->attrs
, ATTR_PROPPUT
) != is_attr
(func_iter
->attrs
, ATTR_PROPPUT
)) continue
;
2821 if
(is_attr
(func
->attrs
, ATTR_PROPPUTREF
) != is_attr
(func_iter
->attrs
, ATTR_PROPPUTREF
)) continue
;
2822 error_loc_info
(&func
->loc_info
, "duplicated function \'%s\'\n", func
->name
);
2826 if
(is_attr
(iface
->attrs
, ATTR_EXPLICIT_HANDLE
))
2828 STATEMENTS_FOR_EACH_FUNC
( stmt
, type_iface_get_stmts
(iface
) )
2830 var_t
*func
= stmt
->u.var
;
2831 add_explicit_handle_if_necessary
(iface
, func
);
2834 if
(!is_inside_library
&& !is_attr
(iface
->attrs
, ATTR_LOCAL
))
2836 STATEMENTS_FOR_EACH_FUNC
( stmt
, type_iface_get_stmts
(iface
) )
2838 const var_t
*func
= stmt
->u.var
;
2839 if
(!is_attr
(func
->attrs
, ATTR_LOCAL
))
2840 check_remoting_args
(func
);
2845 static int async_iface_attrs
(attr_list_t
*attrs
, const attr_t
*attr
)
2851 case ATTR_ASYNCUUID
:
2852 append_attr
(attrs
, make_attrp
(ATTR_UUID
, attr
->u.pval
));
2859 static int arg_in_attrs
(attr_list_t
*attrs
, const attr_t
*attr
)
2861 return attr
->type
!= ATTR_OUT
&& attr
->type
!= ATTR_RETVAL
;
2864 static int arg_out_attrs
(attr_list_t
*attrs
, const attr_t
*attr
)
2866 return attr
->type
!= ATTR_IN
;
2869 static void check_async_uuid
(type_t
*iface
)
2871 statement_list_t
*stmts
= NULL
;
2873 type_t
*async_iface
;
2876 if
(!is_attr
(iface
->attrs
, ATTR_ASYNCUUID
)) return
;
2878 inherit
= type_iface_get_inherit
(iface
);
2879 if
(inherit
&& strcmp
(inherit
->name
, "IUnknown"))
2880 inherit
= type_iface_get_async_iface
(inherit
);
2882 error_loc
("async_uuid applied to an interface with incompatible parent\n");
2884 async_iface
= get_type
(TYPE_INTERFACE
, strmake
("Async%s", iface
->name
), iface
->namespace
, 0);
2885 async_iface
->attrs
= map_attrs
(iface
->attrs
, async_iface_attrs
);
2887 STATEMENTS_FOR_EACH_FUNC
( stmt
, type_iface_get_stmts
(iface
) )
2889 var_t
*begin_func
, *finish_func
, *func
= stmt
->u.var
, *arg
;
2890 var_list_t
*begin_args
= NULL
, *finish_args
= NULL
, *args
;
2892 args
= type_function_get_args
(func
->declspec.type
);
2893 if
(args
) LIST_FOR_EACH_ENTRY
(arg
, args
, var_t
, entry
)
2895 if
(is_attr
(arg
->attrs
, ATTR_IN
) ||
!is_attr
(arg
->attrs
, ATTR_OUT
))
2896 begin_args
= append_var
(begin_args
, copy_var
(arg
, strdup
(arg
->name
), arg_in_attrs
));
2897 if
(is_attr
(arg
->attrs
, ATTR_OUT
))
2898 finish_args
= append_var
(finish_args
, copy_var
(arg
, strdup
(arg
->name
), arg_out_attrs
));
2901 begin_func
= copy_var
(func
, strmake
("Begin_%s", func
->name
), NULL
);
2902 begin_func
->declspec.type
= type_new_function
(begin_args
);
2903 begin_func
->declspec.type
->attrs
= func
->attrs
;
2904 begin_func
->declspec.type
->details.function
->retval
= func
->declspec.type
->details.function
->retval
;
2905 stmts
= append_statement
(stmts
, make_statement_declaration
(begin_func
));
2907 finish_func
= copy_var
(func
, strmake
("Finish_%s", func
->name
), NULL
);
2908 finish_func
->declspec.type
= type_new_function
(finish_args
);
2909 finish_func
->declspec.type
->attrs
= func
->attrs
;
2910 finish_func
->declspec.type
->details.function
->retval
= func
->declspec.type
->details.function
->retval
;
2911 stmts
= append_statement
(stmts
, make_statement_declaration
(finish_func
));
2914 type_interface_define
(async_iface
, inherit
, stmts
);
2915 iface
->details.iface
->async_iface
= async_iface
->details.iface
->async_iface
= async_iface
;
2918 static void check_statements
(const statement_list_t
*stmts
, int is_inside_library
)
2920 const statement_t
*stmt
;
2922 if
(stmts
) LIST_FOR_EACH_ENTRY
(stmt
, stmts
, const statement_t
, entry
)
2924 switch
(stmt
->type
) {
2926 check_statements
(stmt
->u.lib
->stmts
, TRUE
);
2929 switch
(type_get_type
(stmt
->u.type
)) {
2930 case TYPE_INTERFACE
:
2931 check_functions
(stmt
->u.type
, is_inside_library
);
2935 error_loc
("coclass is not allowed in Windows Runtime mode\n");
2947 static void check_all_user_types
(const statement_list_t
*stmts
)
2949 const statement_t
*stmt
;
2952 if
(stmts
) LIST_FOR_EACH_ENTRY
(stmt
, stmts
, const statement_t
, entry
)
2954 if
(stmt
->type
== STMT_LIBRARY
)
2955 check_all_user_types
(stmt
->u.lib
->stmts
);
2956 else if
(stmt
->type
== STMT_TYPE
&& type_get_type
(stmt
->u.type
) == TYPE_INTERFACE
&&
2957 !is_local
(stmt
->u.type
->attrs
))
2959 const statement_t
*stmt_func
;
2960 STATEMENTS_FOR_EACH_FUNC
(stmt_func
, type_iface_get_stmts
(stmt
->u.type
)) {
2961 const var_t
*func
= stmt_func
->u.var
;
2962 if
(type_function_get_args
(func
->declspec.type
))
2963 LIST_FOR_EACH_ENTRY
( v
, type_function_get_args
(func
->declspec.type
), const var_t
, entry
)
2964 check_for_additional_prototype_types
(v
->declspec.type
);
2965 check_for_additional_prototype_types
(type_function_get_rettype
(func
->declspec.type
));
2971 int is_valid_uuid
(const char *s
)
2975 for
(i
= 0; i
< 36; ++i
)
2976 if
(i
== 8 || i
== 13 || i
== 18 || i
== 23)
2982 if
(!isxdigit
(s
[i
]))
2985 return s
[i
] == '\0';
2988 static statement_t
*make_statement
(enum statement_type type
)
2990 statement_t
*stmt
= xmalloc
(sizeof
(*stmt
));
2995 static statement_t
*make_statement_type_decl
(type_t
*type
)
2997 statement_t
*stmt
= make_statement
(STMT_TYPE
);
2998 stmt
->u.type
= type
;
2999 stmt
->declonly
= !type
->defined
;
3003 static statement_t
*make_statement_reference
(type_t
*type
)
3005 statement_t
*stmt
= make_statement
(STMT_TYPEREF
);
3006 stmt
->u.type
= type
;
3010 static statement_t
*make_statement_declaration
(var_t
*var
)
3012 statement_t
*stmt
= make_statement
(STMT_DECLARATION
);
3014 if
(var
->declspec.stgclass
== STG_EXTERN
&& var
->eval
)
3015 warning
("'%s' initialised and declared extern\n", var
->name
);
3016 if
(is_const_decl
(var
))
3021 else if
(type_get_type
(var
->declspec.type
) == TYPE_FUNCTION
)
3022 check_function_attrs
(var
->name
, var
->attrs
);
3023 else if
(var
->declspec.stgclass
== STG_NONE || var
->declspec.stgclass
== STG_REGISTER
)
3024 error_loc
("instantiation of data is illegal\n");
3028 static statement_t
*make_statement_library
(typelib_t
*typelib
)
3030 statement_t
*stmt
= make_statement
(STMT_LIBRARY
);
3031 stmt
->u.lib
= typelib
;
3035 static statement_t
*make_statement_pragma
(const char *str
)
3037 statement_t
*stmt
= make_statement
(STMT_PRAGMA
);
3042 static statement_t
*make_statement_cppquote
(const char *str
)
3044 statement_t
*stmt
= make_statement
(STMT_CPPQUOTE
);
3049 static statement_t
*make_statement_importlib
(const char *str
)
3051 statement_t
*stmt
= make_statement
(STMT_IMPORTLIB
);
3056 static statement_t
*make_statement_import
(const char *str
)
3058 statement_t
*stmt
= make_statement
(STMT_IMPORT
);
3063 static statement_t
*make_statement_module
(type_t
*type
)
3065 statement_t
*stmt
= make_statement
(STMT_MODULE
);
3066 stmt
->u.type
= type
;
3070 static statement_t
*make_statement_typedef
(declarator_list_t
*decls
, int declonly
)
3072 declarator_t
*decl
, *next
;
3074 type_list_t
**type_list
;
3076 if
(!decls
) return NULL
;
3078 stmt
= make_statement
(STMT_TYPEDEF
);
3079 stmt
->u.type_list
= NULL
;
3080 type_list
= &stmt
->u.type_list
;
3081 stmt
->declonly
= declonly
;
3083 LIST_FOR_EACH_ENTRY_SAFE
( decl
, next
, decls
, declarator_t
, entry
)
3085 var_t
*var
= decl
->var
;
3086 type_t
*type
= find_type_or_error
(var
->name
, 0);
3087 *type_list
= xmalloc
(sizeof
(type_list_t
));
3088 (*type_list
)->type
= type
;
3089 (*type_list
)->next
= NULL
;
3091 type_list
= &(*type_list
)->next
;
3099 static statement_list_t
*append_statements
(statement_list_t
*l1
, statement_list_t
*l2
)
3102 if
(!l1 || l1
== l2
) return l2
;
3103 list_move_tail
(l1
, l2
);
3107 static attr_list_t
*append_attribs
(attr_list_t
*l1
, attr_list_t
*l2
)
3110 if
(!l1 || l1
== l2
) return l2
;
3111 list_move_tail
(l1
, l2
);
3115 static statement_list_t
*append_statement
(statement_list_t
*list
, statement_t
*stmt
)
3117 if
(!stmt
) return list
;
3120 list
= xmalloc
( sizeof
(*list
) );
3123 list_add_tail
( list
, &stmt
->entry
);
3127 void init_loc_info
(loc_info_t
*i
)
3129 i
->input_name
= input_name ? input_name
: "stdin";
3130 i
->line_number
= line_number
;
3131 i
->near_text
= parser_text
;
3134 static void check_def
(const type_t
*t
)
3137 error_loc
("%s: redefinition error; original definition was at %s:%d\n",
3138 t
->name
, t
->loc_info.input_name
, t
->loc_info.line_number
);