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 expr_list_t
*append_expr
(expr_list_t
*list
, expr_t
*expr
);
62 static var_t
*declare_var
(attr_list_t
*attrs
, decl_spec_t
*decl_spec
, declarator_t
*decl
, int top
);
63 static var_list_t
*set_var_types
(attr_list_t
*attrs
, decl_spec_t
*decl_spec
, declarator_list_t
*decls
);
64 static ifref_list_t
*append_ifref
(ifref_list_t
*list
, ifref_t
*iface
);
65 static ifref_t
*make_ifref
(type_t
*iface
);
66 static var_list_t
*append_var_list
(var_list_t
*list
, var_list_t
*vars
);
67 static declarator_list_t
*append_declarator
(declarator_list_t
*list
, declarator_t
*p
);
68 static declarator_t
*make_declarator
(var_t
*var
);
69 static type_t
*make_safearray
(type_t
*type
);
70 static typelib_t
*make_library
(const char *name
, const attr_list_t
*attrs
);
71 static void append_array
(declarator_t
*decl
, expr_t
*expr
);
72 static void append_chain_type
(declarator_t
*decl
, type_t
*type
, enum type_qualifier qual
);
73 static void append_chain_callconv
(type_t
*chain
, char *callconv
);
74 static warning_list_t
*append_warning
(warning_list_t
*, int);
76 static type_t
*reg_typedefs
(decl_spec_t
*decl_spec
, var_list_t
*names
, attr_list_t
*attrs
);
77 static type_t
*find_type_or_error
(const char *name
, int t
);
78 static type_t
*find_type_or_error2
(char *name
, int t
);
80 static var_t
*reg_const
(var_t
*var
);
82 static void push_namespace
(const char *name
);
83 static void pop_namespace
(const char *name
);
84 static void init_lookup_namespace
(const char *name
);
85 static void push_lookup_namespace
(const char *name
);
87 static void check_arg_attrs
(const var_t
*arg
);
88 static void check_statements
(const statement_list_t
*stmts
, int is_inside_library
);
89 static void check_all_user_types
(const statement_list_t
*stmts
);
90 static attr_list_t
*check_iface_attrs
(const char *name
, attr_list_t
*attrs
);
91 static attr_list_t
*check_function_attrs
(const char *name
, attr_list_t
*attrs
);
92 static attr_list_t
*check_typedef_attrs
(attr_list_t
*attrs
);
93 static attr_list_t
*check_enum_attrs
(attr_list_t
*attrs
);
94 static attr_list_t
*check_enum_member_attrs
(attr_list_t
*attrs
);
95 static attr_list_t
*check_struct_attrs
(attr_list_t
*attrs
);
96 static attr_list_t
*check_union_attrs
(attr_list_t
*attrs
);
97 static attr_list_t
*check_field_attrs
(const char *name
, attr_list_t
*attrs
);
98 static attr_list_t
*check_library_attrs
(const char *name
, attr_list_t
*attrs
);
99 static attr_list_t
*check_dispiface_attrs
(const char *name
, attr_list_t
*attrs
);
100 static attr_list_t
*check_module_attrs
(const char *name
, attr_list_t
*attrs
);
101 static attr_list_t
*check_coclass_attrs
(const char *name
, attr_list_t
*attrs
);
102 const char *get_attr_display_name
(enum attr_type type
);
103 static void add_explicit_handle_if_necessary
(const type_t
*iface
, var_t
*func
);
104 static void check_def
(const type_t
*t
);
106 static void check_async_uuid
(type_t
*iface
);
108 static statement_t
*make_statement
(enum statement_type type
);
109 static statement_t
*make_statement_type_decl
(type_t
*type
);
110 static statement_t
*make_statement_reference
(type_t
*type
);
111 static statement_t
*make_statement_declaration
(var_t
*var
);
112 static statement_t
*make_statement_library
(typelib_t
*typelib
);
113 static statement_t
*make_statement_pragma
(const char *str
);
114 static statement_t
*make_statement_cppquote
(const char *str
);
115 static statement_t
*make_statement_importlib
(const char *str
);
116 static statement_t
*make_statement_module
(type_t
*type
);
117 static statement_t
*make_statement_typedef
(var_list_t
*names
, int declonly
);
118 static statement_t
*make_statement_import
(const char *str
);
119 static statement_list_t
*append_statement
(statement_list_t
*list
, statement_t
*stmt
);
120 static statement_list_t
*append_statements
(statement_list_t
*, statement_list_t
*);
121 static attr_list_t
*append_attribs
(attr_list_t
*, attr_list_t
*);
123 static struct namespace global_namespace
= {
124 NULL
, NULL
, LIST_INIT
(global_namespace.entry
), LIST_INIT
(global_namespace.children
)
127 static struct namespace
*current_namespace
= &global_namespace
;
128 static struct namespace
*lookup_namespace
= &global_namespace
;
130 static typelib_t
*current_typelib
;
135 attr_list_t
*attr_list
;
136 str_list_t
*str_list
;
138 expr_list_t
*expr_list
;
141 var_list_t
*var_list
;
142 declarator_t
*declarator
;
143 declarator_list_t
*declarator_list
;
144 statement_t
*statement
;
145 statement_list_t
*stmt_list
;
147 warning_list_t
*warning_list
;
149 ifref_list_t
*ifref_list
;
155 struct _import_t
*import
;
156 struct _decl_spec_t
*declspec
;
157 enum storage_class stgclass
;
158 enum type_qualifier type_qualifier
;
159 enum function_specifier function_specifier
;
162 %token
<str
> aIDENTIFIER aPRAGMA
163 %token
<str
> aKNOWNTYPE aNAMESPACE
164 %token
<num
> aNUM aHEXNUM
166 %token
<str
> aSTRING aWSTRING aSQSTRING
171 %token EQUALITY INEQUALITY
172 %token GREATEREQUAL LESSEQUAL
173 %token LOGICALOR LOGICALAND
175 %token tAGGREGATABLE tALLNODES tALLOCATE tANNOTATION tAPPOBJECT tASYNC tASYNCUUID
176 %token tAUTOHANDLE tBINDABLE tBOOLEAN tBROADCAST tBYTE tBYTECOUNT
177 %token tCALLAS tCALLBACK tCASE tCDECL tCHAR tCOCLASS tCODE tCOMMSTATUS
178 %token tCONST tCONTEXTHANDLE tCONTEXTHANDLENOSERIALIZE
179 %token tCONTEXTHANDLESERIALIZE tCONTROL tCPPQUOTE
180 %token tDECODE tDEFAULT tDEFAULTBIND
181 %token tDEFAULTCOLLELEM
183 %token tDEFAULTVTABLE
184 %token tDISABLECONSISTENCYCHECK tDISPLAYBIND
185 %token tDISPINTERFACE
186 %token tDLLNAME tDONTFREE tDOUBLE tDUAL
187 %token tENABLEALLOCATE tENCODE tENDPOINT
188 %token tENTRY tENUM tERRORSTATUST
189 %token tEXPLICITHANDLE tEXTERN
191 %token tFASTCALL tFAULTSTATUS
192 %token tFLOAT tFORCEALLOCATE
195 %token tHELPCONTEXT tHELPFILE
196 %token tHELPSTRING tHELPSTRINGCONTEXT tHELPSTRINGDLL
198 %token tHYPER tID tIDEMPOTENT
199 %token tIGNORE tIIDIS
200 %token tIMMEDIATEBIND
201 %token tIMPLICITHANDLE
202 %token tIMPORT tIMPORTLIB
203 %token tIN tIN_LINE tINLINE
205 %token tINT tINT32 tINT3264 tINT64
208 %token tLENGTHIS tLIBRARY
209 %token tLICENSED tLOCAL
211 %token tMAYBE tMESSAGE
215 %token tNOCODE tNONBROWSABLE
217 %token tNONEXTENSIBLE
218 %token tNOTIFY tNOTIFYFLAG
220 %token tOBJECT tODL tOLEAUTOMATION
221 %token tOPTIMIZE tOPTIONAL
223 %token tPARTIALIGNORE tPASCAL
224 %token tPOINTERDEFAULT
225 %token tPRAGMA_WARNING
226 %token tPROGID tPROPERTIES
227 %token tPROPGET tPROPPUT tPROPPUTREF
231 %token tREADONLY tREF
232 %token tREGISTER tREPRESENTAS
238 %token tSIGNED tSINGLENODE
239 %token tSIZEIS tSIZEOF
244 %token tSTRICTCONTEXTHANDLE
245 %token tSTRING tSTRUCT
246 %token tSWITCH tSWITCHIS tSWITCHTYPE
247 %token tTHREADING tTRANSMITAS
250 %token tUIDEFAULT tUNION
253 %token tUSESGETLASTERROR tUSERMARSHAL tUUID
256 %token tVERSION tVIPROGID
258 %token tWCHAR tWIREMARSHAL
259 %token tAPARTMENT tNEUTRAL tSINGLE tFREE tBOTH
261 %type
<attr
> attribute acf_attribute
262 %type
<attr_list
> m_attributes attributes attrib_list
263 %type
<attr_list
> acf_attributes acf_attribute_list
264 %type
<str_list
> str_list
265 %type
<expr
> m_expr expr expr_const expr_int_const array m_bitfield
266 %type
<expr_list
> m_exprs
/* exprs expr_list */ expr_list_int_const
267 %type
<type
> interfacehdr
268 %type
<stgclass
> storage_cls_spec
269 %type
<type_qualifier
> type_qualifier m_type_qual_list
270 %type
<function_specifier
> function_specifier
271 %type
<declspec
> decl_spec decl_spec_no_type m_decl_spec_no_type
272 %type
<type
> inherit interface interfacedef interfacedec
273 %type
<type
> dispinterface dispinterfacehdr dispinterfacedef
274 %type
<type
> module modulehdr moduledef
275 %type
<str
> namespacedef
276 %type
<type
> base_type int_std
277 %type
<type
> enumdef structdef uniondef typedecl
278 %type
<type
> type qualified_seq qualified_type
279 %type
<ifref
> coclass_int
280 %type
<ifref_list
> coclass_ints
281 %type
<var
> arg ne_union_field union_field s_field case
enum enum_member declaration
283 %type
<var_list
> m_args arg_list args dispint_meths
284 %type
<var_list
> fields ne_union_fields cases enums enum_list dispint_props field
285 %type
<var
> m_ident ident
286 %type
<declarator
> declarator direct_declarator init_declarator struct_declarator
287 %type
<declarator
> m_any_declarator any_declarator any_declarator_no_direct any_direct_declarator
288 %type
<declarator
> m_abstract_declarator abstract_declarator abstract_declarator_no_direct abstract_direct_declarator
289 %type
<declarator_list
> declarator_list struct_declarator_list
290 %type
<type
> coclass coclasshdr coclassdef
291 %type
<num
> pointer_type threading_type version
292 %type
<str
> libraryhdr callconv cppquote importlib import t_ident
293 %type
<uuid
> uuid_string
294 %type
<import
> import_start
295 %type
<typelib
> library_start librarydef
296 %type
<statement
> statement typedef pragma_warning
297 %type
<stmt_list
> gbl_statements imp_statements int_statements
298 %type
<warning_list
> warnings
299 %type
<num
> allocate_option_list allocate_option
308 %left EQUALITY INEQUALITY
309 %left
'<' '>' LESSEQUAL GREATEREQUAL
313 %right
'!' '~' CAST PPTR POS NEG ADDRESSOF tSIZEOF
314 %left
'.' MEMBERPTR
'[' ']'
316 %define parse.
error verbose
320 input: gbl_statements m_acf
{ check_statements
($1, FALSE
);
321 check_all_user_types
($1);
328 write_typelib_regscript
($1);
330 write_local_stubs
($1);
334 m_acf: /* empty */ | aACF acf_statements
336 gbl_statements: { $$
= NULL
; }
337 | gbl_statements namespacedef
'{' { push_namespace
($2); } gbl_statements
'}'
338 { pop_namespace
($2); $$
= append_statements
($1, $5); }
339 | gbl_statements interfacedec
{ $$
= append_statement
($1, make_statement_reference
($2)); }
340 | gbl_statements interfacedef
{ $$
= append_statement
($1, make_statement_type_decl
($2)); }
341 | gbl_statements coclass
';' { $$
= $1;
342 reg_type
($2, $2->name
, current_namespace
, 0);
344 | gbl_statements coclassdef
{ $$
= append_statement
($1, make_statement_type_decl
($2));
345 reg_type
($2, $2->name
, current_namespace
, 0);
347 | gbl_statements moduledef
{ $$
= append_statement
($1, make_statement_module
($2)); }
348 | gbl_statements librarydef
{ $$
= append_statement
($1, make_statement_library
($2)); }
349 | gbl_statements statement
{ $$
= append_statement
($1, $2); }
352 imp_statements: { $$
= NULL
; }
353 | imp_statements interfacedec
{ $$
= append_statement
($1, make_statement_reference
($2)); }
354 | imp_statements namespacedef
'{' { push_namespace
($2); } imp_statements
'}'
355 { pop_namespace
($2); $$
= append_statements
($1, $5); }
356 | imp_statements interfacedef
{ $$
= append_statement
($1, make_statement_type_decl
($2)); }
357 | imp_statements coclass
';' { $$
= $1; reg_type
($2, $2->name
, current_namespace
, 0); }
358 | imp_statements coclassdef
{ $$
= append_statement
($1, make_statement_type_decl
($2));
359 reg_type
($2, $2->name
, current_namespace
, 0);
361 | imp_statements moduledef
{ $$
= append_statement
($1, make_statement_module
($2)); }
362 | imp_statements statement
{ $$
= append_statement
($1, $2); }
363 | imp_statements importlib
{ $$
= append_statement
($1, make_statement_importlib
($2)); }
364 | imp_statements librarydef
{ $$
= append_statement
($1, make_statement_library
($2)); }
367 int_statements: { $$
= NULL
; }
368 | int_statements statement
{ $$
= append_statement
($1, $2); }
376 cppquote
{ $$
= make_statement_cppquote
($1); }
377 | typedecl
';' { $$
= make_statement_type_decl
($1); }
378 | declaration
';' { $$
= make_statement_declaration
($1); }
379 | import
{ $$
= make_statement_import
($1); }
380 | typedef
';' { $$
= $1; }
381 | aPRAGMA
{ $$
= make_statement_pragma
($1); }
382 | pragma_warning
{ $$
= NULL
; }
385 pragma_warning: tPRAGMA_WARNING
'(' aIDENTIFIER
':' warnings
')'
389 result
= do_warning
($3, $5);
391 error_loc
("expected \"disable\" or \"enable\"\n");
396 aNUM
{ $$
= append_warning
(NULL
, $1); }
397 | warnings aNUM
{ $$
= append_warning
($1, $2); }
402 | tENUM aIDENTIFIER
{ $$
= type_new_enum
($2, current_namespace
, FALSE
, NULL
); }
404 | tSTRUCT aIDENTIFIER
{ $$
= type_new_struct
($2, current_namespace
, FALSE
, NULL
); }
406 | tUNION aIDENTIFIER
{ $$
= type_new_nonencapsulated_union
($2, FALSE
, NULL
); }
407 | attributes enumdef
{ $$
= $2; $$
->attrs
= check_enum_attrs
($1); }
408 | attributes structdef
{ $$
= $2; $$
->attrs
= check_struct_attrs
($1); }
409 | attributes uniondef
{ $$
= $2; $$
->attrs
= check_union_attrs
($1); }
412 cppquote: tCPPQUOTE
'(' aSTRING
')' { $$
= $3; }
414 import_start: tIMPORT aSTRING
';' { assert
(yychar == YYEMPTY
);
415 $$
= xmalloc
(sizeof
(struct _import_t
));
417 $$
->import_performed
= do_import
($2);
418 if
(!$$
->import_performed
) yychar = aEOF
;
422 import: import_start imp_statements aEOF
{ $$
= $1->name
;
423 if
($1->import_performed
) pop_import
();
428 importlib: tIMPORTLIB
'(' aSTRING
')'
429 semicolon_opt
{ $$
= $3; if
(!parse_only
) add_importlib
($3, current_typelib
); }
432 libraryhdr: tLIBRARY aIDENTIFIER
{ $$
= $2; }
433 | tLIBRARY aKNOWNTYPE
{ $$
= $2; }
435 library_start: attributes libraryhdr
'{' { $$
= make_library
($2, check_library_attrs
($2, $1));
436 if
(!parse_only
&& do_typelib
) current_typelib
= $$
;
439 librarydef: library_start imp_statements
'}'
440 semicolon_opt
{ $$
= $1; $$
->stmts
= $2; }
443 m_args: { $$
= NULL
; }
447 arg_list: arg
{ check_arg_attrs
($1); $$
= append_var
( NULL
, $1 ); }
448 | arg_list
',' arg
{ check_arg_attrs
($3); $$
= append_var
( $1, $3 ); }
452 | arg_list
',' ELLIPSIS
{ $$
= append_var
( $1, make_var
(strdup
("...")) ); }
455 /* split into two rules to get bison to resolve a tVOID conflict */
456 arg: attributes decl_spec m_any_declarator
{ if
($2->stgclass
!= STG_NONE
&& $2->stgclass
!= STG_REGISTER
)
457 error_loc
("invalid storage class for function parameter\n");
458 $$
= declare_var
($1, $2, $3, TRUE
);
461 | decl_spec m_any_declarator
{ if
($1->stgclass
!= STG_NONE
&& $1->stgclass
!= STG_REGISTER
)
462 error_loc
("invalid storage class for function parameter\n");
463 $$
= declare_var
(NULL
, $1, $2, TRUE
);
468 array: '[' expr
']' { $$
= $2;
469 if
(!$$
->is_const || $$
->cval
<= 0)
470 error_loc
("array dimension is not a positive integer constant\n");
472 |
'[' '*' ']' { $$
= make_expr
(EXPR_VOID
); }
473 |
'[' ']' { $$
= make_expr
(EXPR_VOID
); }
476 m_attributes: { $$
= NULL
; }
481 '[' attrib_list
']' { $$
= $2; }
484 attrib_list: attribute
{ $$
= append_attr
( NULL
, $1 ); }
485 | attrib_list
',' attribute
{ $$
= append_attr
( $1, $3 ); }
486 | attrib_list
']' '[' attribute
{ $$
= append_attr
( $1, $4 ); }
489 str_list: aSTRING
{ $$
= append_str
( NULL
, $1 ); }
490 | str_list
',' aSTRING
{ $$
= append_str
( $1, $3 ); }
493 attribute: { $$
= NULL
; }
494 | tAGGREGATABLE
{ $$
= make_attr
(ATTR_AGGREGATABLE
); }
495 | tANNOTATION
'(' aSTRING
')' { $$
= make_attrp
(ATTR_ANNOTATION
, $3); }
496 | tAPPOBJECT
{ $$
= make_attr
(ATTR_APPOBJECT
); }
497 | tASYNC
{ $$
= make_attr
(ATTR_ASYNC
); }
498 | tAUTOHANDLE
{ $$
= make_attr
(ATTR_AUTO_HANDLE
); }
499 | tBINDABLE
{ $$
= make_attr
(ATTR_BINDABLE
); }
500 | tBROADCAST
{ $$
= make_attr
(ATTR_BROADCAST
); }
501 | tCALLAS
'(' ident
')' { $$
= make_attrp
(ATTR_CALLAS
, $3); }
502 | tCASE
'(' expr_list_int_const
')' { $$
= make_attrp
(ATTR_CASE
, $3); }
503 | tCODE
{ $$
= make_attr
(ATTR_CODE
); }
504 | tCOMMSTATUS
{ $$
= make_attr
(ATTR_COMMSTATUS
); }
505 | tCONTEXTHANDLE
{ $$
= make_attrv
(ATTR_CONTEXTHANDLE
, 0); }
506 | tCONTEXTHANDLENOSERIALIZE
{ $$
= make_attrv
(ATTR_CONTEXTHANDLE
, 0); /* RPC_CONTEXT_HANDLE_DONT_SERIALIZE */ }
507 | tCONTEXTHANDLESERIALIZE
{ $$
= make_attrv
(ATTR_CONTEXTHANDLE
, 0); /* RPC_CONTEXT_HANDLE_SERIALIZE */ }
508 | tCONTROL
{ $$
= make_attr
(ATTR_CONTROL
); }
509 | tDECODE
{ $$
= make_attr
(ATTR_DECODE
); }
510 | tDEFAULT
{ $$
= make_attr
(ATTR_DEFAULT
); }
511 | tDEFAULTBIND
{ $$
= make_attr
(ATTR_DEFAULTBIND
); }
512 | tDEFAULTCOLLELEM
{ $$
= make_attr
(ATTR_DEFAULTCOLLELEM
); }
513 | tDEFAULTVALUE
'(' expr_const
')' { $$
= make_attrp
(ATTR_DEFAULTVALUE
, $3); }
514 | tDEFAULTVTABLE
{ $$
= make_attr
(ATTR_DEFAULTVTABLE
); }
515 | tDISABLECONSISTENCYCHECK
{ $$
= make_attr
(ATTR_DISABLECONSISTENCYCHECK
); }
516 | tDISPLAYBIND
{ $$
= make_attr
(ATTR_DISPLAYBIND
); }
517 | tDLLNAME
'(' aSTRING
')' { $$
= make_attrp
(ATTR_DLLNAME
, $3); }
518 | tDUAL
{ $$
= make_attr
(ATTR_DUAL
); }
519 | tENABLEALLOCATE
{ $$
= make_attr
(ATTR_ENABLEALLOCATE
); }
520 | tENCODE
{ $$
= make_attr
(ATTR_ENCODE
); }
521 | tENDPOINT
'(' str_list
')' { $$
= make_attrp
(ATTR_ENDPOINT
, $3); }
522 | tENTRY
'(' expr_const
')' { $$
= make_attrp
(ATTR_ENTRY
, $3); }
523 | tEXPLICITHANDLE
{ $$
= make_attr
(ATTR_EXPLICIT_HANDLE
); }
524 | tFAULTSTATUS
{ $$
= make_attr
(ATTR_FAULTSTATUS
); }
525 | tFORCEALLOCATE
{ $$
= make_attr
(ATTR_FORCEALLOCATE
); }
526 | tHANDLE
{ $$
= make_attr
(ATTR_HANDLE
); }
527 | tHELPCONTEXT
'(' expr_int_const
')' { $$
= make_attrp
(ATTR_HELPCONTEXT
, $3); }
528 | tHELPFILE
'(' aSTRING
')' { $$
= make_attrp
(ATTR_HELPFILE
, $3); }
529 | tHELPSTRING
'(' aSTRING
')' { $$
= make_attrp
(ATTR_HELPSTRING
, $3); }
530 | tHELPSTRINGCONTEXT
'(' expr_int_const
')' { $$
= make_attrp
(ATTR_HELPSTRINGCONTEXT
, $3); }
531 | tHELPSTRINGDLL
'(' aSTRING
')' { $$
= make_attrp
(ATTR_HELPSTRINGDLL
, $3); }
532 | tHIDDEN
{ $$
= make_attr
(ATTR_HIDDEN
); }
533 | tID
'(' expr_int_const
')' { $$
= make_attrp
(ATTR_ID
, $3); }
534 | tIDEMPOTENT
{ $$
= make_attr
(ATTR_IDEMPOTENT
); }
535 | tIGNORE
{ $$
= make_attr
(ATTR_IGNORE
); }
536 | tIIDIS
'(' expr
')' { $$
= make_attrp
(ATTR_IIDIS
, $3); }
537 | tIMMEDIATEBIND
{ $$
= make_attr
(ATTR_IMMEDIATEBIND
); }
538 | tIMPLICITHANDLE
'(' arg
')' { $$
= make_attrp
(ATTR_IMPLICIT_HANDLE
, $3); }
539 | tIN
{ $$
= make_attr
(ATTR_IN
); }
540 | tINPUTSYNC
{ $$
= make_attr
(ATTR_INPUTSYNC
); }
541 | tLENGTHIS
'(' m_exprs
')' { $$
= make_attrp
(ATTR_LENGTHIS
, $3); }
542 | tLCID
'(' expr_int_const
')' { $$
= make_attrp
(ATTR_LIBLCID
, $3); }
543 | tLCID
{ $$
= make_attr
(ATTR_PARAMLCID
); }
544 | tLICENSED
{ $$
= make_attr
(ATTR_LICENSED
); }
545 | tLOCAL
{ $$
= make_attr
(ATTR_LOCAL
); }
546 | tMAYBE
{ $$
= make_attr
(ATTR_MAYBE
); }
547 | tMESSAGE
{ $$
= make_attr
(ATTR_MESSAGE
); }
548 | tNOCODE
{ $$
= make_attr
(ATTR_NOCODE
); }
549 | tNONBROWSABLE
{ $$
= make_attr
(ATTR_NONBROWSABLE
); }
550 | tNONCREATABLE
{ $$
= make_attr
(ATTR_NONCREATABLE
); }
551 | tNONEXTENSIBLE
{ $$
= make_attr
(ATTR_NONEXTENSIBLE
); }
552 | tNOTIFY
{ $$
= make_attr
(ATTR_NOTIFY
); }
553 | tNOTIFYFLAG
{ $$
= make_attr
(ATTR_NOTIFYFLAG
); }
554 | tOBJECT
{ $$
= make_attr
(ATTR_OBJECT
); }
555 | tODL
{ $$
= make_attr
(ATTR_ODL
); }
556 | tOLEAUTOMATION
{ $$
= make_attr
(ATTR_OLEAUTOMATION
); }
557 | tOPTIMIZE
'(' aSTRING
')' { $$
= make_attrp
(ATTR_OPTIMIZE
, $3); }
558 | tOPTIONAL
{ $$
= make_attr
(ATTR_OPTIONAL
); }
559 | tOUT
{ $$
= make_attr
(ATTR_OUT
); }
560 | tPARTIALIGNORE
{ $$
= make_attr
(ATTR_PARTIALIGNORE
); }
561 | tPOINTERDEFAULT
'(' pointer_type
')' { $$
= make_attrv
(ATTR_POINTERDEFAULT
, $3); }
562 | tPROGID
'(' aSTRING
')' { $$
= make_attrp
(ATTR_PROGID
, $3); }
563 | tPROPGET
{ $$
= make_attr
(ATTR_PROPGET
); }
564 | tPROPPUT
{ $$
= make_attr
(ATTR_PROPPUT
); }
565 | tPROPPUTREF
{ $$
= make_attr
(ATTR_PROPPUTREF
); }
566 | tPROXY
{ $$
= make_attr
(ATTR_PROXY
); }
567 | tPUBLIC
{ $$
= make_attr
(ATTR_PUBLIC
); }
568 | tRANGE
'(' expr_int_const
',' expr_int_const
')'
569 { expr_list_t
*list
= append_expr
( NULL
, $3 );
570 list
= append_expr
( list
, $5 );
571 $$
= make_attrp
(ATTR_RANGE
, list
); }
572 | tREADONLY
{ $$
= make_attr
(ATTR_READONLY
); }
573 | tREPRESENTAS
'(' type
')' { $$
= make_attrp
(ATTR_REPRESENTAS
, $3); }
574 | tREQUESTEDIT
{ $$
= make_attr
(ATTR_REQUESTEDIT
); }
575 | tRESTRICTED
{ $$
= make_attr
(ATTR_RESTRICTED
); }
576 | tRETVAL
{ $$
= make_attr
(ATTR_RETVAL
); }
577 | tSIZEIS
'(' m_exprs
')' { $$
= make_attrp
(ATTR_SIZEIS
, $3); }
578 | tSOURCE
{ $$
= make_attr
(ATTR_SOURCE
); }
579 | tSTRICTCONTEXTHANDLE
{ $$
= make_attr
(ATTR_STRICTCONTEXTHANDLE
); }
580 | tSTRING
{ $$
= make_attr
(ATTR_STRING
); }
581 | tSWITCHIS
'(' expr
')' { $$
= make_attrp
(ATTR_SWITCHIS
, $3); }
582 | tSWITCHTYPE
'(' type
')' { $$
= make_attrp
(ATTR_SWITCHTYPE
, $3); }
583 | tTRANSMITAS
'(' type
')' { $$
= make_attrp
(ATTR_TRANSMITAS
, $3); }
584 | tTHREADING
'(' threading_type
')' { $$
= make_attrv
(ATTR_THREADING
, $3); }
585 | tUIDEFAULT
{ $$
= make_attr
(ATTR_UIDEFAULT
); }
586 | tUSESGETLASTERROR
{ $$
= make_attr
(ATTR_USESGETLASTERROR
); }
587 | tUSERMARSHAL
'(' type
')' { $$
= make_attrp
(ATTR_USERMARSHAL
, $3); }
588 | tUUID
'(' uuid_string
')' { $$
= make_attrp
(ATTR_UUID
, $3); }
589 | tASYNCUUID
'(' uuid_string
')' { $$
= make_attrp
(ATTR_ASYNCUUID
, $3); }
590 | tV1ENUM
{ $$
= make_attr
(ATTR_V1ENUM
); }
591 | tVARARG
{ $$
= make_attr
(ATTR_VARARG
); }
592 | tVERSION
'(' version
')' { $$
= make_attrv
(ATTR_VERSION
, $3); }
593 | tVIPROGID
'(' aSTRING
')' { $$
= make_attrp
(ATTR_VIPROGID
, $3); }
594 | tWIREMARSHAL
'(' type
')' { $$
= make_attrp
(ATTR_WIREMARSHAL
, $3); }
595 | pointer_type
{ $$
= make_attrv
(ATTR_POINTERTYPE
, $1); }
600 | aSTRING
{ if
(!is_valid_uuid
($1))
601 error_loc
("invalid UUID: %s\n", $1);
602 $$
= parse_uuid
($1); }
605 callconv: tCDECL
{ $$
= xstrdup
("__cdecl"); }
606 | tFASTCALL
{ $$
= xstrdup
("__fastcall"); }
607 | tPASCAL
{ $$
= xstrdup
("__pascal"); }
608 | tSTDCALL
{ $$
= xstrdup
("__stdcall"); }
611 cases: { $$
= NULL
; }
612 | cases case
{ $$
= append_var
( $1, $2 ); }
615 case: tCASE expr_int_const
':' union_field
{ attr_t
*a
= make_attrp
(ATTR_CASE
, append_expr
( NULL
, $2 ));
616 $$
= $4; if
(!$$
) $$
= make_var
(NULL
);
617 $$
->attrs
= append_attr
( $$
->attrs
, a
);
619 | tDEFAULT
':' union_field
{ attr_t
*a
= make_attr
(ATTR_DEFAULT
);
620 $$
= $3; if
(!$$
) $$
= make_var
(NULL
);
621 $$
->attrs
= append_attr
( $$
->attrs
, a
);
625 enums: { $$
= NULL
; }
626 | enum_list
',' { $$
= $1; }
630 enum_list: enum { if
(!$1->eval
)
631 $1->eval
= make_exprl
(EXPR_NUM
, 0 /* default for first enum entry */);
632 $$
= append_var
( NULL
, $1 );
634 | enum_list
',' enum { if
(!$3->eval
)
636 var_t
*last
= LIST_ENTRY
( list_tail
($$
), var_t
, entry
);
637 enum expr_type type
= EXPR_NUM
;
638 if
(last
->eval
->type
== EXPR_HEXNUM
) type
= EXPR_HEXNUM
;
639 if
(last
->eval
->cval
+ 1 < 0) type
= EXPR_HEXNUM
;
640 $3->eval
= make_exprl
(type
, last
->eval
->cval
+ 1);
642 $$
= append_var
( $1, $3 );
646 enum_member: m_attributes ident
{ $$
= $2;
647 $$
->attrs
= check_enum_member_attrs
($1);
651 enum: enum_member
'=' expr_int_const
{ $$
= reg_const
($1);
653 $$
->declspec.type
= type_new_int
(TYPE_BASIC_INT
, 0);
655 | enum_member
{ $$
= reg_const
($1);
656 $$
->declspec.type
= type_new_int
(TYPE_BASIC_INT
, 0);
660 enumdef: tENUM t_ident
'{' enums
'}' { $$
= type_new_enum
($2, current_namespace
, TRUE
, $4); }
663 m_exprs: m_expr
{ $$
= append_expr
( NULL
, $1 ); }
664 | m_exprs
',' m_expr
{ $$
= append_expr
( $1, $3 ); }
667 m_expr: { $$
= make_expr
(EXPR_VOID
); }
671 expr: aNUM
{ $$
= make_exprl
(EXPR_NUM
, $1); }
672 | aHEXNUM
{ $$
= make_exprl
(EXPR_HEXNUM
, $1); }
673 | aDOUBLE
{ $$
= make_exprd
(EXPR_DOUBLE
, $1); }
674 | tFALSE
{ $$
= make_exprl
(EXPR_TRUEFALSE
, 0); }
675 | tNULL
{ $$
= make_exprl
(EXPR_NUM
, 0); }
676 | tTRUE
{ $$
= make_exprl
(EXPR_TRUEFALSE
, 1); }
677 | aSTRING
{ $$
= make_exprs
(EXPR_STRLIT
, $1); }
678 | aWSTRING
{ $$
= make_exprs
(EXPR_WSTRLIT
, $1); }
679 | aSQSTRING
{ $$
= make_exprs
(EXPR_CHARCONST
, $1); }
680 | aIDENTIFIER
{ $$
= make_exprs
(EXPR_IDENTIFIER
, $1); }
681 | expr
'?' expr
':' expr
{ $$
= make_expr3
(EXPR_COND
, $1, $3, $5); }
682 | expr LOGICALOR expr
{ $$
= make_expr2
(EXPR_LOGOR
, $1, $3); }
683 | expr LOGICALAND expr
{ $$
= make_expr2
(EXPR_LOGAND
, $1, $3); }
684 | expr
'|' expr
{ $$
= make_expr2
(EXPR_OR
, $1, $3); }
685 | expr
'^' expr
{ $$
= make_expr2
(EXPR_XOR
, $1, $3); }
686 | expr
'&' expr
{ $$
= make_expr2
(EXPR_AND
, $1, $3); }
687 | expr EQUALITY expr
{ $$
= make_expr2
(EXPR_EQUALITY
, $1, $3); }
688 | expr INEQUALITY expr
{ $$
= make_expr2
(EXPR_INEQUALITY
, $1, $3); }
689 | expr
'>' expr
{ $$
= make_expr2
(EXPR_GTR
, $1, $3); }
690 | expr
'<' expr
{ $$
= make_expr2
(EXPR_LESS
, $1, $3); }
691 | expr GREATEREQUAL expr
{ $$
= make_expr2
(EXPR_GTREQL
, $1, $3); }
692 | expr LESSEQUAL expr
{ $$
= make_expr2
(EXPR_LESSEQL
, $1, $3); }
693 | expr SHL expr
{ $$
= make_expr2
(EXPR_SHL
, $1, $3); }
694 | expr SHR expr
{ $$
= make_expr2
(EXPR_SHR
, $1, $3); }
695 | expr
'+' expr
{ $$
= make_expr2
(EXPR_ADD
, $1, $3); }
696 | expr
'-' expr
{ $$
= make_expr2
(EXPR_SUB
, $1, $3); }
697 | expr
'%' expr
{ $$
= make_expr2
(EXPR_MOD
, $1, $3); }
698 | expr
'*' expr
{ $$
= make_expr2
(EXPR_MUL
, $1, $3); }
699 | expr
'/' expr
{ $$
= make_expr2
(EXPR_DIV
, $1, $3); }
700 |
'!' expr
{ $$
= make_expr1
(EXPR_LOGNOT
, $2); }
701 |
'~' expr
{ $$
= make_expr1
(EXPR_NOT
, $2); }
702 |
'+' expr %prec POS
{ $$
= make_expr1
(EXPR_POS
, $2); }
703 |
'-' expr %prec NEG
{ $$
= make_expr1
(EXPR_NEG
, $2); }
704 |
'&' expr %prec ADDRESSOF
{ $$
= make_expr1
(EXPR_ADDRESSOF
, $2); }
705 |
'*' expr %prec PPTR
{ $$
= make_expr1
(EXPR_PPTR
, $2); }
706 | expr MEMBERPTR aIDENTIFIER
{ $$
= make_expr2
(EXPR_MEMBER
, make_expr1
(EXPR_PPTR
, $1), make_exprs
(EXPR_IDENTIFIER
, $3)); }
707 | expr
'.' aIDENTIFIER
{ $$
= make_expr2
(EXPR_MEMBER
, $1, make_exprs
(EXPR_IDENTIFIER
, $3)); }
708 |
'(' decl_spec m_abstract_declarator
')' expr %prec CAST
709 { $$
= make_exprt
(EXPR_CAST
, declare_var
(NULL
, $2, $3, 0), $5); free
($2); free
($3); }
710 | tSIZEOF
'(' decl_spec m_abstract_declarator
')'
711 { $$
= make_exprt
(EXPR_SIZEOF
, declare_var
(NULL
, $3, $4, 0), NULL
); free
($3); free
($4); }
712 | expr
'[' expr
']' { $$
= make_expr2
(EXPR_ARRAY
, $1, $3); }
713 |
'(' expr
')' { $$
= $2; }
716 expr_list_int_const: expr_int_const
{ $$
= append_expr
( NULL
, $1 ); }
717 | expr_list_int_const
',' expr_int_const
{ $$
= append_expr
( $1, $3 ); }
720 expr_int_const: expr
{ $$
= $1;
722 error_loc
("expression is not an integer constant\n");
726 expr_const: expr
{ $$
= $1;
727 if
(!$$
->is_const
&& $$
->type
!= EXPR_STRLIT
&& $$
->type
!= EXPR_WSTRLIT
)
728 error_loc
("expression is not constant\n");
732 fields: { $$
= NULL
; }
733 | fields field
{ $$
= append_var_list
($1, $2); }
736 field: m_attributes decl_spec struct_declarator_list
';'
737 { const char *first
= LIST_ENTRY
(list_head
($3), declarator_t
, entry
)->var
->name
;
738 check_field_attrs
(first
, $1);
739 $$
= set_var_types
($1, $2, $3);
741 | m_attributes uniondef
';' { var_t
*v
= make_var
(NULL
);
742 v
->declspec.type
= $2; v
->attrs
= $1;
743 $$
= append_var
(NULL
, v
);
748 s_field
';' { $$
= $1; }
749 | attributes
';' { $$
= make_var
(NULL
); $$
->attrs
= $1; }
752 ne_union_fields: { $$
= NULL
; }
753 | ne_union_fields ne_union_field
{ $$
= append_var
( $1, $2 ); }
757 s_field
';' { $$
= $1; }
761 s_field: m_attributes decl_spec declarator
{ $$
= declare_var
(check_field_attrs
($3->var
->name
, $1),
765 | m_attributes structdef
{ var_t
*v
= make_var
(NULL
);
766 v
->declspec.type
= $2; v
->attrs
= $1;
771 funcdef: declaration
{ $$
= $1;
772 if
(type_get_type
($$
->declspec.type
) != TYPE_FUNCTION
)
773 error_loc
("only methods may be declared inside the methods section of a dispinterface\n");
774 check_function_attrs
($$
->name
, $$
->attrs
);
779 attributes decl_spec init_declarator
780 { $$
= declare_var
($1, $2, $3, FALSE
);
783 | decl_spec init_declarator
{ $$
= declare_var
(NULL
, $1, $2, FALSE
);
788 m_ident: { $$
= NULL
; }
792 t_ident: { $$
= NULL
; }
793 | aIDENTIFIER
{ $$
= $1; }
794 | aKNOWNTYPE
{ $$
= $1; }
797 ident: aIDENTIFIER
{ $$
= make_var
($1); }
798 /* some "reserved words" used in attributes are also used as field names in some MS IDL files */
799 | aKNOWNTYPE
{ $$
= make_var
($
<str
>1); }
802 base_type: tBYTE
{ $$
= find_type_or_error
($
<str
>1, 0); }
803 | tWCHAR
{ $$
= find_type_or_error
($
<str
>1, 0); }
805 | tSIGNED int_std
{ $$
= type_new_int
(type_basic_get_type
($2), -1); }
806 | tUNSIGNED int_std
{ $$
= type_new_int
(type_basic_get_type
($2), 1); }
807 | tUNSIGNED
{ $$
= type_new_int
(TYPE_BASIC_INT
, 1); }
808 | tFLOAT
{ $$
= find_type_or_error
($
<str
>1, 0); }
809 | tDOUBLE
{ $$
= find_type_or_error
($
<str
>1, 0); }
810 | tBOOLEAN
{ $$
= find_type_or_error
($
<str
>1, 0); }
811 | tERRORSTATUST
{ $$
= find_type_or_error
($
<str
>1, 0); }
812 | tHANDLET
{ $$
= find_type_or_error
($
<str
>1, 0); }
819 int_std: tINT
{ $$
= type_new_int
(TYPE_BASIC_INT
, 0); }
820 | tSHORT m_int
{ $$
= type_new_int
(TYPE_BASIC_INT16
, 0); }
821 | tSMALL
{ $$
= type_new_int
(TYPE_BASIC_INT8
, 0); }
822 | tLONG m_int
{ $$
= type_new_int
(TYPE_BASIC_LONG
, 0); }
823 | tHYPER m_int
{ $$
= type_new_int
(TYPE_BASIC_HYPER
, 0); }
824 | tINT64
{ $$
= type_new_int
(TYPE_BASIC_INT64
, 0); }
825 | tCHAR
{ $$
= type_new_int
(TYPE_BASIC_CHAR
, 0); }
826 | tINT32
{ $$
= type_new_int
(TYPE_BASIC_INT32
, 0); }
827 | tINT3264
{ $$
= type_new_int
(TYPE_BASIC_INT3264
, 0); }
831 aKNOWNTYPE
{ $$
= find_type_or_error
($1, 0); }
832 | aIDENTIFIER
'.' { push_lookup_namespace
($1); } qualified_seq
{ $$
= $4; }
836 aKNOWNTYPE
{ $$
= find_type_or_error
($1, 0); }
837 | aNAMESPACE
'.' { init_lookup_namespace
($1); } qualified_seq
{ $$
= $4; }
840 coclass: tCOCLASS aIDENTIFIER
{ $$
= type_new_coclass
($2); }
841 | tCOCLASS aKNOWNTYPE
{ $$
= find_type
($2, NULL
, 0);
842 if
(type_get_type_detect_alias
($$
) != TYPE_COCLASS
)
843 error_loc
("%s was not declared a coclass at %s:%d\n",
844 $2, $$
->loc_info.input_name
,
845 $$
->loc_info.line_number
);
849 coclasshdr: attributes coclass
{ $$
= $2;
851 $$
->attrs
= check_coclass_attrs
($2->name
, $1);
855 coclassdef: coclasshdr
'{' coclass_ints
'}' semicolon_opt
856 { $$
= type_coclass_define
($1, $3); }
859 namespacedef: tNAMESPACE aIDENTIFIER
{ $$
= $2; }
860 | tNAMESPACE aNAMESPACE
{ $$
= $2; }
863 coclass_ints: { $$
= NULL
; }
864 | coclass_ints coclass_int
{ $$
= append_ifref
( $1, $2 ); }
868 m_attributes interfacedec
{ $$
= make_ifref
($2); $$
->attrs
= $1; }
871 dispinterface: tDISPINTERFACE aIDENTIFIER
{ $$
= get_type
(TYPE_INTERFACE
, $2, current_namespace
, 0); }
872 | tDISPINTERFACE aKNOWNTYPE
{ $$
= get_type
(TYPE_INTERFACE
, $2, current_namespace
, 0); }
875 dispinterfacehdr: attributes dispinterface
{ attr_t
*attrs
;
878 attrs
= make_attr
(ATTR_DISPINTERFACE
);
879 $$
->attrs
= append_attr
( check_dispiface_attrs
($2->name
, $1), attrs
);
884 dispint_props: tPROPERTIES
':' { $$
= NULL
; }
885 | dispint_props s_field
';' { $$
= append_var
( $1, $2 ); }
888 dispint_meths: tMETHODS
':' { $$
= NULL
; }
889 | dispint_meths funcdef
';' { $$
= append_var
( $1, $2 ); }
892 dispinterfacedef: dispinterfacehdr
'{'
896 type_dispinterface_define
($$
, $3, $4);
899 '{' interface
';' '}' { $$
= $1;
900 type_dispinterface_define_from_iface
($$
, $3);
904 inherit: { $$
= NULL
; }
905 |
':' qualified_type
{ $$
= $2; }
908 interface: tINTERFACE aIDENTIFIER
{ $$
= get_type
(TYPE_INTERFACE
, $2, current_namespace
, 0); }
909 | tINTERFACE aKNOWNTYPE
{ $$
= get_type
(TYPE_INTERFACE
, $2, current_namespace
, 0); }
912 interfacehdr: attributes interface
{ $$
= $2;
914 $2->attrs
= check_iface_attrs
($2->name
, $1);
919 interfacedef: interfacehdr inherit
920 '{' int_statements
'}' semicolon_opt
{ $$
= $1;
922 error_loc
("Interface can't inherit from itself\n");
923 type_interface_define
($$
, $2, $4);
924 check_async_uuid
($$
);
926 /* MIDL is able to import the definition of a base class from inside the
927 * definition of a derived class, I'll try to support it with this rule */
928 | interfacehdr
':' aIDENTIFIER
929 '{' import int_statements
'}'
930 semicolon_opt
{ $$
= $1;
931 type_interface_define
($$
, find_type_or_error2
($3, 0), $6);
933 | dispinterfacedef semicolon_opt
{ $$
= $1; }
937 interface
';' { $$
= $1; }
938 | dispinterface
';' { $$
= $1; }
941 module: tMODULE aIDENTIFIER
{ $$
= type_new_module
($2); }
942 | tMODULE aKNOWNTYPE
{ $$
= type_new_module
($2); }
945 modulehdr: attributes module
{ $$
= $2;
946 $$
->attrs
= check_module_attrs
($2->name
, $1);
950 moduledef: modulehdr
'{' int_statements
'}'
951 semicolon_opt
{ $$
= $1;
952 type_module_define
($$
, $3);
957 tEXTERN
{ $$
= STG_EXTERN
; }
958 | tSTATIC
{ $$
= STG_STATIC
; }
959 | tREGISTER
{ $$
= STG_REGISTER
; }
963 tINLINE
{ $$
= FUNCTION_SPECIFIER_INLINE
; }
967 tCONST
{ $$
= TYPE_QUALIFIER_CONST
; }
970 m_type_qual_list: { $$
= 0; }
971 | m_type_qual_list type_qualifier
{ $$
= $1 |
$2; }
974 decl_spec: type m_decl_spec_no_type
{ $$
= make_decl_spec
($1, $2, NULL
, STG_NONE
, 0, 0); }
975 | decl_spec_no_type type m_decl_spec_no_type
976 { $$
= make_decl_spec
($2, $1, $3, STG_NONE
, 0, 0); }
979 m_decl_spec_no_type: { $$
= NULL
; }
984 type_qualifier m_decl_spec_no_type
{ $$
= make_decl_spec
(NULL
, $2, NULL
, STG_NONE
, $1, 0); }
985 | function_specifier m_decl_spec_no_type
{ $$
= make_decl_spec
(NULL
, $2, NULL
, STG_NONE
, 0, $1); }
986 | storage_cls_spec m_decl_spec_no_type
{ $$
= make_decl_spec
(NULL
, $2, NULL
, $1, 0, 0); }
990 '*' m_type_qual_list declarator %prec PPTR
991 { $$
= $3; append_chain_type
($$
, type_new_pointer
(NULL
), $2); }
992 | callconv declarator
{ $$
= $2; append_chain_callconv
($$
->type
, $1); }
997 ident
{ $$
= make_declarator
($1); }
998 |
'(' declarator
')' { $$
= $2; }
999 | direct_declarator array
{ $$
= $1; append_array
($$
, $2); }
1000 | direct_declarator
'(' m_args
')' { $$
= $1; append_chain_type
($$
, type_new_function
($3), 0); }
1003 /* abstract declarator */
1004 abstract_declarator:
1005 '*' m_type_qual_list m_abstract_declarator %prec PPTR
1006 { $$
= $3; append_chain_type
($$
, type_new_pointer
(NULL
), $2); }
1007 | callconv m_abstract_declarator
{ $$
= $2; append_chain_callconv
($$
->type
, $1); }
1008 | abstract_direct_declarator
1011 /* abstract declarator without accepting direct declarator */
1012 abstract_declarator_no_direct:
1013 '*' m_type_qual_list m_any_declarator %prec PPTR
1014 { $$
= $3; append_chain_type
($$
, type_new_pointer
(NULL
), $2); }
1015 | callconv m_any_declarator
{ $$
= $2; append_chain_callconv
($$
->type
, $1); }
1018 /* abstract declarator or empty */
1019 m_abstract_declarator: { $$
= make_declarator
(NULL
); }
1020 | abstract_declarator
1023 /* abstract direct declarator */
1024 abstract_direct_declarator:
1025 '(' abstract_declarator_no_direct
')' { $$
= $2; }
1026 | abstract_direct_declarator array
{ $$
= $1; append_array
($$
, $2); }
1027 | array
{ $$
= make_declarator
(NULL
); append_array
($$
, $1); }
1029 { $$
= make_declarator
(NULL
);
1030 append_chain_type
($$
, type_new_function
($2), 0);
1032 | abstract_direct_declarator
'(' m_args
')'
1034 append_chain_type
($$
, type_new_function
($3), 0);
1038 /* abstract or non-abstract declarator */
1040 '*' m_type_qual_list m_any_declarator %prec PPTR
1041 { $$
= $3; append_chain_type
($$
, type_new_pointer
(NULL
), $2); }
1042 | callconv m_any_declarator
{ $$
= $2; append_chain_callconv
($$
->type
, $1); }
1043 | any_direct_declarator
1046 /* abstract or non-abstract declarator without accepting direct declarator */
1047 any_declarator_no_direct:
1048 '*' m_type_qual_list m_any_declarator %prec PPTR
1049 { $$
= $3; append_chain_type
($$
, type_new_pointer
(NULL
), $2); }
1050 | callconv m_any_declarator
{ $$
= $2; append_chain_callconv
($$
->type
, $1); }
1053 /* abstract or non-abstract declarator or empty */
1054 m_any_declarator: { $$
= make_declarator
(NULL
); }
1058 /* abstract or non-abstract direct declarator. note: direct declarators
1059 * aren't accepted inside brackets to avoid ambiguity with the rule for
1060 * function arguments */
1061 any_direct_declarator:
1062 ident
{ $$
= make_declarator
($1); }
1063 |
'(' any_declarator_no_direct
')' { $$
= $2; }
1064 | any_direct_declarator array
{ $$
= $1; append_array
($$
, $2); }
1065 | array
{ $$
= make_declarator
(NULL
); append_array
($$
, $1); }
1067 { $$
= make_declarator
(NULL
);
1068 append_chain_type
($$
, type_new_function
($2), 0);
1070 | any_direct_declarator
'(' m_args
')'
1072 append_chain_type
($$
, type_new_function
($3), 0);
1077 declarator
{ $$
= append_declarator
( NULL
, $1 ); }
1078 | declarator_list
',' declarator
{ $$
= append_declarator
( $1, $3 ); }
1081 m_bitfield: { $$
= NULL
; }
1082 |
':' expr_const
{ $$
= $2; }
1085 struct_declarator: any_declarator m_bitfield
{ $$
= $1; $$
->bits
= $2;
1086 if
(!$$
->bits
&& !$$
->var
->name
)
1087 error_loc
("unnamed fields are not allowed\n");
1091 struct_declarator_list:
1092 struct_declarator
{ $$
= append_declarator
( NULL
, $1 ); }
1093 | struct_declarator_list
',' struct_declarator
1094 { $$
= append_declarator
( $1, $3 ); }
1098 declarator
{ $$
= $1; }
1099 | declarator
'=' expr_const
{ $$
= $1; $1->var
->eval
= $3; }
1103 tAPARTMENT
{ $$
= THREADING_APARTMENT
; }
1104 | tNEUTRAL
{ $$
= THREADING_NEUTRAL
; }
1105 | tSINGLE
{ $$
= THREADING_SINGLE
; }
1106 | tFREE
{ $$
= THREADING_FREE
; }
1107 | tBOTH
{ $$
= THREADING_BOTH
; }
1111 tREF
{ $$
= FC_RP
; }
1112 | tUNIQUE
{ $$
= FC_UP
; }
1113 | tPTR
{ $$
= FC_FP
; }
1116 structdef: tSTRUCT t_ident
'{' fields
'}' { $$
= type_new_struct
($2, current_namespace
, TRUE
, $4); }
1119 type: tVOID
{ $$
= type_new_void
(); }
1120 | qualified_type
{ $$
= $1; }
1121 | base_type
{ $$
= $1; }
1122 | enumdef
{ $$
= $1; }
1123 | tENUM aIDENTIFIER
{ $$
= type_new_enum
($2, current_namespace
, FALSE
, NULL
); }
1124 | structdef
{ $$
= $1; }
1125 | tSTRUCT aIDENTIFIER
{ $$
= type_new_struct
($2, current_namespace
, FALSE
, NULL
); }
1126 | uniondef
{ $$
= $1; }
1127 | tUNION aIDENTIFIER
{ $$
= type_new_nonencapsulated_union
($2, FALSE
, NULL
); }
1128 | tSAFEARRAY
'(' type
')' { $$
= make_safearray
($3); }
1131 typedef: m_attributes tTYPEDEF m_attributes decl_spec declarator_list
1132 { $1 = append_attribs
($1, $3);
1133 reg_typedefs
($4, $5, check_typedef_attrs
($1));
1134 $$
= make_statement_typedef
($5, !$4->type
->defined
);
1138 uniondef: tUNION t_ident
'{' ne_union_fields
'}'
1139 { $$
= type_new_nonencapsulated_union
($2, TRUE
, $4); }
1141 tSWITCH
'(' s_field
')'
1142 m_ident
'{' cases
'}' { $$
= type_new_encapsulated_union
($2, $5, $7, $9); }
1146 aNUM
{ $$
= MAKEVERSION
($1, 0); }
1147 | aNUM
'.' aNUM
{ $$
= MAKEVERSION
($1, $3); }
1148 | aHEXNUM
{ $$
= $1; }
1153 | acf_interface acf_statements
1158 | acf_int_statement acf_int_statements
1162 : tTYPEDEF acf_attributes aKNOWNTYPE
';'
1163 { type_t
*type
= find_type_or_error
($3, 0);
1164 type
->attrs
= append_attr_list
(type
->attrs
, $2);
1169 : acf_attributes tINTERFACE aKNOWNTYPE
'{' acf_int_statements
'}'
1170 { type_t
*iface
= find_type_or_error2
($3, 0);
1171 if
(type_get_type
(iface
) != TYPE_INTERFACE
)
1172 error_loc
("%s is not an interface\n", iface
->name
);
1173 iface
->attrs
= append_attr_list
(iface
->attrs
, $1);
1178 : /* empty */ { $$
= NULL
; };
1179 |
'[' acf_attribute_list
']' { $$
= $2; };
1183 : acf_attribute
{ $$
= append_attr
(NULL
, $1); }
1184 | acf_attribute_list
',' acf_attribute
{ $$
= append_attr
($1, $3); }
1188 : tALLOCATE
'(' allocate_option_list
')'
1189 { $$
= make_attrv
(ATTR_ALLOCATE
, $3); }
1190 | tENCODE
{ $$
= make_attr
(ATTR_ENCODE
); }
1191 | tDECODE
{ $$
= make_attr
(ATTR_DECODE
); }
1192 | tEXPLICITHANDLE
{ $$
= make_attr
(ATTR_EXPLICIT_HANDLE
); }
1195 allocate_option_list
1196 : allocate_option
{ $$
= $1; }
1197 | allocate_option_list
',' allocate_option
1202 : tDONTFREE
{ $$
= FC_DONT_FREE
; }
1204 | tALLNODES
{ $$
= FC_ALLOCATE_ALL_NODES
; }
1205 | tSINGLENODE
{ $$
= 0; }
1210 static void decl_builtin_basic
(const char *name
, enum type_basic_type type
)
1212 type_t
*t
= type_new_basic
(type
);
1213 reg_type
(t
, name
, NULL
, 0);
1216 static void decl_builtin_alias
(const char *name
, type_t
*t
)
1218 const decl_spec_t ds
= {.type
= t
};
1219 reg_type
(type_new_alias
(&ds
, name
), name
, NULL
, 0);
1222 void init_types
(void)
1224 decl_builtin_basic
("byte", TYPE_BASIC_BYTE
);
1225 decl_builtin_basic
("wchar_t", TYPE_BASIC_WCHAR
);
1226 decl_builtin_basic
("float", TYPE_BASIC_FLOAT
);
1227 decl_builtin_basic
("double", TYPE_BASIC_DOUBLE
);
1228 decl_builtin_basic
("error_status_t", TYPE_BASIC_ERROR_STATUS_T
);
1229 decl_builtin_basic
("handle_t", TYPE_BASIC_HANDLE
);
1230 decl_builtin_alias
("boolean", type_new_basic
(TYPE_BASIC_CHAR
));
1233 static str_list_t
*append_str
(str_list_t
*list
, char *str
)
1235 struct str_list_entry_t
*entry
;
1237 if
(!str
) return list
;
1240 list
= xmalloc
( sizeof
(*list
) );
1243 entry
= xmalloc
( sizeof
(*entry
) );
1245 list_add_tail
( list
, &entry
->entry
);
1249 static attr_list_t
*append_attr
(attr_list_t
*list
, attr_t
*attr
)
1251 attr_t
*attr_existing
;
1252 if
(!attr
) return list
;
1255 list
= xmalloc
( sizeof
(*list
) );
1258 LIST_FOR_EACH_ENTRY
(attr_existing
, list
, attr_t
, entry
)
1259 if
(attr_existing
->type
== attr
->type
)
1261 parser_warning
("duplicate attribute %s\n", get_attr_display_name
(attr
->type
));
1262 /* use the last attribute, like MIDL does */
1263 list_remove
(&attr_existing
->entry
);
1266 list_add_tail
( list
, &attr
->entry
);
1270 static attr_list_t
*move_attr
(attr_list_t
*dst
, attr_list_t
*src
, enum attr_type type
)
1273 if
(!src
) return dst
;
1274 LIST_FOR_EACH_ENTRY
(attr
, src
, attr_t
, entry
)
1275 if
(attr
->type
== type
)
1277 list_remove
(&attr
->entry
);
1278 return append_attr
(dst
, attr
);
1283 static attr_list_t
*append_attr_list
(attr_list_t
*new_list
, attr_list_t
*old_list
)
1287 if
(!old_list
) return new_list
;
1289 while
((entry
= list_head
(old_list
)))
1291 attr_t
*attr
= LIST_ENTRY
(entry
, attr_t
, entry
);
1293 new_list
= append_attr
(new_list
, attr
);
1298 typedef
int (*map_attrs_filter_t
)(attr_list_t
*,const attr_t
*);
1300 static attr_list_t
*map_attrs
(const attr_list_t
*list
, map_attrs_filter_t filter
)
1302 attr_list_t
*new_list
;
1306 if
(!list
) return NULL
;
1308 new_list
= xmalloc
( sizeof
(*list
) );
1309 list_init
( new_list
);
1310 LIST_FOR_EACH_ENTRY
(attr
, list
, const attr_t
, entry
)
1312 if
(filter
&& !filter
(new_list
, attr
)) continue
;
1313 new_attr
= xmalloc
(sizeof
(*new_attr
));
1315 list_add_tail
(new_list
, &new_attr
->entry
);
1320 static decl_spec_t
*make_decl_spec
(type_t
*type
, decl_spec_t
*left
, decl_spec_t
*right
,
1321 enum storage_class stgclass
, enum type_qualifier qual
, enum function_specifier func_specifier
)
1323 decl_spec_t
*declspec
= left ? left
: right
;
1326 declspec
= xmalloc
(sizeof
(*declspec
));
1327 declspec
->type
= NULL
;
1328 declspec
->stgclass
= STG_NONE
;
1329 declspec
->qualifier
= 0;
1330 declspec
->func_specifier
= 0;
1332 declspec
->type
= type
;
1333 if
(left
&& declspec
!= left
)
1335 if
(declspec
->stgclass
== STG_NONE
)
1336 declspec
->stgclass
= left
->stgclass
;
1337 else if
(left
->stgclass
!= STG_NONE
)
1338 error_loc
("only one storage class can be specified\n");
1339 declspec
->qualifier |
= left
->qualifier
;
1340 declspec
->func_specifier |
= left
->func_specifier
;
1341 assert
(!left
->type
);
1344 if
(right
&& declspec
!= right
)
1346 if
(declspec
->stgclass
== STG_NONE
)
1347 declspec
->stgclass
= right
->stgclass
;
1348 else if
(right
->stgclass
!= STG_NONE
)
1349 error_loc
("only one storage class can be specified\n");
1350 declspec
->qualifier |
= right
->qualifier
;
1351 declspec
->func_specifier |
= right
->func_specifier
;
1352 assert
(!right
->type
);
1356 if
(declspec
->stgclass
== STG_NONE
)
1357 declspec
->stgclass
= stgclass
;
1358 else if
(stgclass
!= STG_NONE
)
1359 error_loc
("only one storage class can be specified\n");
1360 declspec
->qualifier |
= qual
;
1361 declspec
->func_specifier |
= func_specifier
;
1366 static attr_t
*make_attr
(enum attr_type type
)
1368 attr_t
*a
= xmalloc
(sizeof
(attr_t
));
1374 static attr_t
*make_attrv
(enum attr_type type
, unsigned int val
)
1376 attr_t
*a
= xmalloc
(sizeof
(attr_t
));
1382 static attr_t
*make_attrp
(enum attr_type type
, void *val
)
1384 attr_t
*a
= xmalloc
(sizeof
(attr_t
));
1390 static expr_list_t
*append_expr
(expr_list_t
*list
, expr_t
*expr
)
1392 if
(!expr
) return list
;
1395 list
= xmalloc
( sizeof
(*list
) );
1398 list_add_tail
( list
, &expr
->entry
);
1402 static void append_array
(declarator_t
*decl
, expr_t
*expr
)
1409 /* An array is always a reference pointer unless explicitly marked otherwise
1410 * (regardless of what the default pointer attribute is). */
1411 array
= type_new_array
(NULL
, NULL
, FALSE
, expr
->is_const ? expr
->cval
: 0,
1412 expr
->is_const ? NULL
: expr
, NULL
);
1414 append_chain_type
(decl
, array
, 0);
1417 static struct list type_pool
= LIST_INIT
(type_pool
);
1424 type_t
*alloc_type
(void)
1426 type_pool_node_t
*node
= xmalloc
(sizeof
*node
);
1427 list_add_tail
(&type_pool
, &node
->link
);
1431 void set_all_tfswrite
(int val
)
1433 type_pool_node_t
*node
;
1434 LIST_FOR_EACH_ENTRY
(node
, &type_pool
, type_pool_node_t
, link
)
1435 node
->data.tfswrite
= val
;
1438 void clear_all_offsets
(void)
1440 type_pool_node_t
*node
;
1441 LIST_FOR_EACH_ENTRY
(node
, &type_pool
, type_pool_node_t
, link
)
1442 node
->data.typestring_offset
= node
->data.ptrdesc
= 0;
1445 static void type_function_add_head_arg
(type_t
*type
, var_t
*arg
)
1447 if
(!type
->details.function
->args
)
1449 type
->details.function
->args
= xmalloc
( sizeof
(*type
->details.function
->args
) );
1450 list_init
( type
->details.function
->args
);
1452 list_add_head
( type
->details.function
->args
, &arg
->entry
);
1455 static int is_allowed_range_type
(const type_t
*type
)
1457 switch
(type_get_type
(type
))
1462 switch
(type_basic_get_type
(type
))
1464 case TYPE_BASIC_INT8
:
1465 case TYPE_BASIC_INT16
:
1466 case TYPE_BASIC_INT32
:
1467 case TYPE_BASIC_INT64
:
1468 case TYPE_BASIC_INT
:
1469 case TYPE_BASIC_INT3264
:
1470 case TYPE_BASIC_LONG
:
1471 case TYPE_BASIC_BYTE
:
1472 case TYPE_BASIC_CHAR
:
1473 case TYPE_BASIC_WCHAR
:
1474 case TYPE_BASIC_HYPER
:
1476 case TYPE_BASIC_FLOAT
:
1477 case TYPE_BASIC_DOUBLE
:
1478 case TYPE_BASIC_ERROR_STATUS_T
:
1479 case TYPE_BASIC_HANDLE
:
1488 static type_t
*get_chain_ref
(type_t
*type
)
1491 return type_pointer_get_ref_type
(type
);
1492 else if
(is_array
(type
))
1493 return type_array_get_element_type
(type
);
1494 else if
(is_func
(type
))
1495 return type_function_get_rettype
(type
);
1499 static type_t
*get_chain_end
(type_t
*type
)
1502 while
((inner
= get_chain_ref
(type
)))
1507 static void append_chain_type
(declarator_t
*decl
, type_t
*type
, enum type_qualifier qual
)
1514 decl
->qualifier
= qual
;
1517 chain_type
= get_chain_end
(decl
->type
);
1519 if
(is_ptr
(chain_type
))
1521 chain_type
->details.pointer.ref.type
= type
;
1522 chain_type
->details.pointer.ref.qualifier
= qual
;
1524 else if
(is_array
(chain_type
))
1526 chain_type
->details.array.elem.type
= type
;
1527 chain_type
->details.array.elem.qualifier
= qual
;
1529 else if
(is_func
(chain_type
))
1531 chain_type
->details.function
->retval
->declspec.type
= type
;
1532 chain_type
->details.function
->retval
->declspec.qualifier
= qual
;
1537 if
(!is_func
(chain_type
))
1538 type
->attrs
= move_attr
(type
->attrs
, chain_type
->attrs
, ATTR_CALLCONV
);
1541 static void append_chain_callconv
(type_t
*chain
, char *callconv
)
1545 if
(chain
&& (chain_end
= get_chain_end
(chain
)))
1546 chain_end
->attrs
= append_attr
(chain_end
->attrs
, make_attrp
(ATTR_CALLCONV
, callconv
));
1548 error_loc
("calling convention applied to non-function type\n");
1551 static warning_list_t
*append_warning
(warning_list_t
*list
, int num
)
1557 list
= xmalloc
( sizeof
(*list
) );
1560 entry
= xmalloc
( sizeof
(*entry
) );
1562 list_add_tail
( list
, &entry
->entry
);
1566 static var_t
*declare_var
(attr_list_t
*attrs
, decl_spec_t
*decl_spec
, declarator_t
*decl
,
1569 var_t
*v
= decl
->var
;
1570 expr_list_t
*sizes
= get_attrp
(attrs
, ATTR_SIZEIS
);
1571 expr_list_t
*lengs
= get_attrp
(attrs
, ATTR_LENGTHIS
);
1574 type_t
*type
= decl_spec
->type
;
1576 if
(decl_spec
->func_specifier
& FUNCTION_SPECIFIER_INLINE
)
1578 if
(!decl ||
!is_func
(decl
->type
))
1579 error_loc
("inline attribute applied to non-function type\n");
1582 /* add type onto the end of the pointers in pident->type */
1583 append_chain_type
(decl
, type
, decl_spec
->qualifier
);
1584 v
->declspec
= *decl_spec
;
1585 v
->declspec.type
= decl
->type
;
1586 v
->declspec.qualifier
= decl
->qualifier
;
1588 v
->declonly
= !type
->defined
;
1590 if
(is_attr
(type
->attrs
, ATTR_CALLCONV
) && !is_func
(type
))
1591 error_loc
("calling convention applied to non-function type\n");
1593 /* check for pointer attribute being applied to non-pointer, non-array
1595 if
(!is_array
(v
->declspec.type
))
1597 int ptr_attr
= get_attrv
(v
->attrs
, ATTR_POINTERTYPE
);
1598 const type_t
*ptr
= NULL
;
1599 for
(ptr
= v
->declspec.type
; ptr
&& !ptr_attr
; )
1601 ptr_attr
= get_attrv
(ptr
->attrs
, ATTR_POINTERTYPE
);
1602 if
(!ptr_attr
&& type_is_alias
(ptr
))
1603 ptr
= type_alias_get_aliasee_type
(ptr
);
1609 if
(ptr_attr
&& ptr_attr
!= FC_UP
&&
1610 type_get_type
(type_pointer_get_ref_type
(ptr
)) == TYPE_INTERFACE
)
1611 warning_loc_info
(&v
->loc_info
,
1612 "%s: pointer attribute applied to interface "
1613 "pointer type has no effect\n", v
->name
);
1614 if
(!ptr_attr
&& top
)
1616 /* FIXME: this is a horrible hack to cope with the issue that we
1617 * store an offset to the typeformat string in the type object, but
1618 * two typeformat strings may be written depending on whether the
1619 * pointer is a toplevel parameter or not */
1620 v
->declspec.type
= duptype
(v
->declspec.type
, 1);
1624 error_loc
("%s: pointer attribute applied to non-pointer type\n", v
->name
);
1627 if
(is_attr
(v
->attrs
, ATTR_STRING
))
1631 if
(!is_ptr
(v
->declspec.type
) && !is_array
(v
->declspec.type
))
1632 error_loc
("'%s': [string] attribute applied to non-pointer, non-array type\n",
1638 t
= type_pointer_get_ref_type
(t
);
1639 else if
(is_array
(t
))
1640 t
= type_array_get_element_type
(t
);
1645 if
(type_get_type
(t
) != TYPE_BASIC
&&
1646 (get_basic_fc
(t
) != FC_CHAR
&&
1647 get_basic_fc
(t
) != FC_BYTE
&&
1648 get_basic_fc
(t
) != FC_WCHAR
))
1650 error_loc
("'%s': [string] attribute is only valid on 'char', 'byte', or 'wchar_t' pointers and arrays\n",
1655 if
(is_attr
(v
->attrs
, ATTR_V1ENUM
))
1657 if
(type_get_type_detect_alias
(v
->declspec.type
) != TYPE_ENUM
)
1658 error_loc
("'%s': [v1_enum] attribute applied to non-enum type\n", v
->name
);
1661 if
(is_attr
(v
->attrs
, ATTR_RANGE
) && !is_allowed_range_type
(v
->declspec.type
))
1662 error_loc
("'%s': [range] attribute applied to non-integer type\n",
1665 ptype
= &v
->declspec.type
;
1666 if
(sizes
) LIST_FOR_EACH_ENTRY
(dim
, sizes
, expr_t
, entry
)
1668 if
(dim
->type
!= EXPR_VOID
)
1670 if
(is_array
(*ptype
))
1672 if
(!type_array_get_conformance
(*ptype
) ||
1673 type_array_get_conformance
(*ptype
)->type
!= EXPR_VOID
)
1674 error_loc
("%s: cannot specify size_is for an already sized array\n", v
->name
);
1676 *ptype
= type_new_array
((*ptype
)->name
,
1677 type_array_get_element
(*ptype
), FALSE
,
1680 else if
(is_ptr
(*ptype
))
1681 *ptype
= type_new_array
((*ptype
)->name
, type_pointer_get_ref
(*ptype
), TRUE
,
1684 error_loc
("%s: size_is attribute applied to illegal type\n", v
->name
);
1688 ptype
= &(*ptype
)->details.pointer.ref.type
;
1689 else if
(is_array
(*ptype
))
1690 ptype
= &(*ptype
)->details.array.elem.type
;
1692 error_loc
("%s: too many expressions in size_is attribute\n", v
->name
);
1695 ptype
= &v
->declspec.type
;
1696 if
(lengs
) LIST_FOR_EACH_ENTRY
(dim
, lengs
, expr_t
, entry
)
1698 if
(dim
->type
!= EXPR_VOID
)
1700 if
(is_array
(*ptype
))
1702 *ptype
= type_new_array
((*ptype
)->name
,
1703 type_array_get_element
(*ptype
),
1704 type_array_is_decl_as_ptr
(*ptype
),
1705 type_array_get_dim
(*ptype
),
1706 type_array_get_conformance
(*ptype
), dim
);
1709 error_loc
("%s: length_is attribute applied to illegal type\n", v
->name
);
1713 ptype
= &(*ptype
)->details.pointer.ref.type
;
1714 else if
(is_array
(*ptype
))
1715 ptype
= &(*ptype
)->details.array.elem.type
;
1717 error_loc
("%s: too many expressions in length_is attribute\n", v
->name
);
1721 v
->declspec.type
= type_new_bitfield
(v
->declspec.type
, decl
->bits
);
1726 static var_list_t
*set_var_types
(attr_list_t
*attrs
, decl_spec_t
*decl_spec
, declarator_list_t
*decls
)
1728 declarator_t
*decl
, *next
;
1729 var_list_t
*var_list
= NULL
;
1731 LIST_FOR_EACH_ENTRY_SAFE
( decl
, next
, decls
, declarator_t
, entry
)
1733 var_t
*var
= declare_var
(attrs
, decl_spec
, decl
, 0);
1734 var_list
= append_var
(var_list
, var
);
1741 static ifref_list_t
*append_ifref
(ifref_list_t
*list
, ifref_t
*iface
)
1743 if
(!iface
) return list
;
1746 list
= xmalloc
( sizeof
(*list
) );
1749 list_add_tail
( list
, &iface
->entry
);
1753 static ifref_t
*make_ifref
(type_t
*iface
)
1755 ifref_t
*l
= xmalloc
(sizeof
(ifref_t
));
1761 var_list_t
*append_var
(var_list_t
*list
, var_t
*var
)
1763 if
(!var
) return list
;
1766 list
= xmalloc
( sizeof
(*list
) );
1769 list_add_tail
( list
, &var
->entry
);
1773 static var_list_t
*append_var_list
(var_list_t
*list
, var_list_t
*vars
)
1775 if
(!vars
) return list
;
1778 list
= xmalloc
( sizeof
(*list
) );
1781 list_move_tail
( list
, vars
);
1785 var_t
*make_var
(char *name
)
1787 var_t
*v
= xmalloc
(sizeof
(var_t
));
1789 init_declspec
(&v
->declspec
, NULL
);
1792 init_loc_info
(&v
->loc_info
);
1793 v
->declonly
= FALSE
;
1797 static var_t
*copy_var
(var_t
*src
, char *name
, map_attrs_filter_t attr_filter
)
1799 var_t
*v
= xmalloc
(sizeof
(var_t
));
1801 v
->declspec
= src
->declspec
;
1802 v
->attrs
= map_attrs
(src
->attrs
, attr_filter
);
1803 v
->eval
= src
->eval
;
1804 v
->loc_info
= src
->loc_info
;
1808 static declarator_list_t
*append_declarator
(declarator_list_t
*list
, declarator_t
*d
)
1810 if
(!d
) return list
;
1812 list
= xmalloc
(sizeof
(*list
));
1815 list_add_tail
(list
, &d
->entry
);
1819 static declarator_t
*make_declarator
(var_t
*var
)
1821 declarator_t
*d
= xmalloc
(sizeof
(*d
));
1822 d
->var
= var ? var
: make_var
(NULL
);
1829 static type_t
*make_safearray
(type_t
*type
)
1831 decl_spec_t ds
= {.type
= type
};
1832 ds.type
= type_new_alias
(&ds
, "SAFEARRAY");
1833 return type_new_array
(NULL
, &ds
, TRUE
, 0, NULL
, NULL
);
1836 static typelib_t
*make_library
(const char *name
, const attr_list_t
*attrs
)
1838 typelib_t
*typelib
= xmalloc
(sizeof
(*typelib
));
1839 memset
(typelib
, 0, sizeof
(*typelib
));
1840 typelib
->name
= xstrdup
(name
);
1841 typelib
->attrs
= attrs
;
1842 list_init
( &typelib
->importlibs
);
1846 static int hash_ident
(const char *name
)
1848 const char *p
= name
;
1850 /* a simple sum hash is probably good enough */
1855 return sum
& (HASHMAX
-1);
1858 /***** type repository *****/
1860 static struct namespace
*find_sub_namespace
(struct namespace
*namespace
, const char *name
)
1862 struct namespace
*cur
;
1864 LIST_FOR_EACH_ENTRY
(cur
, &namespace
->children
, struct namespace
, entry
) {
1865 if
(!strcmp
(cur
->name
, name
))
1872 static void push_namespace
(const char *name
)
1874 struct namespace
*namespace
;
1876 namespace
= find_sub_namespace
(current_namespace
, name
);
1878 namespace
= xmalloc
(sizeof
(*namespace
));
1879 namespace
->name
= xstrdup
(name
);
1880 namespace
->parent
= current_namespace
;
1881 list_add_tail
(¤t_namespace
->children
, &namespace
->entry
);
1882 list_init
(&namespace
->children
);
1883 memset
(namespace
->type_hash
, 0, sizeof
(namespace
->type_hash
));
1886 current_namespace
= namespace
;
1889 static void pop_namespace
(const char *name
)
1891 assert
(!strcmp
(current_namespace
->name
, name
) && current_namespace
->parent
);
1892 current_namespace
= current_namespace
->parent
;
1895 static void init_lookup_namespace
(const char *name
)
1897 if
(!(lookup_namespace
= find_sub_namespace
(&global_namespace
, name
)))
1898 error_loc
("namespace '%s' not found\n", name
);
1901 static void push_lookup_namespace
(const char *name
)
1903 struct namespace
*namespace
;
1904 if
(!(namespace
= find_sub_namespace
(lookup_namespace
, name
)))
1905 error_loc
("namespace '%s' not found\n", name
);
1906 lookup_namespace
= namespace
;
1916 type_t
*reg_type
(type_t
*type
, const char *name
, struct namespace
*namespace
, int t
)
1921 error_loc
("registering named type without name\n");
1925 namespace
= &global_namespace
;
1926 hash
= hash_ident
(name
);
1927 nt
= xmalloc
(sizeof
(struct rtype
));
1929 if
(is_global_namespace
(namespace
))
1930 type
->c_name
= name
;
1932 type
->c_name
= format_namespace
(namespace
, "__x_", "_C", name
);
1935 nt
->next
= namespace
->type_hash
[hash
];
1936 namespace
->type_hash
[hash
] = nt
;
1940 static type_t
*reg_typedefs
(decl_spec_t
*decl_spec
, declarator_list_t
*decls
, attr_list_t
*attrs
)
1943 type_t
*type
= decl_spec
->type
;
1945 if
(is_attr
(attrs
, ATTR_UUID
) && !is_attr
(attrs
, ATTR_PUBLIC
))
1946 attrs
= append_attr
( attrs
, make_attr
(ATTR_PUBLIC
) );
1948 /* We must generate names for tagless enum, struct or union.
1949 Typedef-ing a tagless enum, struct or union means we want the typedef
1950 to be included in a library hence the public attribute. */
1951 if
(type_get_type_detect_alias
(type
) == TYPE_ENUM ||
1952 type_get_type_detect_alias
(type
) == TYPE_STRUCT ||
1953 type_get_type_detect_alias
(type
) == TYPE_UNION ||
1954 type_get_type_detect_alias
(type
) == TYPE_ENCAPSULATED_UNION
)
1958 type
->name
= gen_name
();
1959 if
(!is_attr
(attrs
, ATTR_PUBLIC
))
1960 attrs
= append_attr
(attrs
, make_attr
(ATTR_PUBLIC
));
1963 /* replace existing attributes when generating a typelib */
1965 type
->attrs
= attrs
;
1968 LIST_FOR_EACH_ENTRY
( decl
, decls
, declarator_t
, entry
)
1971 if
(decl
->var
->name
) {
1975 cur
= find_type
(decl
->var
->name
, current_namespace
, 0);
1978 * MIDL allows shadowing types that are declared in imported files.
1979 * We don't throw an error in this case and instead add a new type
1980 * (which is earlier on the list in hash table, so it will be used
1981 * instead of shadowed type).
1983 * FIXME: We may consider string separated type tables for each input
1984 * for cleaner solution.
1986 if
(cur
&& input_name
== cur
->loc_info.input_name
)
1987 error_loc
("%s: redefinition error; original definition was at %s:%d\n",
1988 cur
->name
, cur
->loc_info.input_name
,
1989 cur
->loc_info.line_number
);
1991 name
= declare_var
(attrs
, decl_spec
, decl
, 0);
1992 cur
= type_new_alias
(&name
->declspec
, name
->name
);
1995 reg_type
(cur
, cur
->name
, current_namespace
, 0);
2001 type_t
*find_type
(const char *name
, struct namespace
*namespace
, int t
)
2005 if
(namespace
&& namespace
!= &global_namespace
) {
2006 for
(cur
= namespace
->type_hash
[hash_ident
(name
)]; cur
; cur
= cur
->next
) {
2007 if
(cur
->t
== t
&& !strcmp
(cur
->name
, name
))
2011 for
(cur
= global_namespace.type_hash
[hash_ident
(name
)]; cur
; cur
= cur
->next
) {
2012 if
(cur
->t
== t
&& !strcmp
(cur
->name
, name
))
2018 static type_t
*find_type_or_error
(const char *name
, int t
)
2021 if
(!(type
= find_type
(name
, current_namespace
, t
)) &&
2022 !(type
= find_type
(name
, lookup_namespace
, t
)))
2024 error_loc
("type '%s' not found\n", name
);
2030 static type_t
*find_type_or_error2
(char *name
, int t
)
2032 type_t
*tp
= find_type_or_error
(name
, t
);
2037 int is_type
(const char *name
)
2039 return find_type
(name
, current_namespace
, 0) != NULL ||
2040 find_type
(name
, lookup_namespace
, 0) != NULL
;
2043 int is_namespace
(const char *name
)
2045 if
(!winrt_mode
) return
0;
2046 return find_sub_namespace
(current_namespace
, name
) != NULL ||
2047 find_sub_namespace
(&global_namespace
, name
) != NULL
;
2050 type_t
*get_type
(enum type_type type
, char *name
, struct namespace
*namespace
, int t
)
2054 namespace
= &global_namespace
;
2056 tp
= find_type
(name
, namespace
, t
);
2062 tp
= make_type
(type
);
2064 tp
->namespace
= namespace
;
2065 if
(!name
) return tp
;
2066 return reg_type
(tp
, name
, namespace
, t
);
2069 /***** constant repository *****/
2074 struct rconst
*next
;
2077 struct rconst
*const_hash
[HASHMAX
];
2079 static var_t
*reg_const
(var_t
*var
)
2084 error_loc
("registering constant without name\n");
2087 hash
= hash_ident
(var
->name
);
2088 nc
= xmalloc
(sizeof
(struct rconst
));
2089 nc
->name
= var
->name
;
2091 nc
->next
= const_hash
[hash
];
2092 const_hash
[hash
] = nc
;
2096 var_t
*find_const
(const char *name
, int f
)
2098 struct rconst
*cur
= const_hash
[hash_ident
(name
)];
2099 while
(cur
&& strcmp
(cur
->name
, name
))
2102 if
(f
) error_loc
("constant '%s' not found\n", name
);
2108 char *gen_name
(void)
2110 static unsigned long n
= 0;
2111 static const char *file_id
;
2115 char *dst
= dup_basename
(input_idl_name
, ".idl");
2119 if
(! isalnum
((unsigned char) *dst
))
2122 return strmake
("__WIDL_%s_generated_name_%08lX", file_id
, n
++);
2127 unsigned int dce_compatible
: 1;
2128 unsigned int acf
: 1;
2129 unsigned int on_interface
: 1;
2130 unsigned int on_function
: 1;
2131 unsigned int on_arg
: 1;
2132 unsigned int on_type
: 1;
2133 unsigned int on_enum
: 1;
2134 unsigned int on_enum_member
: 1;
2135 unsigned int on_struct
: 2;
2136 unsigned int on_union
: 1;
2137 unsigned int on_field
: 1;
2138 unsigned int on_library
: 1;
2139 unsigned int on_dispinterface
: 1;
2140 unsigned int on_module
: 1;
2141 unsigned int on_coclass
: 1;
2142 const char *display_name
;
2145 struct allowed_attr allowed_attr
[] =
2147 /* attr { D ACF I Fn ARG T En Enm St Un Fi L DI M C <display name> } */
2148 /* ATTR_AGGREGATABLE */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "aggregatable" },
2149 /* ATTR_ALLOCATE */ { 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "allocate" },
2150 /* ATTR_ANNOTATION */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "annotation" },
2151 /* ATTR_APPOBJECT */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "appobject" },
2152 /* ATTR_ASYNC */ { 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "async" },
2153 /* ATTR_ASYNCUUID */ { 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, "async_uuid" },
2154 /* ATTR_AUTO_HANDLE */ { 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "auto_handle" },
2155 /* ATTR_BINDABLE */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "bindable" },
2156 /* ATTR_BROADCAST */ { 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "broadcast" },
2157 /* ATTR_CALLAS */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "call_as" },
2158 /* ATTR_CALLCONV */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL
},
2159 /* ATTR_CASE */ { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, "case" },
2160 /* ATTR_CODE */ { 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "code" },
2161 /* ATTR_COMMSTATUS */ { 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "comm_status" },
2162 /* ATTR_CONTEXTHANDLE */ { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "context_handle" },
2163 /* ATTR_CONTROL */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, "control" },
2164 /* ATTR_DECODE */ { 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "decode" },
2165 /* ATTR_DEFAULT */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, "default" },
2166 /* ATTR_DEFAULTBIND */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "defaultbind" },
2167 /* ATTR_DEFAULTCOLLELEM */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "defaultcollelem" },
2168 /* ATTR_DEFAULTVALUE */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "defaultvalue" },
2169 /* ATTR_DEFAULTVTABLE */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "defaultvtable" },
2170 /* ATTR_DISABLECONSISTENCYCHECK */{ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "disable_consistency_check" },
2171 /* ATTR_DISPINTERFACE */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL
},
2172 /* ATTR_DISPLAYBIND */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "displaybind" },
2173 /* ATTR_DLLNAME */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, "dllname" },
2174 /* ATTR_DUAL */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "dual" },
2175 /* ATTR_ENABLEALLOCATE */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "enable_allocate" },
2176 /* ATTR_ENCODE */ { 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "encode" },
2177 /* ATTR_ENDPOINT */ { 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "endpoint" },
2178 /* ATTR_ENTRY */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "entry" },
2179 /* ATTR_EXPLICIT_HANDLE */ { 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "explicit_handle" },
2180 /* ATTR_FAULTSTATUS */ { 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "fault_status" },
2181 /* ATTR_FORCEALLOCATE */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "force_allocate" },
2182 /* ATTR_HANDLE */ { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "handle" },
2183 /* ATTR_HELPCONTEXT */ { 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, "helpcontext" },
2184 /* ATTR_HELPFILE */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, "helpfile" },
2185 /* ATTR_HELPSTRING */ { 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, "helpstring" },
2186 /* ATTR_HELPSTRINGCONTEXT */ { 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, "helpstringcontext" },
2187 /* ATTR_HELPSTRINGDLL */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, "helpstringdll" },
2188 /* ATTR_HIDDEN */ { 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, "hidden" },
2189 /* ATTR_ID */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, "id" },
2190 /* ATTR_IDEMPOTENT */ { 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "idempotent" },
2191 /* ATTR_IGNORE */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, "ignore" },
2192 /* ATTR_IIDIS */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, "iid_is" },
2193 /* ATTR_IMMEDIATEBIND */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "immediatebind" },
2194 /* ATTR_IMPLICIT_HANDLE */ { 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "implicit_handle" },
2195 /* ATTR_IN */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "in" },
2196 /* ATTR_INPUTSYNC */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "inputsync" },
2197 /* ATTR_LENGTHIS */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, "length_is" },
2198 /* ATTR_LIBLCID */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, "lcid" },
2199 /* ATTR_LICENSED */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "licensed" },
2200 /* ATTR_LOCAL */ { 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "local" },
2201 /* ATTR_MAYBE */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "maybe" },
2202 /* ATTR_MESSAGE */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "message" },
2203 /* ATTR_NOCODE */ { 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "nocode" },
2204 /* ATTR_NONBROWSABLE */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "nonbrowsable" },
2205 /* ATTR_NONCREATABLE */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "noncreatable" },
2206 /* ATTR_NONEXTENSIBLE */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "nonextensible" },
2207 /* ATTR_NOTIFY */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "notify" },
2208 /* ATTR_NOTIFYFLAG */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "notify_flag" },
2209 /* ATTR_OBJECT */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "object" },
2210 /* ATTR_ODL */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, "odl" },
2211 /* ATTR_OLEAUTOMATION */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "oleautomation" },
2212 /* ATTR_OPTIMIZE */ { 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "optimize" },
2213 /* ATTR_OPTIONAL */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "optional" },
2214 /* ATTR_OUT */ { 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "out" },
2215 /* ATTR_PARAMLCID */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "lcid" },
2216 /* ATTR_PARTIALIGNORE */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "partial_ignore" },
2217 /* ATTR_POINTERDEFAULT */ { 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "pointer_default" },
2218 /* ATTR_POINTERTYPE */ { 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, "ref, unique or ptr" },
2219 /* ATTR_PROGID */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "progid" },
2220 /* ATTR_PROPGET */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "propget" },
2221 /* ATTR_PROPPUT */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "propput" },
2222 /* ATTR_PROPPUTREF */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "propputref" },
2223 /* ATTR_PROXY */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "proxy" },
2224 /* ATTR_PUBLIC */ { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "public" },
2225 /* ATTR_RANGE */ { 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, "range" },
2226 /* ATTR_READONLY */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, "readonly" },
2227 /* ATTR_REPRESENTAS */ { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "represent_as" },
2228 /* ATTR_REQUESTEDIT */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "requestedit" },
2229 /* ATTR_RESTRICTED */ { 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, "restricted" },
2230 /* ATTR_RETVAL */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "retval" },
2231 /* ATTR_SIZEIS */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, "size_is" },
2232 /* ATTR_SOURCE */ { 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, "source" },
2233 /* ATTR_STRICTCONTEXTHANDLE */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "strict_context_handle" },
2234 /* ATTR_STRING */ { 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, "string" },
2235 /* ATTR_SWITCHIS */ { 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, "switch_is" },
2236 /* ATTR_SWITCHTYPE */ { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, "switch_type" },
2237 /* ATTR_THREADING */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "threading" },
2238 /* ATTR_TRANSMITAS */ { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "transmit_as" },
2239 /* ATTR_UIDEFAULT */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "uidefault" },
2240 /* ATTR_USESGETLASTERROR */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "usesgetlasterror" },
2241 /* ATTR_USERMARSHAL */ { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "user_marshal" },
2242 /* ATTR_UUID */ { 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, "uuid" },
2243 /* ATTR_V1ENUM */ { 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, "v1_enum" },
2244 /* ATTR_VARARG */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "vararg" },
2245 /* ATTR_VERSION */ { 1, 0, 1, 0, 0, 1, 1, 0, 2, 0, 0, 1, 0, 0, 1, "version" },
2246 /* ATTR_VIPROGID */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "vi_progid" },
2247 /* ATTR_WIREMARSHAL */ { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "wire_marshal" },
2250 const char *get_attr_display_name
(enum attr_type type
)
2252 return allowed_attr
[type
].display_name
;
2255 static attr_list_t
*check_iface_attrs
(const char *name
, attr_list_t
*attrs
)
2258 if
(!attrs
) return attrs
;
2259 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2261 if
(!allowed_attr
[attr
->type
].on_interface
)
2262 error_loc
("inapplicable attribute %s for interface %s\n",
2263 allowed_attr
[attr
->type
].display_name
, name
);
2264 if
(attr
->type
== ATTR_IMPLICIT_HANDLE
)
2266 const var_t
*var
= attr
->u.pval
;
2267 if
(type_get_type
( var
->declspec.type
) == TYPE_BASIC
&&
2268 type_basic_get_type
( var
->declspec.type
) == TYPE_BASIC_HANDLE
)
2270 if
(is_aliaschain_attr
( var
->declspec.type
, ATTR_HANDLE
))
2272 error_loc
("attribute %s requires a handle type in interface %s\n",
2273 allowed_attr
[attr
->type
].display_name
, name
);
2279 static attr_list_t
*check_function_attrs
(const char *name
, attr_list_t
*attrs
)
2282 if
(!attrs
) return attrs
;
2283 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2285 if
(!allowed_attr
[attr
->type
].on_function
)
2286 error_loc
("inapplicable attribute %s for function %s\n",
2287 allowed_attr
[attr
->type
].display_name
, name
);
2292 static void check_arg_attrs
(const var_t
*arg
)
2298 LIST_FOR_EACH_ENTRY
(attr
, arg
->attrs
, const attr_t
, entry
)
2300 if
(!allowed_attr
[attr
->type
].on_arg
)
2301 error_loc
("inapplicable attribute %s for argument %s\n",
2302 allowed_attr
[attr
->type
].display_name
, arg
->name
);
2307 static attr_list_t
*check_typedef_attrs
(attr_list_t
*attrs
)
2310 if
(!attrs
) return attrs
;
2311 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2313 if
(!allowed_attr
[attr
->type
].on_type
)
2314 error_loc
("inapplicable attribute %s for typedef\n",
2315 allowed_attr
[attr
->type
].display_name
);
2320 static attr_list_t
*check_enum_attrs
(attr_list_t
*attrs
)
2323 if
(!attrs
) return attrs
;
2324 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2326 if
(!allowed_attr
[attr
->type
].on_enum
)
2327 error_loc
("inapplicable attribute %s for enum\n",
2328 allowed_attr
[attr
->type
].display_name
);
2333 static attr_list_t
*check_enum_member_attrs
(attr_list_t
*attrs
)
2336 if
(!attrs
) return attrs
;
2337 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2339 if
(!allowed_attr
[attr
->type
].on_enum_member
)
2340 error_loc
("inapplicable attribute %s for enum member\n",
2341 allowed_attr
[attr
->type
].display_name
);
2346 static attr_list_t
*check_struct_attrs
(attr_list_t
*attrs
)
2348 int mask
= winrt_mode ?
3 : 1;
2350 if
(!attrs
) return attrs
;
2351 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2353 if
(!(allowed_attr
[attr
->type
].on_struct
& mask
))
2354 error_loc
("inapplicable attribute %s for struct\n",
2355 allowed_attr
[attr
->type
].display_name
);
2360 static attr_list_t
*check_union_attrs
(attr_list_t
*attrs
)
2363 if
(!attrs
) return attrs
;
2364 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2366 if
(!allowed_attr
[attr
->type
].on_union
)
2367 error_loc
("inapplicable attribute %s for union\n",
2368 allowed_attr
[attr
->type
].display_name
);
2373 static attr_list_t
*check_field_attrs
(const char *name
, attr_list_t
*attrs
)
2376 if
(!attrs
) return attrs
;
2377 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2379 if
(!allowed_attr
[attr
->type
].on_field
)
2380 error_loc
("inapplicable attribute %s for field %s\n",
2381 allowed_attr
[attr
->type
].display_name
, name
);
2386 static attr_list_t
*check_library_attrs
(const char *name
, attr_list_t
*attrs
)
2389 if
(!attrs
) return attrs
;
2390 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2392 if
(!allowed_attr
[attr
->type
].on_library
)
2393 error_loc
("inapplicable attribute %s for library %s\n",
2394 allowed_attr
[attr
->type
].display_name
, name
);
2399 static attr_list_t
*check_dispiface_attrs
(const char *name
, attr_list_t
*attrs
)
2402 if
(!attrs
) return attrs
;
2403 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2405 if
(!allowed_attr
[attr
->type
].on_dispinterface
)
2406 error_loc
("inapplicable attribute %s for dispinterface %s\n",
2407 allowed_attr
[attr
->type
].display_name
, name
);
2412 static attr_list_t
*check_module_attrs
(const char *name
, attr_list_t
*attrs
)
2415 if
(!attrs
) return attrs
;
2416 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2418 if
(!allowed_attr
[attr
->type
].on_module
)
2419 error_loc
("inapplicable attribute %s for module %s\n",
2420 allowed_attr
[attr
->type
].display_name
, name
);
2425 static attr_list_t
*check_coclass_attrs
(const char *name
, attr_list_t
*attrs
)
2428 if
(!attrs
) return attrs
;
2429 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2431 if
(!allowed_attr
[attr
->type
].on_coclass
)
2432 error_loc
("inapplicable attribute %s for coclass %s\n",
2433 allowed_attr
[attr
->type
].display_name
, name
);
2438 static int is_allowed_conf_type
(const type_t
*type
)
2440 switch
(type_get_type
(type
))
2445 switch
(type_basic_get_type
(type
))
2447 case TYPE_BASIC_INT8
:
2448 case TYPE_BASIC_INT16
:
2449 case TYPE_BASIC_INT32
:
2450 case TYPE_BASIC_INT64
:
2451 case TYPE_BASIC_INT
:
2452 case TYPE_BASIC_LONG
:
2453 case TYPE_BASIC_CHAR
:
2454 case TYPE_BASIC_HYPER
:
2455 case TYPE_BASIC_BYTE
:
2456 case TYPE_BASIC_WCHAR
:
2462 /* shouldn't get here because of type_get_type call above */
2467 case TYPE_ENCAPSULATED_UNION
:
2474 case TYPE_INTERFACE
:
2481 static int is_ptr_guid_type
(const type_t
*type
)
2483 /* first, make sure it is a pointer to something */
2484 if
(!is_ptr
(type
)) return FALSE
;
2486 /* second, make sure it is a pointer to something of size sizeof(GUID),
2488 return
(type_memsize
(type_pointer_get_ref_type
(type
)) == 16);
2491 static void check_conformance_expr_list
(const char *attr_name
, const var_t
*arg
, const type_t
*container_type
, expr_list_t
*expr_list
)
2494 struct expr_loc expr_loc
;
2496 expr_loc.attr
= attr_name
;
2497 if
(expr_list
) LIST_FOR_EACH_ENTRY
(dim
, expr_list
, expr_t
, entry
)
2499 if
(dim
->type
!= EXPR_VOID
)
2501 const type_t
*expr_type
= expr_resolve_type
(&expr_loc
, container_type
, dim
);
2502 if
(!is_allowed_conf_type
(expr_type
))
2503 error_loc_info
(&arg
->loc_info
, "expression must resolve to integral type <= 32bits for attribute %s\n",
2509 static void check_remoting_fields
(const var_t
*var
, type_t
*type
);
2511 /* checks that properties common to fields and arguments are consistent */
2512 static void check_field_common
(const type_t
*container_type
,
2513 const char *container_name
, const var_t
*arg
)
2515 type_t
*type
= arg
->declspec.type
;
2517 const char *container_type_name
;
2518 const char *var_type
;
2520 switch
(type_get_type
(container_type
))
2523 container_type_name
= "struct";
2527 container_type_name
= "union";
2530 case TYPE_ENCAPSULATED_UNION
:
2531 container_type_name
= "encapsulated union";
2535 container_type_name
= "function";
2536 var_type
= "parameter";
2539 /* should be no other container types */
2544 if
(is_attr
(arg
->attrs
, ATTR_LENGTHIS
) &&
2545 (is_attr
(arg
->attrs
, ATTR_STRING
) || is_aliaschain_attr
(arg
->declspec.type
, ATTR_STRING
)))
2546 error_loc_info
(&arg
->loc_info
,
2547 "string and length_is specified for argument %s are mutually exclusive attributes\n",
2550 if
(is_attr
(arg
->attrs
, ATTR_SIZEIS
))
2552 expr_list_t
*size_is_exprs
= get_attrp
(arg
->attrs
, ATTR_SIZEIS
);
2553 check_conformance_expr_list
("size_is", arg
, container_type
, size_is_exprs
);
2555 if
(is_attr
(arg
->attrs
, ATTR_LENGTHIS
))
2557 expr_list_t
*length_is_exprs
= get_attrp
(arg
->attrs
, ATTR_LENGTHIS
);
2558 check_conformance_expr_list
("length_is", arg
, container_type
, length_is_exprs
);
2560 if
(is_attr
(arg
->attrs
, ATTR_IIDIS
))
2562 struct expr_loc expr_loc
;
2563 expr_t
*expr
= get_attrp
(arg
->attrs
, ATTR_IIDIS
);
2564 if
(expr
->type
!= EXPR_VOID
)
2566 const type_t
*expr_type
;
2568 expr_loc.attr
= "iid_is";
2569 expr_type
= expr_resolve_type
(&expr_loc
, container_type
, expr
);
2570 if
(!expr_type ||
!is_ptr_guid_type
(expr_type
))
2571 error_loc_info
(&arg
->loc_info
, "expression must resolve to pointer to GUID type for attribute iid_is\n");
2574 if
(is_attr
(arg
->attrs
, ATTR_SWITCHIS
))
2576 struct expr_loc expr_loc
;
2577 expr_t
*expr
= get_attrp
(arg
->attrs
, ATTR_SWITCHIS
);
2578 if
(expr
->type
!= EXPR_VOID
)
2580 const type_t
*expr_type
;
2582 expr_loc.attr
= "switch_is";
2583 expr_type
= expr_resolve_type
(&expr_loc
, container_type
, expr
);
2584 if
(!expr_type ||
!is_allowed_conf_type
(expr_type
))
2585 error_loc_info
(&arg
->loc_info
, "expression must resolve to integral type <= 32bits for attribute %s\n",
2594 switch
(typegen_detect_type
(type
, arg
->attrs
, TDT_IGNORE_STRINGS
))
2598 check_remoting_fields
(arg
, type
);
2602 const char *reason
= "is invalid";
2603 switch
(type_get_type
(type
))
2606 reason
= "cannot derive from void *";
2609 reason
= "cannot be a function pointer";
2612 reason
= "cannot be a bit-field";
2615 reason
= "cannot be a class";
2617 case TYPE_INTERFACE
:
2618 reason
= "cannot be a non-pointer to an interface";
2621 reason
= "cannot be a module";
2626 error_loc_info
(&arg
->loc_info
, "%s \'%s\' of %s \'%s\' %s\n",
2627 var_type
, arg
->name
, container_type_name
, container_name
, reason
);
2630 case TGT_CTXT_HANDLE
:
2631 case TGT_CTXT_HANDLE_POINTER
:
2632 if
(type_get_type
(container_type
) != TYPE_FUNCTION
)
2633 error_loc_info
(&arg
->loc_info
,
2634 "%s \'%s\' of %s \'%s\' cannot be a context handle\n",
2635 var_type
, arg
->name
, container_type_name
,
2640 const type_t
*t
= type
;
2642 t
= type_pointer_get_ref_type
(t
);
2643 if
(is_aliaschain_attr
(t
, ATTR_RANGE
))
2644 warning_loc_info
(&arg
->loc_info
, "%s: range not verified for a string of ranged types\n", arg
->name
);
2648 type
= type_pointer_get_ref_type
(type
);
2652 type
= type_array_get_element_type
(type
);
2656 type
= type_get_real_type
(type
);
2657 if
(!type_is_complete
(type
))
2659 error_loc_info
(&arg
->loc_info
, "undefined type declaration \"enum %s\"\n", type
->name
);
2662 case TGT_IFACE_POINTER
:
2668 } while
(more_to_do
);
2671 static void check_remoting_fields
(const var_t
*var
, type_t
*type
)
2674 const var_list_t
*fields
= NULL
;
2676 type
= type_get_real_type
(type
);
2681 type
->checked
= TRUE
;
2683 if
(type_get_type
(type
) == TYPE_STRUCT
)
2685 if
(type_is_complete
(type
))
2686 fields
= type_struct_get_fields
(type
);
2688 error_loc_info
(&var
->loc_info
, "undefined type declaration \"struct %s\"\n", type
->name
);
2690 else if
(type_get_type
(type
) == TYPE_UNION || type_get_type
(type
) == TYPE_ENCAPSULATED_UNION
)
2692 if
(type_is_complete
(type
))
2693 fields
= type_union_get_cases
(type
);
2695 error_loc_info
(&var
->loc_info
, "undefined type declaration \"union %s\"\n", type
->name
);
2698 if
(fields
) LIST_FOR_EACH_ENTRY
( field
, fields
, const var_t
, entry
)
2699 if
(field
->declspec.type
) check_field_common
(type
, type
->name
, field
);
2702 /* checks that arguments for a function make sense for marshalling and unmarshalling */
2703 static void check_remoting_args
(const var_t
*func
)
2705 const char *funcname
= func
->name
;
2708 if
(!type_function_get_args
(func
->declspec.type
))
2711 LIST_FOR_EACH_ENTRY
( arg
, type_function_get_args
(func
->declspec.type
), const var_t
, entry
)
2713 const type_t
*type
= arg
->declspec.type
;
2715 /* check that [out] parameters have enough pointer levels */
2716 if
(is_attr
(arg
->attrs
, ATTR_OUT
))
2718 switch
(typegen_detect_type
(type
, arg
->attrs
, TDT_ALL_TYPES
))
2725 case TGT_CTXT_HANDLE
:
2727 error_loc_info
(&arg
->loc_info
, "out parameter \'%s\' of function \'%s\' is not a pointer\n", arg
->name
, funcname
);
2729 case TGT_IFACE_POINTER
:
2730 error_loc_info
(&arg
->loc_info
, "out interface pointer \'%s\' of function \'%s\' is not a double pointer\n", arg
->name
, funcname
);
2735 /* needs conformance or fixed dimension */
2736 if
(type_array_has_conformance
(type
) &&
2737 type_array_get_conformance
(type
)->type
!= EXPR_VOID
) break
;
2738 if
(!type_array_has_conformance
(type
) && type_array_get_dim
(type
)) break
;
2740 if
(is_attr
( arg
->attrs
, ATTR_IN
)) break
;
2741 error_loc_info
(&arg
->loc_info
, "out parameter \'%s\' of function \'%s\' cannot be an unsized string\n", arg
->name
, funcname
);
2744 /* already error'd before we get here */
2745 case TGT_CTXT_HANDLE_POINTER
:
2753 check_field_common
(func
->declspec.type
, funcname
, arg
);
2756 if
(type_get_type
(type_function_get_rettype
(func
->declspec.type
)) != TYPE_VOID
)
2760 var.declspec.type
= type_function_get_rettype
(func
->declspec.type
);
2761 var.name
= xstrdup
("return value");
2762 check_field_common
(func
->declspec.type
, funcname
, &var
);
2767 static void add_explicit_handle_if_necessary
(const type_t
*iface
, var_t
*func
)
2769 unsigned char explicit_fc
, implicit_fc
;
2771 /* check for a defined binding handle */
2772 if
(!get_func_handle_var
( iface
, func
, &explicit_fc
, &implicit_fc
) ||
!explicit_fc
)
2774 /* no explicit handle specified so add
2775 * "[in] handle_t IDL_handle" as the first parameter to the
2777 var_t
*idl_handle
= make_var
(xstrdup
("IDL_handle"));
2778 idl_handle
->attrs
= append_attr
(NULL
, make_attr
(ATTR_IN
));
2779 idl_handle
->declspec.type
= find_type_or_error
("handle_t", 0);
2780 type_function_add_head_arg
(func
->declspec.type
, idl_handle
);
2784 static void check_functions
(const type_t
*iface
, int is_inside_library
)
2786 const statement_t
*stmt
;
2787 /* check for duplicates */
2788 if
(is_attr
(iface
->attrs
, ATTR_DISPINTERFACE
))
2790 var_list_t
*methods
= type_dispiface_get_methods
(iface
);
2791 var_t
*func
, *func_iter
;
2793 if
(methods
) LIST_FOR_EACH_ENTRY
( func
, methods
, var_t
, entry
)
2795 LIST_FOR_EACH_ENTRY
( func_iter
, methods
, var_t
, entry
)
2797 if
(func
== func_iter
) break
;
2798 if
(strcmp
(func
->name
, func_iter
->name
)) continue
;
2799 if
(is_attr
(func
->attrs
, ATTR_PROPGET
) != is_attr
(func_iter
->attrs
, ATTR_PROPGET
)) continue
;
2800 if
(is_attr
(func
->attrs
, ATTR_PROPPUT
) != is_attr
(func_iter
->attrs
, ATTR_PROPPUT
)) continue
;
2801 if
(is_attr
(func
->attrs
, ATTR_PROPPUTREF
) != is_attr
(func_iter
->attrs
, ATTR_PROPPUTREF
)) continue
;
2802 error_loc_info
(&func
->loc_info
, "duplicated function \'%s\'\n", func
->name
);
2806 if
(is_attr
(iface
->attrs
, ATTR_EXPLICIT_HANDLE
))
2808 STATEMENTS_FOR_EACH_FUNC
( stmt
, type_iface_get_stmts
(iface
) )
2810 var_t
*func
= stmt
->u.var
;
2811 add_explicit_handle_if_necessary
(iface
, func
);
2814 if
(!is_inside_library
&& !is_attr
(iface
->attrs
, ATTR_LOCAL
))
2816 STATEMENTS_FOR_EACH_FUNC
( stmt
, type_iface_get_stmts
(iface
) )
2818 const var_t
*func
= stmt
->u.var
;
2819 if
(!is_attr
(func
->attrs
, ATTR_LOCAL
))
2820 check_remoting_args
(func
);
2825 static int async_iface_attrs
(attr_list_t
*attrs
, const attr_t
*attr
)
2831 case ATTR_ASYNCUUID
:
2832 append_attr
(attrs
, make_attrp
(ATTR_UUID
, attr
->u.pval
));
2839 static int arg_in_attrs
(attr_list_t
*attrs
, const attr_t
*attr
)
2841 return attr
->type
!= ATTR_OUT
&& attr
->type
!= ATTR_RETVAL
;
2844 static int arg_out_attrs
(attr_list_t
*attrs
, const attr_t
*attr
)
2846 return attr
->type
!= ATTR_IN
;
2849 static void check_async_uuid
(type_t
*iface
)
2851 statement_list_t
*stmts
= NULL
;
2853 type_t
*async_iface
;
2856 if
(!is_attr
(iface
->attrs
, ATTR_ASYNCUUID
)) return
;
2858 inherit
= type_iface_get_inherit
(iface
);
2859 if
(inherit
&& strcmp
(inherit
->name
, "IUnknown"))
2860 inherit
= type_iface_get_async_iface
(inherit
);
2862 error_loc
("async_uuid applied to an interface with incompatible parent\n");
2864 async_iface
= get_type
(TYPE_INTERFACE
, strmake
("Async%s", iface
->name
), iface
->namespace
, 0);
2865 async_iface
->attrs
= map_attrs
(iface
->attrs
, async_iface_attrs
);
2867 STATEMENTS_FOR_EACH_FUNC
( stmt
, type_iface_get_stmts
(iface
) )
2869 var_t
*begin_func
, *finish_func
, *func
= stmt
->u.var
, *arg
;
2870 var_list_t
*begin_args
= NULL
, *finish_args
= NULL
, *args
;
2872 args
= type_function_get_args
(func
->declspec.type
);
2873 if
(args
) LIST_FOR_EACH_ENTRY
(arg
, args
, var_t
, entry
)
2875 if
(is_attr
(arg
->attrs
, ATTR_IN
) ||
!is_attr
(arg
->attrs
, ATTR_OUT
))
2876 begin_args
= append_var
(begin_args
, copy_var
(arg
, strdup
(arg
->name
), arg_in_attrs
));
2877 if
(is_attr
(arg
->attrs
, ATTR_OUT
))
2878 finish_args
= append_var
(finish_args
, copy_var
(arg
, strdup
(arg
->name
), arg_out_attrs
));
2881 begin_func
= copy_var
(func
, strmake
("Begin_%s", func
->name
), NULL
);
2882 begin_func
->declspec.type
= type_new_function
(begin_args
);
2883 begin_func
->declspec.type
->attrs
= func
->attrs
;
2884 begin_func
->declspec.type
->details.function
->retval
= func
->declspec.type
->details.function
->retval
;
2885 stmts
= append_statement
(stmts
, make_statement_declaration
(begin_func
));
2887 finish_func
= copy_var
(func
, strmake
("Finish_%s", func
->name
), NULL
);
2888 finish_func
->declspec.type
= type_new_function
(finish_args
);
2889 finish_func
->declspec.type
->attrs
= func
->attrs
;
2890 finish_func
->declspec.type
->details.function
->retval
= func
->declspec.type
->details.function
->retval
;
2891 stmts
= append_statement
(stmts
, make_statement_declaration
(finish_func
));
2894 type_interface_define
(async_iface
, inherit
, stmts
);
2895 iface
->details.iface
->async_iface
= async_iface
->details.iface
->async_iface
= async_iface
;
2898 static void check_statements
(const statement_list_t
*stmts
, int is_inside_library
)
2900 const statement_t
*stmt
;
2902 if
(stmts
) LIST_FOR_EACH_ENTRY
(stmt
, stmts
, const statement_t
, entry
)
2904 switch
(stmt
->type
) {
2906 check_statements
(stmt
->u.lib
->stmts
, TRUE
);
2909 switch
(type_get_type
(stmt
->u.type
)) {
2910 case TYPE_INTERFACE
:
2911 check_functions
(stmt
->u.type
, is_inside_library
);
2915 error_loc
("coclass is not allowed in Windows Runtime mode\n");
2927 static void check_all_user_types
(const statement_list_t
*stmts
)
2929 const statement_t
*stmt
;
2932 if
(stmts
) LIST_FOR_EACH_ENTRY
(stmt
, stmts
, const statement_t
, entry
)
2934 if
(stmt
->type
== STMT_LIBRARY
)
2935 check_all_user_types
(stmt
->u.lib
->stmts
);
2936 else if
(stmt
->type
== STMT_TYPE
&& type_get_type
(stmt
->u.type
) == TYPE_INTERFACE
&&
2937 !is_local
(stmt
->u.type
->attrs
))
2939 const statement_t
*stmt_func
;
2940 STATEMENTS_FOR_EACH_FUNC
(stmt_func
, type_iface_get_stmts
(stmt
->u.type
)) {
2941 const var_t
*func
= stmt_func
->u.var
;
2942 if
(type_function_get_args
(func
->declspec.type
))
2943 LIST_FOR_EACH_ENTRY
( v
, type_function_get_args
(func
->declspec.type
), const var_t
, entry
)
2944 check_for_additional_prototype_types
(v
->declspec.type
);
2945 check_for_additional_prototype_types
(type_function_get_rettype
(func
->declspec.type
));
2951 int is_valid_uuid
(const char *s
)
2955 for
(i
= 0; i
< 36; ++i
)
2956 if
(i
== 8 || i
== 13 || i
== 18 || i
== 23)
2962 if
(!isxdigit
(s
[i
]))
2965 return s
[i
] == '\0';
2968 static statement_t
*make_statement
(enum statement_type type
)
2970 statement_t
*stmt
= xmalloc
(sizeof
(*stmt
));
2975 static statement_t
*make_statement_type_decl
(type_t
*type
)
2977 statement_t
*stmt
= make_statement
(STMT_TYPE
);
2978 stmt
->u.type
= type
;
2979 stmt
->declonly
= !type
->defined
;
2983 static statement_t
*make_statement_reference
(type_t
*type
)
2985 statement_t
*stmt
= make_statement
(STMT_TYPEREF
);
2986 stmt
->u.type
= type
;
2990 static statement_t
*make_statement_declaration
(var_t
*var
)
2992 statement_t
*stmt
= make_statement
(STMT_DECLARATION
);
2994 if
(var
->declspec.stgclass
== STG_EXTERN
&& var
->eval
)
2995 warning
("'%s' initialised and declared extern\n", var
->name
);
2996 if
(is_const_decl
(var
))
3001 else if
(type_get_type
(var
->declspec.type
) == TYPE_FUNCTION
)
3002 check_function_attrs
(var
->name
, var
->attrs
);
3003 else if
(var
->declspec.stgclass
== STG_NONE || var
->declspec.stgclass
== STG_REGISTER
)
3004 error_loc
("instantiation of data is illegal\n");
3008 static statement_t
*make_statement_library
(typelib_t
*typelib
)
3010 statement_t
*stmt
= make_statement
(STMT_LIBRARY
);
3011 stmt
->u.lib
= typelib
;
3015 static statement_t
*make_statement_pragma
(const char *str
)
3017 statement_t
*stmt
= make_statement
(STMT_PRAGMA
);
3022 static statement_t
*make_statement_cppquote
(const char *str
)
3024 statement_t
*stmt
= make_statement
(STMT_CPPQUOTE
);
3029 static statement_t
*make_statement_importlib
(const char *str
)
3031 statement_t
*stmt
= make_statement
(STMT_IMPORTLIB
);
3036 static statement_t
*make_statement_import
(const char *str
)
3038 statement_t
*stmt
= make_statement
(STMT_IMPORT
);
3043 static statement_t
*make_statement_module
(type_t
*type
)
3045 statement_t
*stmt
= make_statement
(STMT_MODULE
);
3046 stmt
->u.type
= type
;
3050 static statement_t
*make_statement_typedef
(declarator_list_t
*decls
, int declonly
)
3052 declarator_t
*decl
, *next
;
3054 type_list_t
**type_list
;
3056 if
(!decls
) return NULL
;
3058 stmt
= make_statement
(STMT_TYPEDEF
);
3059 stmt
->u.type_list
= NULL
;
3060 type_list
= &stmt
->u.type_list
;
3061 stmt
->declonly
= declonly
;
3063 LIST_FOR_EACH_ENTRY_SAFE
( decl
, next
, decls
, declarator_t
, entry
)
3065 var_t
*var
= decl
->var
;
3066 type_t
*type
= find_type_or_error
(var
->name
, 0);
3067 *type_list
= xmalloc
(sizeof
(type_list_t
));
3068 (*type_list
)->type
= type
;
3069 (*type_list
)->next
= NULL
;
3071 type_list
= &(*type_list
)->next
;
3079 static statement_list_t
*append_statements
(statement_list_t
*l1
, statement_list_t
*l2
)
3082 if
(!l1 || l1
== l2
) return l2
;
3083 list_move_tail
(l1
, l2
);
3087 static attr_list_t
*append_attribs
(attr_list_t
*l1
, attr_list_t
*l2
)
3090 if
(!l1 || l1
== l2
) return l2
;
3091 list_move_tail
(l1
, l2
);
3095 static statement_list_t
*append_statement
(statement_list_t
*list
, statement_t
*stmt
)
3097 if
(!stmt
) return list
;
3100 list
= xmalloc
( sizeof
(*list
) );
3103 list_add_tail
( list
, &stmt
->entry
);
3107 void init_loc_info
(loc_info_t
*i
)
3109 i
->input_name
= input_name ? input_name
: "stdin";
3110 i
->line_number
= line_number
;
3111 i
->near_text
= parser_text
;
3114 static void check_def
(const type_t
*t
)
3117 error_loc
("%s: redefinition error; original definition was at %s:%d\n",
3118 t
->name
, t
->loc_info.input_name
, t
->loc_info.line_number
);