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
42 /* Berkeley yacc (byacc) doesn't seem to know about these */
43 /* Some *BSD supplied versions do define these though */
45 # define YYEMPTY (-1) /* Empty lookahead value of yychar */
48 # define YYLEX yylex()
51 #elif defined(YYBISON)
52 /* Bison was used for original development */
53 /* #define YYEMPTY -2 */
54 /* #define YYLEX yylex() */
57 /* No yacc we know yet */
58 # if !defined(YYEMPTY) || !defined(YYLEX)
59 # error Yacc version/type unknown. This version needs to be verified for settings of YYEMPTY and YYLEX.
60 # elif defined(__GNUC__) /* gcc defines the #warning directive */
61 # warning Yacc version/type unknown. It defines YYEMPTY and YYLEX, but is not tested
62 /* #else we just take a chance that it works... */
66 #define YYERROR_VERBOSE
68 static unsigned char pointer_default
= RPC_FC_UP
;
69 static int is_object_interface
= FALSE
;
71 typedef
struct list typelist_t
;
83 typedef
struct _decl_spec_t
87 enum storage_class stgclass
;
90 typelist_t incomplete_types
= LIST_INIT
(incomplete_types
);
92 static void fix_incomplete
(void);
93 static void fix_incomplete_types
(type_t
*complete_type
);
95 static str_list_t
*append_str
(str_list_t
*list
, char *str
);
96 static attr_list_t
*append_attr
(attr_list_t
*list
, attr_t
*attr
);
97 static attr_list_t
*append_attr_list
(attr_list_t
*new_list
, attr_list_t
*old_list
);
98 static decl_spec_t
*make_decl_spec
(type_t
*type
, decl_spec_t
*left
, decl_spec_t
*right
, attr_t
*attr
, enum storage_class stgclass
);
99 static attr_t
*make_attr
(enum attr_type type
);
100 static attr_t
*make_attrv
(enum attr_type type
, unsigned long val
);
101 static attr_t
*make_attrp
(enum attr_type type
, void *val
);
102 static expr_list_t
*append_expr
(expr_list_t
*list
, expr_t
*expr
);
103 static array_dims_t
*append_array
(array_dims_t
*list
, expr_t
*expr
);
104 static void set_type
(var_t
*v
, decl_spec_t
*decl_spec
, const declarator_t
*decl
, int top
);
105 static var_list_t
*set_var_types
(attr_list_t
*attrs
, decl_spec_t
*decl_spec
, declarator_list_t
*decls
);
106 static ifref_list_t
*append_ifref
(ifref_list_t
*list
, ifref_t
*iface
);
107 static ifref_t
*make_ifref
(type_t
*iface
);
108 static var_list_t
*append_var_list
(var_list_t
*list
, var_list_t
*vars
);
109 static declarator_list_t
*append_declarator
(declarator_list_t
*list
, declarator_t
*p
);
110 static declarator_t
*make_declarator
(var_t
*var
);
111 static func_list_t
*append_func
(func_list_t
*list
, func_t
*func
);
112 static func_t
*make_func
(var_t
*def
);
113 static type_t
*make_safearray
(type_t
*type
);
114 static typelib_t
*make_library
(const char *name
, const attr_list_t
*attrs
);
115 static type_t
*append_ptrchain_type
(type_t
*ptrchain
, type_t
*type
);
117 static type_t
*reg_typedefs
(decl_spec_t
*decl_spec
, var_list_t
*names
, attr_list_t
*attrs
);
118 static type_t
*find_type_or_error
(const char *name
, int t
);
119 static type_t
*find_type_or_error2
(char *name
, int t
);
121 static var_t
*reg_const
(var_t
*var
);
123 static char *gen_name
(void);
124 static void check_arg
(var_t
*arg
);
125 static void check_statements
(const statement_list_t
*stmts
, int is_inside_library
);
126 static void check_all_user_types
(const statement_list_t
*stmts
);
127 static attr_list_t
*check_iface_attrs
(const char *name
, attr_list_t
*attrs
);
128 static attr_list_t
*check_function_attrs
(const char *name
, attr_list_t
*attrs
);
129 static attr_list_t
*check_typedef_attrs
(attr_list_t
*attrs
);
130 static attr_list_t
*check_enum_attrs
(attr_list_t
*attrs
);
131 static attr_list_t
*check_struct_attrs
(attr_list_t
*attrs
);
132 static attr_list_t
*check_union_attrs
(attr_list_t
*attrs
);
133 static attr_list_t
*check_field_attrs
(const char *name
, attr_list_t
*attrs
);
134 static attr_list_t
*check_library_attrs
(const char *name
, attr_list_t
*attrs
);
135 static attr_list_t
*check_dispiface_attrs
(const char *name
, attr_list_t
*attrs
);
136 static attr_list_t
*check_module_attrs
(const char *name
, attr_list_t
*attrs
);
137 static attr_list_t
*check_coclass_attrs
(const char *name
, attr_list_t
*attrs
);
138 const char *get_attr_display_name
(enum attr_type type
);
139 static void add_explicit_handle_if_necessary
(var_t
*func
);
140 static void check_def
(const type_t
*t
);
142 static statement_t
*make_statement
(enum statement_type type
);
143 static statement_t
*make_statement_type_decl
(type_t
*type
);
144 static statement_t
*make_statement_reference
(type_t
*type
);
145 static statement_t
*make_statement_declaration
(var_t
*var
);
146 static statement_t
*make_statement_library
(typelib_t
*typelib
);
147 static statement_t
*make_statement_cppquote
(const char *str
);
148 static statement_t
*make_statement_importlib
(const char *str
);
149 static statement_t
*make_statement_module
(type_t
*type
);
150 static statement_t
*make_statement_typedef
(var_list_t
*names
);
151 static statement_t
*make_statement_import
(const char *str
);
152 static statement_t
*make_statement_typedef
(var_list_t
*names
);
153 static statement_list_t
*append_statement
(statement_list_t
*list
, statement_t
*stmt
);
158 attr_list_t
*attr_list
;
159 str_list_t
*str_list
;
161 expr_list_t
*expr_list
;
162 array_dims_t
*array_dims
;
165 var_list_t
*var_list
;
166 declarator_t
*declarator
;
167 declarator_list_t
*declarator_list
;
169 func_list_t
*func_list
;
170 statement_t
*statement
;
171 statement_list_t
*stmt_list
;
173 ifref_list_t
*ifref_list
;
178 interface_info_t ifinfo
;
180 struct _import_t
*import
;
181 struct _decl_spec_t
*declspec
;
182 enum storage_class stgclass
;
185 %token
<str
> aIDENTIFIER
186 %token
<str
> aKNOWNTYPE
187 %token
<num
> aNUM aHEXNUM
189 %token
<str
> aSTRING aWSTRING
194 %token EQUALITY INEQUALITY
195 %token GREATEREQUAL LESSEQUAL
196 %token LOGICALOR LOGICALAND
197 %token tAGGREGATABLE tALLOCATE tAPPOBJECT tASYNC tASYNCUUID
198 %token tAUTOHANDLE tBINDABLE tBOOLEAN tBROADCAST tBYTE tBYTECOUNT
199 %token tCALLAS tCALLBACK tCASE tCDECL tCHAR tCOCLASS tCODE tCOMMSTATUS
200 %token tCONST tCONTEXTHANDLE tCONTEXTHANDLENOSERIALIZE
201 %token tCONTEXTHANDLESERIALIZE tCONTROL tCPPQUOTE
203 %token tDEFAULTCOLLELEM
205 %token tDEFAULTVTABLE
207 %token tDISPINTERFACE
208 %token tDLLNAME tDOUBLE tDUAL
210 %token tENTRY tENUM tERRORSTATUST
211 %token tEXPLICITHANDLE tEXTERN
217 %token tHELPCONTEXT tHELPFILE
218 %token tHELPSTRING tHELPSTRINGCONTEXT tHELPSTRINGDLL
220 %token tHYPER tID tIDEMPOTENT
222 %token tIMMEDIATEBIND
223 %token tIMPLICITHANDLE
224 %token tIMPORT tIMPORTLIB
225 %token tIN tIN_LINE tINLINE
230 %token tLENGTHIS tLIBRARY
237 %token tNONEXTENSIBLE
239 %token tOBJECT tODL tOLEAUTOMATION
243 %token tPOINTERDEFAULT
245 %token tPROPGET tPROPPUT tPROPPUTREF
249 %token tREADONLY tREF
257 %token tSIZEIS tSIZEOF
262 %token tSTRICTCONTEXTHANDLE
263 %token tSTRING tSTRUCT
264 %token tSWITCH tSWITCHIS tSWITCHTYPE
276 %token tWCHAR tWIREMARSHAL
278 %type
<attr
> attribute type_qualifier function_specifier
279 %type
<attr_list
> m_attributes attributes attrib_list m_type_qual_list
280 %type
<str_list
> str_list
281 %type
<expr
> m_expr expr expr_const expr_int_const array
282 %type
<expr_list
> m_exprs
/* exprs expr_list */ expr_list_int_const
283 %type
<ifinfo
> interfacehdr
284 %type
<stgclass
> storage_cls_spec
285 %type
<declspec
> decl_spec decl_spec_no_type m_decl_spec_no_type
286 %type
<type
> inherit interface interfacedef interfacedec
287 %type
<type
> dispinterface dispinterfacehdr dispinterfacedef
288 %type
<type
> module modulehdr moduledef
289 %type
<type
> base_type int_std
290 %type
<type
> enumdef structdef uniondef typedecl
292 %type
<ifref
> coclass_int
293 %type
<ifref_list
> coclass_ints
294 %type
<var
> arg ne_union_field union_field s_field case
enum declaration
295 %type
<var_list
> m_args no_args args fields ne_union_fields cases enums enum_list dispint_props field
296 %type
<var
> m_ident ident
297 %type
<declarator
> declarator direct_declarator init_declarator
298 %type
<declarator_list
> declarator_list
300 %type
<type
> coclass coclasshdr coclassdef
301 %type
<num
> pointer_type version
302 %type
<str
> libraryhdr callconv cppquote importlib import t_ident
303 %type
<uuid
> uuid_string
304 %type
<import
> import_start
305 %type
<typelib
> library_start librarydef
306 %type
<statement
> statement typedef
307 %type
<stmt_list
> gbl_statements imp_statements int_statements dispint_meths
316 %left EQUALITY INEQUALITY
317 %left
'<' '>' LESSEQUAL GREATEREQUAL
321 %right
'!' '~' CAST PPTR POS NEG ADDRESSOF tSIZEOF
322 %left
'.' MEMBERPTR
'[' ']'
326 input: gbl_statements
{ fix_incomplete
();
327 check_statements
($1, FALSE
);
328 check_all_user_types
($1);
335 write_local_stubs
($1);
339 gbl_statements: { $$
= NULL
; }
340 | gbl_statements interfacedec
{ $$
= append_statement
($1, make_statement_reference
($2)); }
341 | gbl_statements interfacedef
{ $$
= append_statement
($1, make_statement_type_decl
($2)); }
342 | gbl_statements coclass
';' { $$
= $1;
343 reg_type
($2, $2->name
, 0);
345 | gbl_statements coclassdef
{ $$
= append_statement
($1, make_statement_type_decl
($2));
346 reg_type
($2, $2->name
, 0);
348 | gbl_statements moduledef
{ $$
= append_statement
($1, make_statement_module
($2)); }
349 | gbl_statements librarydef
{ $$
= append_statement
($1, make_statement_library
($2)); }
350 | gbl_statements statement
{ $$
= append_statement
($1, $2); }
353 imp_statements: { $$
= NULL
; }
354 | imp_statements interfacedec
{ $$
= append_statement
($1, make_statement_reference
($2)); }
355 | imp_statements interfacedef
{ $$
= append_statement
($1, make_statement_type_decl
($2)); }
356 | imp_statements coclass
';' { $$
= $1; reg_type
($2, $2->name
, 0); }
357 | imp_statements coclassdef
{ $$
= append_statement
($1, make_statement_type_decl
($2));
358 reg_type
($2, $2->name
, 0);
360 | imp_statements moduledef
{ $$
= append_statement
($1, make_statement_module
($2)); }
361 | imp_statements statement
{ $$
= append_statement
($1, $2); }
362 | imp_statements importlib
{ $$
= append_statement
($1, make_statement_importlib
($2)); }
363 | imp_statements librarydef
{ $$
= append_statement
($1, make_statement_library
($2)); }
366 int_statements: { $$
= NULL
; }
367 | int_statements statement
{ $$
= append_statement
($1, $2); }
375 cppquote
{ $$
= make_statement_cppquote
($1); }
376 | typedecl
';' { $$
= make_statement_type_decl
($1); }
377 | declaration
';' { $$
= make_statement_declaration
($1); }
378 | import
{ $$
= make_statement_import
($1); }
379 | typedef
';' { $$
= $1; }
386 | attributes enumdef
{ $$
= $2; $$
->attrs
= check_enum_attrs
($1); }
387 | attributes structdef
{ $$
= $2; $$
->attrs
= check_struct_attrs
($1); }
388 | attributes uniondef
{ $$
= $2; $$
->attrs
= check_union_attrs
($1); }
391 cppquote: tCPPQUOTE
'(' aSTRING
')' { $$
= $3; }
393 import_start: tIMPORT aSTRING
';' { assert
(yychar == YYEMPTY
);
394 $$
= xmalloc
(sizeof
(struct _import_t
));
396 $$
->import_performed
= do_import
($2);
397 if
(!$$
->import_performed
) yychar = aEOF
;
401 import: import_start imp_statements aEOF
{ $$
= $1->name
;
402 if
($1->import_performed
) pop_import
();
407 importlib: tIMPORTLIB
'(' aSTRING
')'
408 semicolon_opt
{ $$
= $3; if
(!parse_only
) add_importlib
($3); }
411 libraryhdr: tLIBRARY aIDENTIFIER
{ $$
= $2; }
413 library_start: attributes libraryhdr
'{' { $$
= make_library
($2, check_library_attrs
($2, $1));
414 if
(!parse_only
) start_typelib
($$
);
417 librarydef: library_start imp_statements
'}'
418 semicolon_opt
{ $$
= $1;
420 if
(!parse_only
) end_typelib
();
424 m_args: { $$
= NULL
; }
428 no_args: tVOID
{ $$
= NULL
; }
431 args: arg
{ check_arg
($1); $$
= append_var
( NULL
, $1 ); }
432 | args
',' arg
{ check_arg
($3); $$
= append_var
( $1, $3); }
436 /* split into two rules to get bison to resolve a tVOID conflict */
437 arg: attributes decl_spec declarator
{ $$
= $3->var
;
439 if
($2->stgclass
!= STG_NONE
&& $2->stgclass
!= STG_REGISTER
)
440 error_loc
("invalid storage class for function parameter\n");
441 set_type
($$
, $2, $3, TRUE
);
444 | decl_spec declarator
{ $$
= $2->var
;
445 if
($1->stgclass
!= STG_NONE
&& $1->stgclass
!= STG_REGISTER
)
446 error_loc
("invalid storage class for function parameter\n");
447 set_type
($$
, $1, $2, TRUE
);
452 array: '[' m_expr
']' { $$
= $2; }
453 |
'[' '*' ']' { $$
= make_expr
(EXPR_VOID
); }
456 m_attributes: { $$
= NULL
; }
461 '[' attrib_list
']' { $$
= $2; }
464 attrib_list: attribute
{ $$
= append_attr
( NULL
, $1 ); }
465 | attrib_list
',' attribute
{ $$
= append_attr
( $1, $3 ); }
466 | attrib_list
']' '[' attribute
{ $$
= append_attr
( $1, $4 ); }
469 str_list: aSTRING
{ $$
= append_str
( NULL
, $1 ); }
470 | str_list
',' aSTRING
{ $$
= append_str
( $1, $3 ); }
473 attribute: { $$
= NULL
; }
474 | tAGGREGATABLE
{ $$
= make_attr
(ATTR_AGGREGATABLE
); }
475 | tAPPOBJECT
{ $$
= make_attr
(ATTR_APPOBJECT
); }
476 | tASYNC
{ $$
= make_attr
(ATTR_ASYNC
); }
477 | tAUTOHANDLE
{ $$
= make_attr
(ATTR_AUTO_HANDLE
); }
478 | tBINDABLE
{ $$
= make_attr
(ATTR_BINDABLE
); }
479 | tBROADCAST
{ $$
= make_attr
(ATTR_BROADCAST
); }
480 | tCALLAS
'(' ident
')' { $$
= make_attrp
(ATTR_CALLAS
, $3); }
481 | tCASE
'(' expr_list_int_const
')' { $$
= make_attrp
(ATTR_CASE
, $3); }
482 | tCONTEXTHANDLE
{ $$
= make_attrv
(ATTR_CONTEXTHANDLE
, 0); }
483 | tCONTEXTHANDLENOSERIALIZE
{ $$
= make_attrv
(ATTR_CONTEXTHANDLE
, 0); /* RPC_CONTEXT_HANDLE_DONT_SERIALIZE */ }
484 | tCONTEXTHANDLESERIALIZE
{ $$
= make_attrv
(ATTR_CONTEXTHANDLE
, 0); /* RPC_CONTEXT_HANDLE_SERIALIZE */ }
485 | tCONTROL
{ $$
= make_attr
(ATTR_CONTROL
); }
486 | tDEFAULT
{ $$
= make_attr
(ATTR_DEFAULT
); }
487 | tDEFAULTCOLLELEM
{ $$
= make_attr
(ATTR_DEFAULTCOLLELEM
); }
488 | tDEFAULTVALUE
'(' expr_const
')' { $$
= make_attrp
(ATTR_DEFAULTVALUE
, $3); }
489 | tDEFAULTVTABLE
{ $$
= make_attr
(ATTR_DEFAULTVTABLE
); }
490 | tDISPLAYBIND
{ $$
= make_attr
(ATTR_DISPLAYBIND
); }
491 | tDLLNAME
'(' aSTRING
')' { $$
= make_attrp
(ATTR_DLLNAME
, $3); }
492 | tDUAL
{ $$
= make_attr
(ATTR_DUAL
); }
493 | tENDPOINT
'(' str_list
')' { $$
= make_attrp
(ATTR_ENDPOINT
, $3); }
494 | tENTRY
'(' expr_const
')' { $$
= make_attrp
(ATTR_ENTRY
, $3); }
495 | tEXPLICITHANDLE
{ $$
= make_attr
(ATTR_EXPLICIT_HANDLE
); }
496 | tHANDLE
{ $$
= make_attr
(ATTR_HANDLE
); }
497 | tHELPCONTEXT
'(' expr_int_const
')' { $$
= make_attrp
(ATTR_HELPCONTEXT
, $3); }
498 | tHELPFILE
'(' aSTRING
')' { $$
= make_attrp
(ATTR_HELPFILE
, $3); }
499 | tHELPSTRING
'(' aSTRING
')' { $$
= make_attrp
(ATTR_HELPSTRING
, $3); }
500 | tHELPSTRINGCONTEXT
'(' expr_int_const
')' { $$
= make_attrp
(ATTR_HELPSTRINGCONTEXT
, $3); }
501 | tHELPSTRINGDLL
'(' aSTRING
')' { $$
= make_attrp
(ATTR_HELPSTRINGDLL
, $3); }
502 | tHIDDEN
{ $$
= make_attr
(ATTR_HIDDEN
); }
503 | tID
'(' expr_int_const
')' { $$
= make_attrp
(ATTR_ID
, $3); }
504 | tIDEMPOTENT
{ $$
= make_attr
(ATTR_IDEMPOTENT
); }
505 | tIIDIS
'(' expr
')' { $$
= make_attrp
(ATTR_IIDIS
, $3); }
506 | tIMMEDIATEBIND
{ $$
= make_attr
(ATTR_IMMEDIATEBIND
); }
507 | tIMPLICITHANDLE
'(' tHANDLET aIDENTIFIER
')' { $$
= make_attrp
(ATTR_IMPLICIT_HANDLE
, $4); }
508 | tIN
{ $$
= make_attr
(ATTR_IN
); }
509 | tINPUTSYNC
{ $$
= make_attr
(ATTR_INPUTSYNC
); }
510 | tLENGTHIS
'(' m_exprs
')' { $$
= make_attrp
(ATTR_LENGTHIS
, $3); }
511 | tLCID
'(' expr_int_const
')' { $$
= make_attrp
(ATTR_LIBLCID
, $3); }
512 | tLCID
{ $$
= make_attr
(ATTR_PARAMLCID
); }
513 | tLOCAL
{ $$
= make_attr
(ATTR_LOCAL
); }
514 | tNONBROWSABLE
{ $$
= make_attr
(ATTR_NONBROWSABLE
); }
515 | tNONCREATABLE
{ $$
= make_attr
(ATTR_NONCREATABLE
); }
516 | tNONEXTENSIBLE
{ $$
= make_attr
(ATTR_NONEXTENSIBLE
); }
517 | tOBJECT
{ $$
= make_attr
(ATTR_OBJECT
); }
518 | tODL
{ $$
= make_attr
(ATTR_ODL
); }
519 | tOLEAUTOMATION
{ $$
= make_attr
(ATTR_OLEAUTOMATION
); }
520 | tOPTIONAL
{ $$
= make_attr
(ATTR_OPTIONAL
); }
521 | tOUT
{ $$
= make_attr
(ATTR_OUT
); }
522 | tPOINTERDEFAULT
'(' pointer_type
')' { $$
= make_attrv
(ATTR_POINTERDEFAULT
, $3); }
523 | tPROPGET
{ $$
= make_attr
(ATTR_PROPGET
); }
524 | tPROPPUT
{ $$
= make_attr
(ATTR_PROPPUT
); }
525 | tPROPPUTREF
{ $$
= make_attr
(ATTR_PROPPUTREF
); }
526 | tPUBLIC
{ $$
= make_attr
(ATTR_PUBLIC
); }
527 | tRANGE
'(' expr_int_const
',' expr_int_const
')'
528 { expr_list_t
*list
= append_expr
( NULL
, $3 );
529 list
= append_expr
( list
, $5 );
530 $$
= make_attrp
(ATTR_RANGE
, list
); }
531 | tREADONLY
{ $$
= make_attr
(ATTR_READONLY
); }
532 | tREQUESTEDIT
{ $$
= make_attr
(ATTR_REQUESTEDIT
); }
533 | tRESTRICTED
{ $$
= make_attr
(ATTR_RESTRICTED
); }
534 | tRETVAL
{ $$
= make_attr
(ATTR_RETVAL
); }
535 | tSIZEIS
'(' m_exprs
')' { $$
= make_attrp
(ATTR_SIZEIS
, $3); }
536 | tSOURCE
{ $$
= make_attr
(ATTR_SOURCE
); }
537 | tSTRICTCONTEXTHANDLE
{ $$
= make_attr
(ATTR_STRICTCONTEXTHANDLE
); }
538 | tSTRING
{ $$
= make_attr
(ATTR_STRING
); }
539 | tSWITCHIS
'(' expr
')' { $$
= make_attrp
(ATTR_SWITCHIS
, $3); }
540 | tSWITCHTYPE
'(' type
')' { $$
= make_attrp
(ATTR_SWITCHTYPE
, $3); }
541 | tTRANSMITAS
'(' type
')' { $$
= make_attrp
(ATTR_TRANSMITAS
, $3); }
542 | tUUID
'(' uuid_string
')' { $$
= make_attrp
(ATTR_UUID
, $3); }
543 | tV1ENUM
{ $$
= make_attr
(ATTR_V1ENUM
); }
544 | tVARARG
{ $$
= make_attr
(ATTR_VARARG
); }
545 | tVERSION
'(' version
')' { $$
= make_attrv
(ATTR_VERSION
, $3); }
546 | tWIREMARSHAL
'(' type
')' { $$
= make_attrp
(ATTR_WIREMARSHAL
, $3); }
547 | pointer_type
{ $$
= make_attrv
(ATTR_POINTERTYPE
, $1); }
552 | aSTRING
{ if
(!is_valid_uuid
($1))
553 error_loc
("invalid UUID: %s\n", $1);
554 $$
= parse_uuid
($1); }
557 callconv: tCDECL
{ $$
= $
<str
>1; }
558 | tFASTCALL
{ $$
= $
<str
>1; }
559 | tPASCAL
{ $$
= $
<str
>1; }
560 | tSTDCALL
{ $$
= $
<str
>1; }
563 cases: { $$
= NULL
; }
564 | cases case
{ $$
= append_var
( $1, $2 ); }
567 case: tCASE expr_int_const
':' union_field
{ attr_t
*a
= make_attrp
(ATTR_CASE
, append_expr
( NULL
, $2 ));
568 $$
= $4; if
(!$$
) $$
= make_var
(NULL
);
569 $$
->attrs
= append_attr
( $$
->attrs
, a
);
571 | tDEFAULT
':' union_field
{ attr_t
*a
= make_attr
(ATTR_DEFAULT
);
572 $$
= $3; if
(!$$
) $$
= make_var
(NULL
);
573 $$
->attrs
= append_attr
( $$
->attrs
, a
);
577 enums: { $$
= NULL
; }
578 | enum_list
',' { $$
= $1; }
582 enum_list: enum { if
(!$1->eval
)
583 $1->eval
= make_exprl
(EXPR_NUM
, 0 /* default for first enum entry */);
584 $$
= append_var
( NULL
, $1 );
586 | enum_list
',' enum { if
(!$3->eval
)
588 var_t
*last
= LIST_ENTRY
( list_tail
($$
), var_t
, entry
);
589 $3->eval
= make_exprl
(EXPR_NUM
, last
->eval
->cval
+ 1);
591 $$
= append_var
( $1, $3 );
595 enum: ident
'=' expr_int_const
{ $$
= reg_const
($1);
597 $$
->type
= type_new_int
(TYPE_BASIC_INT
, 0);
599 | ident
{ $$
= reg_const
($1);
600 $$
->type
= type_new_int
(TYPE_BASIC_INT
, 0);
604 enumdef: tENUM t_ident
'{' enums
'}' { $$
= type_new_enum
($2, TRUE
, $4); }
607 m_exprs: m_expr
{ $$
= append_expr
( NULL
, $1 ); }
608 | m_exprs
',' m_expr
{ $$
= append_expr
( $1, $3 ); }
612 exprs: { $$ = make_expr(EXPR_VOID); }
617 | expr_list ',' expr { LINK($3, $1); $$ = $3; }
621 m_expr: { $$
= make_expr
(EXPR_VOID
); }
625 expr: aNUM
{ $$
= make_exprl
(EXPR_NUM
, $1); }
626 | aHEXNUM
{ $$
= make_exprl
(EXPR_HEXNUM
, $1); }
627 | aDOUBLE
{ $$
= make_exprd
(EXPR_DOUBLE
, $1); }
628 | tFALSE
{ $$
= make_exprl
(EXPR_TRUEFALSE
, 0); }
629 | tNULL
{ $$
= make_exprl
(EXPR_NUM
, 0); }
630 | tTRUE
{ $$
= make_exprl
(EXPR_TRUEFALSE
, 1); }
631 | aSTRING
{ $$
= make_exprs
(EXPR_STRLIT
, $1); }
632 | aWSTRING
{ $$
= make_exprs
(EXPR_WSTRLIT
, $1); }
633 | aIDENTIFIER
{ $$
= make_exprs
(EXPR_IDENTIFIER
, $1); }
634 | expr
'?' expr
':' expr
{ $$
= make_expr3
(EXPR_COND
, $1, $3, $5); }
635 | expr LOGICALOR expr
{ $$
= make_expr2
(EXPR_LOGOR
, $1, $3); }
636 | expr LOGICALAND expr
{ $$
= make_expr2
(EXPR_LOGAND
, $1, $3); }
637 | expr
'|' expr
{ $$
= make_expr2
(EXPR_OR
, $1, $3); }
638 | expr
'^' expr
{ $$
= make_expr2
(EXPR_XOR
, $1, $3); }
639 | expr
'&' expr
{ $$
= make_expr2
(EXPR_AND
, $1, $3); }
640 | expr EQUALITY expr
{ $$
= make_expr2
(EXPR_EQUALITY
, $1, $3); }
641 | expr INEQUALITY expr
{ $$
= make_expr2
(EXPR_INEQUALITY
, $1, $3); }
642 | expr
'>' expr
{ $$
= make_expr2
(EXPR_GTR
, $1, $3); }
643 | expr
'<' expr
{ $$
= make_expr2
(EXPR_LESS
, $1, $3); }
644 | expr GREATEREQUAL expr
{ $$
= make_expr2
(EXPR_GTREQL
, $1, $3); }
645 | expr LESSEQUAL expr
{ $$
= make_expr2
(EXPR_LESSEQL
, $1, $3); }
646 | expr SHL expr
{ $$
= make_expr2
(EXPR_SHL
, $1, $3); }
647 | expr SHR expr
{ $$
= make_expr2
(EXPR_SHR
, $1, $3); }
648 | expr
'+' expr
{ $$
= make_expr2
(EXPR_ADD
, $1, $3); }
649 | expr
'-' expr
{ $$
= make_expr2
(EXPR_SUB
, $1, $3); }
650 | expr
'%' expr
{ $$
= make_expr2
(EXPR_MOD
, $1, $3); }
651 | expr
'*' expr
{ $$
= make_expr2
(EXPR_MUL
, $1, $3); }
652 | expr
'/' expr
{ $$
= make_expr2
(EXPR_DIV
, $1, $3); }
653 |
'!' expr
{ $$
= make_expr1
(EXPR_LOGNOT
, $2); }
654 |
'~' expr
{ $$
= make_expr1
(EXPR_NOT
, $2); }
655 |
'+' expr %prec POS
{ $$
= make_expr1
(EXPR_POS
, $2); }
656 |
'-' expr %prec NEG
{ $$
= make_expr1
(EXPR_NEG
, $2); }
657 |
'&' expr %prec ADDRESSOF
{ $$
= make_expr1
(EXPR_ADDRESSOF
, $2); }
658 |
'*' expr %prec PPTR
{ $$
= make_expr1
(EXPR_PPTR
, $2); }
659 | expr MEMBERPTR aIDENTIFIER
{ $$
= make_expr2
(EXPR_MEMBER
, make_expr1
(EXPR_PPTR
, $1), make_exprs
(EXPR_IDENTIFIER
, $3)); }
660 | expr
'.' aIDENTIFIER
{ $$
= make_expr2
(EXPR_MEMBER
, $1, make_exprs
(EXPR_IDENTIFIER
, $3)); }
661 |
'(' type
')' expr %prec CAST
{ $$
= make_exprt
(EXPR_CAST
, $2, $4); }
662 | tSIZEOF
'(' type
')' { $$
= make_exprt
(EXPR_SIZEOF
, $3, NULL
); }
663 | expr
'[' expr
']' { $$
= make_expr2
(EXPR_ARRAY
, $1, $3); }
664 |
'(' expr
')' { $$
= $2; }
667 expr_list_int_const: expr_int_const
{ $$
= append_expr
( NULL
, $1 ); }
668 | expr_list_int_const
',' expr_int_const
{ $$
= append_expr
( $1, $3 ); }
671 expr_int_const: expr
{ $$
= $1;
673 error_loc
("expression is not an integer constant\n");
677 expr_const: expr
{ $$
= $1;
678 if
(!$$
->is_const
&& $$
->type
!= EXPR_STRLIT
&& $$
->type
!= EXPR_WSTRLIT
)
679 error_loc
("expression is not constant\n");
683 fields: { $$
= NULL
; }
684 | fields field
{ $$
= append_var_list
($1, $2); }
687 field: m_attributes decl_spec declarator_list
';'
688 { const char *first
= LIST_ENTRY
(list_head
($3), declarator_t
, entry
)->var
->name
;
689 check_field_attrs
(first
, $1);
690 $$
= set_var_types
($1, $2, $3);
692 | m_attributes uniondef
';' { var_t
*v
= make_var
(NULL
);
693 v
->type
= $2; v
->attrs
= $1;
694 $$
= append_var
(NULL
, v
);
699 s_field
';' { $$
= $1; }
700 | attributes
';' { $$
= make_var
(NULL
); $$
->attrs
= $1; }
703 ne_union_fields: { $$
= NULL
; }
704 | ne_union_fields ne_union_field
{ $$
= append_var
( $1, $2 ); }
708 s_field
';' { $$
= $1; }
712 s_field: m_attributes decl_spec declarator
{ $$
= $3->var
;
713 $$
->attrs
= check_field_attrs
($$
->name
, $1);
714 set_type
($$
, $2, $3, FALSE
);
720 m_attributes decl_spec declarator
{ var_t
*v
= $3->var
;
721 v
->attrs
= check_function_attrs
(v
->name
, $1);
722 set_type
(v
, $2, $3, FALSE
);
729 attributes decl_spec init_declarator
732 set_type
($$
, $2, $3, FALSE
);
735 | decl_spec init_declarator
{ $$
= $2->var
;
736 set_type
($$
, $1, $2, FALSE
);
741 m_ident: { $$
= NULL
; }
745 t_ident: { $$
= NULL
; }
746 | aIDENTIFIER
{ $$
= $1; }
747 | aKNOWNTYPE
{ $$
= $1; }
750 ident: aIDENTIFIER
{ $$
= make_var
($1); }
751 /* some "reserved words" used in attributes are also used as field names in some MS IDL files */
752 | aKNOWNTYPE
{ $$
= make_var
($
<str
>1); }
755 base_type: tBYTE
{ $$
= find_type_or_error
($
<str
>1, 0); }
756 | tWCHAR
{ $$
= find_type_or_error
($
<str
>1, 0); }
758 | tSIGNED int_std
{ $$
= type_new_int
(type_basic_get_type
($2), -1); }
759 | tUNSIGNED int_std
{ $$
= type_new_int
(type_basic_get_type
($2), 1); }
760 | tUNSIGNED
{ $$
= type_new_int
(TYPE_BASIC_INT
, 1); }
761 | tFLOAT
{ $$
= find_type_or_error
($
<str
>1, 0); }
762 | tDOUBLE
{ $$
= find_type_or_error
($
<str
>1, 0); }
763 | tBOOLEAN
{ $$
= find_type_or_error
($
<str
>1, 0); }
764 | tERRORSTATUST
{ $$
= find_type_or_error
($
<str
>1, 0); }
765 | tHANDLET
{ $$
= find_type_or_error
($
<str
>1, 0); }
772 int_std: tINT
{ $$
= type_new_int
(TYPE_BASIC_INT
, 0); }
773 | tSHORT m_int
{ $$
= type_new_int
(TYPE_BASIC_INT16
, 0); }
774 | tSMALL
{ $$
= type_new_int
(TYPE_BASIC_INT8
, 0); }
775 | tLONG m_int
{ $$
= type_new_int
(TYPE_BASIC_INT32
, 0); }
776 | tHYPER m_int
{ $$
= type_new_int
(TYPE_BASIC_HYPER
, 0); }
777 | tINT64
{ $$
= type_new_int
(TYPE_BASIC_INT64
, 0); }
778 | tCHAR
{ $$
= type_new_int
(TYPE_BASIC_CHAR
, 0); }
781 coclass: tCOCLASS aIDENTIFIER
{ $$
= type_new_coclass
($2); }
782 | tCOCLASS aKNOWNTYPE
{ $$
= find_type
($2, 0);
783 if
(type_get_type_detect_alias
($$
) != TYPE_COCLASS
)
784 error_loc
("%s was not declared a coclass at %s:%d\n",
785 $2, $$
->loc_info.input_name
,
786 $$
->loc_info.line_number
);
790 coclasshdr: attributes coclass
{ $$
= $2;
792 $$
->attrs
= check_coclass_attrs
($2->name
, $1);
796 coclassdef: coclasshdr
'{' coclass_ints
'}' semicolon_opt
797 { $$
= type_coclass_define
($1, $3); }
800 coclass_ints: { $$
= NULL
; }
801 | coclass_ints coclass_int
{ $$
= append_ifref
( $1, $2 ); }
805 m_attributes interfacedec
{ $$
= make_ifref
($2); $$
->attrs
= $1; }
808 dispinterface: tDISPINTERFACE aIDENTIFIER
{ $$
= get_type
(TYPE_INTERFACE
, $2, 0); }
809 | tDISPINTERFACE aKNOWNTYPE
{ $$
= get_type
(TYPE_INTERFACE
, $2, 0); }
812 dispinterfacehdr: attributes dispinterface
{ attr_t
*attrs
;
813 is_object_interface
= TRUE
;
816 attrs
= make_attr
(ATTR_DISPINTERFACE
);
817 $$
->attrs
= append_attr
( check_dispiface_attrs
($2->name
, $1), attrs
);
822 dispint_props: tPROPERTIES
':' { $$
= NULL
; }
823 | dispint_props s_field
';' { $$
= append_var
( $1, $2 ); }
826 dispint_meths: tMETHODS
':' { $$
= NULL
; }
827 | dispint_meths funcdef
';' { $$
= append_func
( $1, $2 ); }
830 dispinterfacedef: dispinterfacehdr
'{'
834 type_dispinterface_define
($$
, $3, $4);
837 '{' interface
';' '}' { $$
= $1;
838 type_dispinterface_define_from_iface
($$
, $3);
842 inherit: { $$
= NULL
; }
843 |
':' aKNOWNTYPE
{ $$
= find_type_or_error2
($2, 0); }
846 interface: tINTERFACE aIDENTIFIER
{ $$
= get_type
(TYPE_INTERFACE
, $2, 0); }
847 | tINTERFACE aKNOWNTYPE
{ $$
= get_type
(TYPE_INTERFACE
, $2, 0); }
850 interfacehdr: attributes interface
{ $$.interface
= $2;
851 $$.old_pointer_default
= pointer_default
;
852 if
(is_attr
($1, ATTR_POINTERDEFAULT
))
853 pointer_default
= get_attrv
($1, ATTR_POINTERDEFAULT
);
854 is_object_interface
= is_object
($1);
856 $2->attrs
= check_iface_attrs
($2->name
, $1);
861 interfacedef: interfacehdr inherit
862 '{' int_statements
'}' semicolon_opt
{ $$
= $1.interface
;
863 type_interface_define
($$
, $2, $4);
864 pointer_default
= $1.old_pointer_default
;
866 /* MIDL is able to import the definition of a base class from inside the
867 * definition of a derived class, I'll try to support it with this rule */
868 | interfacehdr
':' aIDENTIFIER
869 '{' import int_statements
'}'
870 semicolon_opt
{ $$
= $1.interface
;
871 type_interface_define
($$
, find_type_or_error2
($3, 0), $6);
872 pointer_default
= $1.old_pointer_default
;
874 | dispinterfacedef semicolon_opt
{ $$
= $1; }
878 interface
';' { $$
= $1; }
879 | dispinterface
';' { $$
= $1; }
882 module: tMODULE aIDENTIFIER
{ $$
= type_new_module
($2); }
883 | tMODULE aKNOWNTYPE
{ $$
= type_new_module
($2); }
886 modulehdr: attributes module
{ $$
= $2;
887 $$
->attrs
= check_module_attrs
($2->name
, $1);
891 moduledef: modulehdr
'{' int_statements
'}'
892 semicolon_opt
{ $$
= $1;
893 type_module_define
($$
, $3);
898 tEXTERN
{ $$
= STG_EXTERN
; }
899 | tSTATIC
{ $$
= STG_STATIC
; }
900 | tREGISTER
{ $$
= STG_REGISTER
; }
904 tINLINE
{ $$
= make_attr
(ATTR_INLINE
); }
908 tCONST
{ $$
= make_attr
(ATTR_CONST
); }
911 m_type_qual_list: { $$
= NULL
; }
912 | m_type_qual_list type_qualifier
{ $$
= append_attr
($1, $2); }
915 decl_spec: type m_decl_spec_no_type
{ $$
= make_decl_spec
($1, $2, NULL
, NULL
, STG_NONE
); }
916 | decl_spec_no_type type m_decl_spec_no_type
917 { $$
= make_decl_spec
($2, $1, $3, NULL
, STG_NONE
); }
920 m_decl_spec_no_type: { $$
= NULL
; }
925 type_qualifier m_decl_spec_no_type
{ $$
= make_decl_spec
(NULL
, $2, NULL
, $1, STG_NONE
); }
926 | function_specifier m_decl_spec_no_type
{ $$
= make_decl_spec
(NULL
, $2, NULL
, $1, STG_NONE
); }
927 | storage_cls_spec m_decl_spec_no_type
{ $$
= make_decl_spec
(NULL
, $2, NULL
, NULL
, $1); }
931 '*' m_type_qual_list declarator %prec PPTR
932 { $$
= $3; $$
->type
= append_ptrchain_type
($$
->type
, type_new_pointer
(pointer_default
, NULL
, $2)); }
933 | callconv declarator
{ $$
= $2; $$
->type
->attrs
= append_attr
($$
->type
->attrs
, make_attrp
(ATTR_CALLCONV
, $1)); }
938 ident
{ $$
= make_declarator
($1); }
939 |
'(' declarator
')' { $$
= $2; }
940 | direct_declarator array
{ $$
= $1; $$
->array
= append_array
($$
->array
, $2); }
941 | direct_declarator
'(' m_args
')' { $$
= $1;
942 $$
->func_type
= append_ptrchain_type
($$
->type
, type_new_function
($3));
948 declarator
{ $$
= append_declarator
( NULL
, $1 ); }
949 | declarator_list
',' declarator
{ $$
= append_declarator
( $1, $3 ); }
953 declarator
{ $$
= $1; }
954 | declarator
'=' expr_const
{ $$
= $1; $1->var
->eval
= $3; }
958 tREF
{ $$
= RPC_FC_RP
; }
959 | tUNIQUE
{ $$
= RPC_FC_UP
; }
960 | tPTR
{ $$
= RPC_FC_FP
; }
963 structdef: tSTRUCT t_ident
'{' fields
'}' { $$
= type_new_struct
($2, TRUE
, $4); }
966 type: tVOID
{ $$
= type_new_void
(); }
967 | aKNOWNTYPE
{ $$
= find_type_or_error
($1, 0); }
968 | base_type
{ $$
= $1; }
969 | enumdef
{ $$
= $1; }
970 | tENUM aIDENTIFIER
{ $$
= type_new_enum
($2, FALSE
, NULL
); }
971 | structdef
{ $$
= $1; }
972 | tSTRUCT aIDENTIFIER
{ $$
= type_new_struct
($2, FALSE
, NULL
); }
973 | uniondef
{ $$
= $1; }
974 | tUNION aIDENTIFIER
{ $$
= type_new_nonencapsulated_union
($2, FALSE
, NULL
); }
975 | tSAFEARRAY
'(' type
')' { $$
= make_safearray
($3); }
978 typedef: tTYPEDEF m_attributes decl_spec declarator_list
979 { reg_typedefs
($3, $4, check_typedef_attrs
($2));
980 $$
= make_statement_typedef
($4);
984 uniondef: tUNION t_ident
'{' ne_union_fields
'}'
985 { $$
= type_new_nonencapsulated_union
($2, TRUE
, $4); }
987 tSWITCH
'(' s_field
')'
988 m_ident
'{' cases
'}' { $$
= type_new_encapsulated_union
($2, $5, $7, $9); }
992 aNUM
{ $$
= MAKEVERSION
($1, 0); }
993 | aNUM
'.' aNUM
{ $$
= MAKEVERSION
($1, $3); }
998 static void decl_builtin_basic
(const char *name
, enum type_basic_type type
)
1000 type_t
*t
= type_new_basic
(type
);
1001 reg_type
(t
, name
, 0);
1004 static void decl_builtin_alias
(const char *name
, type_t
*t
)
1006 reg_type
(type_new_alias
(t
, name
), name
, 0);
1009 void init_types
(void)
1011 decl_builtin_basic
("byte", TYPE_BASIC_BYTE
);
1012 decl_builtin_basic
("wchar_t", TYPE_BASIC_WCHAR
);
1013 decl_builtin_basic
("float", TYPE_BASIC_FLOAT
);
1014 decl_builtin_basic
("double", TYPE_BASIC_DOUBLE
);
1015 decl_builtin_basic
("error_status_t", TYPE_BASIC_ERROR_STATUS_T
);
1016 decl_builtin_basic
("handle_t", TYPE_BASIC_HANDLE
);
1017 decl_builtin_alias
("boolean", type_new_basic
(TYPE_BASIC_BYTE
));
1020 static str_list_t
*append_str
(str_list_t
*list
, char *str
)
1022 struct str_list_entry_t
*entry
;
1024 if
(!str
) return list
;
1027 list
= xmalloc
( sizeof
(*list
) );
1030 entry
= xmalloc
( sizeof
(*entry
) );
1032 list_add_tail
( list
, &entry
->entry
);
1036 static attr_list_t
*append_attr
(attr_list_t
*list
, attr_t
*attr
)
1038 attr_t
*attr_existing
;
1039 if
(!attr
) return list
;
1042 list
= xmalloc
( sizeof
(*list
) );
1045 LIST_FOR_EACH_ENTRY
(attr_existing
, list
, attr_t
, entry
)
1046 if
(attr_existing
->type
== attr
->type
)
1048 parser_warning
("duplicate attribute %s\n", get_attr_display_name
(attr
->type
));
1049 /* use the last attribute, like MIDL does */
1050 list_remove
(&attr_existing
->entry
);
1053 list_add_tail
( list
, &attr
->entry
);
1057 static attr_list_t
*move_attr
(attr_list_t
*dst
, attr_list_t
*src
, enum attr_type type
)
1060 if
(!src
) return dst
;
1061 LIST_FOR_EACH_ENTRY
(attr
, src
, attr_t
, entry
)
1062 if
(attr
->type
== type
)
1064 list_remove
(&attr
->entry
);
1065 return append_attr
(dst
, attr
);
1070 static attr_list_t
*append_attr_list
(attr_list_t
*new_list
, attr_list_t
*old_list
)
1074 if
(!old_list
) return new_list
;
1076 while
((entry
= list_head
(old_list
)))
1078 attr_t
*attr
= LIST_ENTRY
(entry
, attr_t
, entry
);
1080 new_list
= append_attr
(new_list
, attr
);
1085 static attr_list_t
*dupattrs
(const attr_list_t
*list
)
1087 attr_list_t
*new_list
;
1090 if
(!list
) return NULL
;
1092 new_list
= xmalloc
( sizeof
(*list
) );
1093 list_init
( new_list
);
1094 LIST_FOR_EACH_ENTRY
(attr
, list
, const attr_t
, entry
)
1096 attr_t
*new_attr
= xmalloc
(sizeof
(*new_attr
));
1098 list_add_tail
(new_list
, &new_attr
->entry
);
1103 static decl_spec_t
*make_decl_spec
(type_t
*type
, decl_spec_t
*left
, decl_spec_t
*right
, attr_t
*attr
, enum storage_class stgclass
)
1105 decl_spec_t
*declspec
= left ? left
: right
;
1108 declspec
= xmalloc
(sizeof
(*declspec
));
1109 declspec
->type
= NULL
;
1110 declspec
->attrs
= NULL
;
1111 declspec
->stgclass
= STG_NONE
;
1113 declspec
->type
= type
;
1114 if
(left
&& declspec
!= left
)
1116 declspec
->attrs
= append_attr_list
(declspec
->attrs
, left
->attrs
);
1117 if
(declspec
->stgclass
== STG_NONE
)
1118 declspec
->stgclass
= left
->stgclass
;
1119 else if
(left
->stgclass
!= STG_NONE
)
1120 error_loc
("only one storage class can be specified\n");
1121 assert
(!left
->type
);
1124 if
(right
&& declspec
!= right
)
1126 declspec
->attrs
= append_attr_list
(declspec
->attrs
, right
->attrs
);
1127 if
(declspec
->stgclass
== STG_NONE
)
1128 declspec
->stgclass
= right
->stgclass
;
1129 else if
(right
->stgclass
!= STG_NONE
)
1130 error_loc
("only one storage class can be specified\n");
1131 assert
(!right
->type
);
1135 declspec
->attrs
= append_attr
(declspec
->attrs
, attr
);
1136 if
(declspec
->stgclass
== STG_NONE
)
1137 declspec
->stgclass
= stgclass
;
1138 else if
(stgclass
!= STG_NONE
)
1139 error_loc
("only one storage class can be specified\n");
1141 /* apply attributes to type */
1142 if
(type
&& declspec
->attrs
)
1145 declspec
->type
= duptype
(type
, 1);
1146 attrs
= dupattrs
(type
->attrs
);
1147 declspec
->type
->attrs
= append_attr_list
(attrs
, declspec
->attrs
);
1148 declspec
->attrs
= NULL
;
1154 static attr_t
*make_attr
(enum attr_type type
)
1156 attr_t
*a
= xmalloc
(sizeof
(attr_t
));
1162 static attr_t
*make_attrv
(enum attr_type type
, unsigned long val
)
1164 attr_t
*a
= xmalloc
(sizeof
(attr_t
));
1170 static attr_t
*make_attrp
(enum attr_type type
, void *val
)
1172 attr_t
*a
= xmalloc
(sizeof
(attr_t
));
1178 static expr_list_t
*append_expr
(expr_list_t
*list
, expr_t
*expr
)
1180 if
(!expr
) return list
;
1183 list
= xmalloc
( sizeof
(*list
) );
1186 list_add_tail
( list
, &expr
->entry
);
1190 static array_dims_t
*append_array
(array_dims_t
*list
, expr_t
*expr
)
1192 if
(!expr
) return list
;
1195 list
= xmalloc
( sizeof
(*list
) );
1198 list_add_tail
( list
, &expr
->entry
);
1202 static struct list type_pool
= LIST_INIT
(type_pool
);
1209 type_t
*alloc_type
(void)
1211 type_pool_node_t
*node
= xmalloc
(sizeof
*node
);
1212 list_add_tail
(&type_pool
, &node
->link
);
1216 void set_all_tfswrite
(int val
)
1218 type_pool_node_t
*node
;
1219 LIST_FOR_EACH_ENTRY
(node
, &type_pool
, type_pool_node_t
, link
)
1220 node
->data.tfswrite
= val
;
1223 void clear_all_offsets
(void)
1225 type_pool_node_t
*node
;
1226 LIST_FOR_EACH_ENTRY
(node
, &type_pool
, type_pool_node_t
, link
)
1227 node
->data.typestring_offset
= node
->data.ptrdesc
= 0;
1230 static void type_function_add_head_arg
(type_t
*type
, var_t
*arg
)
1232 if
(!type
->details.function
->args
)
1234 type
->details.function
->args
= xmalloc
( sizeof
(*type
->details.function
->args
) );
1235 list_init
( type
->details.function
->args
);
1237 list_add_head
( type
->details.function
->args
, &arg
->entry
);
1240 static type_t
*append_ptrchain_type
(type_t
*ptrchain
, type_t
*type
)
1242 type_t
*ptrchain_type
;
1245 for
(ptrchain_type
= ptrchain
; type_pointer_get_ref
(ptrchain_type
); ptrchain_type
= type_pointer_get_ref
(ptrchain_type
))
1247 assert
(ptrchain_type
->type_type
== TYPE_POINTER
);
1248 ptrchain_type
->details.pointer.ref
= type
;
1252 static void set_type
(var_t
*v
, decl_spec_t
*decl_spec
, const declarator_t
*decl
,
1255 expr_list_t
*sizes
= get_attrp
(v
->attrs
, ATTR_SIZEIS
);
1256 expr_list_t
*lengs
= get_attrp
(v
->attrs
, ATTR_LENGTHIS
);
1260 array_dims_t
*arr
= decl ? decl
->array
: NULL
;
1261 type_t
*func_type
= decl ? decl
->func_type
: NULL
;
1262 type_t
*type
= decl_spec
->type
;
1264 if
(is_attr
(type
->attrs
, ATTR_INLINE
))
1267 error_loc
("inline attribute applied to non-function type\n");
1271 /* move inline attribute from return type node to function node */
1272 for
(t
= func_type
; is_ptr
(t
); t
= type_pointer_get_ref
(t
))
1274 t
->attrs
= move_attr
(t
->attrs
, type
->attrs
, ATTR_INLINE
);
1278 /* add type onto the end of the pointers in pident->type */
1279 v
->type
= append_ptrchain_type
(decl ? decl
->type
: NULL
, type
);
1280 v
->stgclass
= decl_spec
->stgclass
;
1282 /* check for pointer attribute being applied to non-pointer, non-array
1286 int ptr_attr
= get_attrv
(v
->attrs
, ATTR_POINTERTYPE
);
1287 const type_t
*ptr
= NULL
;
1288 /* pointer attributes on the left side of the type belong to the function
1289 * pointer, if one is being declared */
1290 type_t
**pt
= func_type ?
&func_type
: &v
->type
;
1291 for
(ptr
= *pt
; ptr
&& !ptr_attr
; )
1293 ptr_attr
= get_attrv
(ptr
->attrs
, ATTR_POINTERTYPE
);
1294 if
(!ptr_attr
&& type_is_alias
(ptr
))
1295 ptr
= type_alias_get_aliasee
(ptr
);
1301 if
(ptr_attr
&& ptr_attr
!= RPC_FC_UP
&&
1302 type_get_type
(type_pointer_get_ref
(ptr
)) == TYPE_INTERFACE
)
1303 warning_loc_info
(&v
->loc_info
,
1304 "%s: pointer attribute applied to interface "
1305 "pointer type has no effect\n", v
->name
);
1306 if
(!ptr_attr
&& top
&& (*pt
)->details.pointer.def_fc
!= RPC_FC_RP
)
1308 /* FIXME: this is a horrible hack to cope with the issue that we
1309 * store an offset to the typeformat string in the type object, but
1310 * two typeformat strings may be written depending on whether the
1311 * pointer is a toplevel parameter or not */
1312 *pt
= duptype
(*pt
, 1);
1316 error_loc
("%s: pointer attribute applied to non-pointer type\n", v
->name
);
1319 if
(is_attr
(v
->attrs
, ATTR_STRING
) && !is_ptr
(v
->type
) && !arr
)
1320 error_loc
("'%s': [string] attribute applied to non-pointer, non-array type\n",
1323 if
(is_attr
(v
->attrs
, ATTR_V1ENUM
))
1325 if
(type_get_type_detect_alias
(v
->type
) != TYPE_ENUM
)
1326 error_loc
("'%s': [v1_enum] attribute applied to non-enum type\n", v
->name
);
1331 if
(arr
) LIST_FOR_EACH_ENTRY_REV
(dim
, arr
, expr_t
, entry
)
1334 error_loc
("%s: only the first array dimension can be unspecified\n", v
->name
);
1339 error_loc
("%s: array dimension must be positive\n", v
->name
);
1341 /* FIXME: should use a type_memsize that allows us to pass in a pointer size */
1344 unsigned int align
= 0;
1345 unsigned int size
= type_memsize
(v
->type
, &align
);
1347 if
(0xffffffffu
/ size
< dim
->cval
)
1348 error_loc
("%s: total array size is too large\n", v
->name
);
1354 *ptype
= type_new_array
(NULL
, *ptype
, FALSE
,
1355 dim
->is_const ? dim
->cval
: 0,
1356 dim
->is_const ? NULL
: dim
, NULL
,
1361 if
(sizes
) LIST_FOR_EACH_ENTRY
(dim
, sizes
, expr_t
, entry
)
1363 if
(dim
->type
!= EXPR_VOID
)
1365 if
(is_array
(*ptype
))
1367 if
(type_array_get_conformance
(*ptype
)->is_const
)
1368 error_loc
("%s: cannot specify size_is for a fixed sized array\n", v
->name
);
1370 *ptype
= type_new_array
((*ptype
)->name
,
1371 type_array_get_element
(*ptype
), FALSE
,
1374 else if
(is_ptr
(*ptype
))
1375 *ptype
= type_new_array
((*ptype
)->name
, type_pointer_get_ref
(*ptype
), TRUE
,
1376 0, dim
, NULL
, pointer_default
);
1378 error_loc
("%s: size_is attribute applied to illegal type\n", v
->name
);
1382 ptype
= &(*ptype
)->details.pointer.ref
;
1383 else if
(is_array
(*ptype
))
1384 ptype
= &(*ptype
)->details.array.elem
;
1386 error_loc
("%s: too many expressions in size_is attribute\n", v
->name
);
1390 if
(lengs
) LIST_FOR_EACH_ENTRY
(dim
, lengs
, expr_t
, entry
)
1392 if
(dim
->type
!= EXPR_VOID
)
1394 if
(is_array
(*ptype
))
1396 *ptype
= type_new_array
((*ptype
)->name
,
1397 type_array_get_element
(*ptype
),
1398 type_array_is_decl_as_ptr
(*ptype
),
1399 type_array_get_dim
(*ptype
),
1400 type_array_get_conformance
(*ptype
),
1401 dim
, type_array_get_ptr_default_fc
(*ptype
));
1404 error_loc
("%s: length_is attribute applied to illegal type\n", v
->name
);
1408 ptype
= &(*ptype
)->details.pointer.ref
;
1409 else if
(is_array
(*ptype
))
1410 ptype
= &(*ptype
)->details.array.elem
;
1412 error_loc
("%s: too many expressions in length_is attribute\n", v
->name
);
1415 /* v->type is currently pointing to the type on the left-side of the
1416 * declaration, so we need to fix this up so that it is the return type of the
1417 * function and make v->type point to the function side of the declaration */
1421 type_t
*return_type
= v
->type
;
1422 v
->type
= func_type
;
1423 for
(ft
= v
->type
; is_ptr
(ft
); ft
= type_pointer_get_ref
(ft
))
1425 assert
(type_get_type_detect_alias
(ft
) == TYPE_FUNCTION
);
1426 ft
->details.function
->rettype
= return_type
;
1427 /* move calling convention attribute, if present, from pointer nodes to
1429 for
(t
= v
->type
; is_ptr
(t
); t
= type_pointer_get_ref
(t
))
1430 ft
->attrs
= move_attr
(ft
->attrs
, t
->attrs
, ATTR_CALLCONV
);
1431 if
(is_object_interface
&& !is_attr
(ft
->attrs
, ATTR_CALLCONV
))
1433 static char *stdmethodcalltype
;
1434 if
(!stdmethodcalltype
) stdmethodcalltype
= strdup
("STDMETHODCALLTYPE");
1435 ft
->attrs
= append_attr
(NULL
, make_attrp
(ATTR_CALLCONV
, stdmethodcalltype
));
1441 for
(t
= v
->type
; is_ptr
(t
); t
= type_pointer_get_ref
(t
))
1442 if
(is_attr
(t
->attrs
, ATTR_CALLCONV
))
1443 error_loc
("calling convention applied to non-function-pointer type\n");
1447 static var_list_t
*set_var_types
(attr_list_t
*attrs
, decl_spec_t
*decl_spec
, declarator_list_t
*decls
)
1449 declarator_t
*decl
, *next
;
1450 var_list_t
*var_list
= NULL
;
1452 LIST_FOR_EACH_ENTRY_SAFE
( decl
, next
, decls
, declarator_t
, entry
)
1454 var_t
*var
= decl
->var
;
1457 set_type
(var
, decl_spec
, decl
, 0);
1458 var_list
= append_var
(var_list
, var
);
1464 static ifref_list_t
*append_ifref
(ifref_list_t
*list
, ifref_t
*iface
)
1466 if
(!iface
) return list
;
1469 list
= xmalloc
( sizeof
(*list
) );
1472 list_add_tail
( list
, &iface
->entry
);
1476 static ifref_t
*make_ifref
(type_t
*iface
)
1478 ifref_t
*l
= xmalloc
(sizeof
(ifref_t
));
1484 var_list_t
*append_var
(var_list_t
*list
, var_t
*var
)
1486 if
(!var
) return list
;
1489 list
= xmalloc
( sizeof
(*list
) );
1492 list_add_tail
( list
, &var
->entry
);
1496 static var_list_t
*append_var_list
(var_list_t
*list
, var_list_t
*vars
)
1498 if
(!vars
) return list
;
1501 list
= xmalloc
( sizeof
(*list
) );
1504 list_move_tail
( list
, vars
);
1508 var_t
*make_var
(char *name
)
1510 var_t
*v
= xmalloc
(sizeof
(var_t
));
1515 v
->stgclass
= STG_NONE
;
1516 init_loc_info
(&v
->loc_info
);
1520 static declarator_list_t
*append_declarator
(declarator_list_t
*list
, declarator_t
*d
)
1522 if
(!d
) return list
;
1524 list
= xmalloc
(sizeof
(*list
));
1527 list_add_tail
(list
, &d
->entry
);
1531 static declarator_t
*make_declarator
(var_t
*var
)
1533 declarator_t
*d
= xmalloc
(sizeof
(*d
));
1536 d
->func_type
= NULL
;
1541 static func_list_t
*append_func
(func_list_t
*list
, func_t
*func
)
1543 if
(!func
) return list
;
1546 list
= xmalloc
( sizeof
(*list
) );
1549 list_add_tail
( list
, &func
->entry
);
1553 static func_t
*make_func
(var_t
*def
)
1555 func_t
*f
= xmalloc
(sizeof
(func_t
));
1560 static type_t
*make_safearray
(type_t
*type
)
1562 return type_new_array
(NULL
, type_new_alias
(type
, "SAFEARRAY"), TRUE
, 0,
1563 NULL
, NULL
, RPC_FC_RP
);
1566 static typelib_t
*make_library
(const char *name
, const attr_list_t
*attrs
)
1568 typelib_t
*typelib
= xmalloc
(sizeof
(*typelib
));
1569 typelib
->name
= xstrdup
(name
);
1570 typelib
->filename
= NULL
;
1571 typelib
->attrs
= attrs
;
1572 list_init
( &typelib
->importlibs
);
1578 static int hash_ident
(const char *name
)
1580 const char *p
= name
;
1582 /* a simple sum hash is probably good enough */
1587 return sum
& (HASHMAX
-1);
1590 /***** type repository *****/
1599 struct rtype
*type_hash
[HASHMAX
];
1601 type_t
*reg_type
(type_t
*type
, const char *name
, int t
)
1606 error_loc
("registering named type without name\n");
1609 hash
= hash_ident
(name
);
1610 nt
= xmalloc
(sizeof
(struct rtype
));
1614 nt
->next
= type_hash
[hash
];
1615 type_hash
[hash
] = nt
;
1616 if
((t
== tsSTRUCT || t
== tsUNION
))
1617 fix_incomplete_types
(type
);
1621 static int is_incomplete
(const type_t
*t
)
1623 return
!t
->defined
&&
1624 (type_get_type_detect_alias
(t
) == TYPE_STRUCT ||
1625 type_get_type_detect_alias
(t
) == TYPE_UNION ||
1626 type_get_type_detect_alias
(t
) == TYPE_ENCAPSULATED_UNION
);
1629 void add_incomplete
(type_t
*t
)
1631 struct typenode
*tn
= xmalloc
(sizeof
*tn
);
1633 list_add_tail
(&incomplete_types
, &tn
->entry
);
1636 static void fix_type
(type_t
*t
)
1638 if
(type_is_alias
(t
) && is_incomplete
(t
)) {
1639 type_t
*ot
= type_alias_get_aliasee
(t
);
1641 if
(type_get_type_detect_alias
(ot
) == TYPE_STRUCT ||
1642 type_get_type_detect_alias
(ot
) == TYPE_UNION ||
1643 type_get_type_detect_alias
(ot
) == TYPE_ENCAPSULATED_UNION
)
1644 t
->details.structure
= ot
->details.structure
;
1645 t
->defined
= ot
->defined
;
1649 static void fix_incomplete
(void)
1651 struct typenode
*tn
, *next
;
1653 LIST_FOR_EACH_ENTRY_SAFE
(tn
, next
, &incomplete_types
, struct typenode
, entry
) {
1655 list_remove
(&tn
->entry
);
1660 static void fix_incomplete_types
(type_t
*complete_type
)
1662 struct typenode
*tn
, *next
;
1664 LIST_FOR_EACH_ENTRY_SAFE
(tn
, next
, &incomplete_types
, struct typenode
, entry
)
1666 if
(type_is_equal
(complete_type
, tn
->type
))
1668 tn
->type
->details.structure
= complete_type
->details.structure
;
1669 list_remove
(&tn
->entry
);
1675 static type_t
*reg_typedefs
(decl_spec_t
*decl_spec
, declarator_list_t
*decls
, attr_list_t
*attrs
)
1677 const declarator_t
*decl
;
1678 int is_str
= is_attr
(attrs
, ATTR_STRING
);
1679 type_t
*type
= decl_spec
->type
;
1683 type_t
*t
= decl_spec
->type
;
1686 t
= type_pointer_get_ref
(t
);
1688 if
(type_get_type
(t
) != TYPE_BASIC
&&
1689 (get_basic_fc
(t
) != RPC_FC_CHAR
&&
1690 get_basic_fc
(t
) != RPC_FC_BYTE
&&
1691 get_basic_fc
(t
) != RPC_FC_WCHAR
))
1693 decl
= LIST_ENTRY
( list_head
( decls
), const declarator_t
, entry
);
1694 error_loc
("'%s': [string] attribute is only valid on 'char', 'byte', or 'wchar_t' pointers and arrays\n",
1699 /* We must generate names for tagless enum, struct or union.
1700 Typedef-ing a tagless enum, struct or union means we want the typedef
1701 to be included in a library hence the public attribute. */
1702 if
((type_get_type_detect_alias
(type
) == TYPE_ENUM ||
1703 type_get_type_detect_alias
(type
) == TYPE_STRUCT ||
1704 type_get_type_detect_alias
(type
) == TYPE_UNION ||
1705 type_get_type_detect_alias
(type
) == TYPE_ENCAPSULATED_UNION
) &&
1706 !type
->name
&& !parse_only
)
1708 if
(! is_attr
(attrs
, ATTR_PUBLIC
))
1709 attrs
= append_attr
( attrs
, make_attr
(ATTR_PUBLIC
) );
1710 type
->name
= gen_name
();
1712 else if
(is_attr
(attrs
, ATTR_UUID
) && !is_attr
(attrs
, ATTR_PUBLIC
))
1713 attrs
= append_attr
( attrs
, make_attr
(ATTR_PUBLIC
) );
1715 LIST_FOR_EACH_ENTRY
( decl
, decls
, const declarator_t
, entry
)
1717 var_t
*name
= decl
->var
;
1722 cur
= find_type
(name
->name
, 0);
1724 error_loc
("%s: redefinition error; original definition was at %s:%d\n",
1725 cur
->name
, cur
->loc_info.input_name
,
1726 cur
->loc_info.line_number
);
1728 /* set the attributes to allow set_type to do some checks on them */
1729 name
->attrs
= attrs
;
1730 set_type
(name
, decl_spec
, decl
, 0);
1731 cur
= type_new_alias
(name
->type
, name
->name
);
1734 if
(is_incomplete
(cur
))
1735 add_incomplete
(cur
);
1736 reg_type
(cur
, cur
->name
, 0);
1742 type_t
*find_type
(const char *name
, int t
)
1744 struct rtype
*cur
= type_hash
[hash_ident
(name
)];
1745 while
(cur
&& (cur
->t
!= t || strcmp
(cur
->name
, name
)))
1747 return cur ? cur
->type
: NULL
;
1750 static type_t
*find_type_or_error
(const char *name
, int t
)
1752 type_t
*type
= find_type
(name
, t
);
1754 error_loc
("type '%s' not found\n", name
);
1760 static type_t
*find_type_or_error2
(char *name
, int t
)
1762 type_t
*tp
= find_type_or_error
(name
, t
);
1767 int is_type
(const char *name
)
1769 return find_type
(name
, 0) != NULL
;
1772 type_t
*get_type
(enum type_type type
, char *name
, int t
)
1776 tp
= find_type
(name
, t
);
1782 tp
= make_type
(type
);
1784 if
(!name
) return tp
;
1785 return reg_type
(tp
, name
, t
);
1788 /***** constant repository *****/
1793 struct rconst
*next
;
1796 struct rconst
*const_hash
[HASHMAX
];
1798 static var_t
*reg_const
(var_t
*var
)
1803 error_loc
("registering constant without name\n");
1806 hash
= hash_ident
(var
->name
);
1807 nc
= xmalloc
(sizeof
(struct rconst
));
1808 nc
->name
= var
->name
;
1810 nc
->next
= const_hash
[hash
];
1811 const_hash
[hash
] = nc
;
1815 var_t
*find_const
(const char *name
, int f
)
1817 struct rconst
*cur
= const_hash
[hash_ident
(name
)];
1818 while
(cur
&& strcmp
(cur
->name
, name
))
1821 if
(f
) error_loc
("constant '%s' not found\n", name
);
1827 static char *gen_name
(void)
1829 static const char format
[] = "__WIDL_%s_generated_name_%08lX";
1830 static unsigned long n
= 0;
1831 static const char *file_id
;
1837 char *dst
= dup_basename
(input_name
, ".idl");
1841 if
(! isalnum
((unsigned char) *dst
))
1844 size
= sizeof format
- 7 + strlen
(file_id
) + 8;
1847 name
= xmalloc
(size
);
1848 sprintf
(name
, format
, file_id
, n
++);
1854 unsigned int dce_compatible
: 1;
1855 unsigned int acf
: 1;
1856 unsigned int on_interface
: 1;
1857 unsigned int on_function
: 1;
1858 unsigned int on_arg
: 1;
1859 unsigned int on_type
: 1;
1860 unsigned int on_enum
: 1;
1861 unsigned int on_struct
: 1;
1862 unsigned int on_union
: 1;
1863 unsigned int on_field
: 1;
1864 unsigned int on_library
: 1;
1865 unsigned int on_dispinterface
: 1;
1866 unsigned int on_module
: 1;
1867 unsigned int on_coclass
: 1;
1868 const char *display_name
;
1871 struct allowed_attr allowed_attr
[] =
1873 /* attr { D ACF I Fn ARG T En St Un Fi L DI M C <display name> } */
1874 /* ATTR_AGGREGATABLE */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "aggregatable" },
1875 /* ATTR_APPOBJECT */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "appobject" },
1876 /* ATTR_ASYNC */ { 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "async" },
1877 /* ATTR_AUTO_HANDLE */ { 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "auto_handle" },
1878 /* ATTR_BINDABLE */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "bindable" },
1879 /* ATTR_BROADCAST */ { 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "broadcast" },
1880 /* ATTR_CALLAS */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "call_as" },
1881 /* ATTR_CALLCONV */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL
},
1882 /* ATTR_CASE */ { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, "case" },
1883 /* ATTR_CONST */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "const" },
1884 /* ATTR_CONTEXTHANDLE */ { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "context_handle" },
1885 /* ATTR_CONTROL */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, "control" },
1886 /* ATTR_DEFAULT */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, "default" },
1887 /* ATTR_DEFAULTCOLLELEM */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "defaultcollelem" },
1888 /* ATTR_DEFAULTVALUE */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "defaultvalue" },
1889 /* ATTR_DEFAULTVTABLE */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "defaultvtable" },
1890 /* ATTR_DISPINTERFACE */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL
},
1891 /* ATTR_DISPLAYBIND */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "displaybind" },
1892 /* ATTR_DLLNAME */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, "dllname" },
1893 /* ATTR_DUAL */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "dual" },
1894 /* ATTR_ENDPOINT */ { 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "endpoint" },
1895 /* ATTR_ENTRY */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "entry" },
1896 /* ATTR_EXPLICIT_HANDLE */ { 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "explicit_handle" },
1897 /* ATTR_HANDLE */ { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "handle" },
1898 /* ATTR_HELPCONTEXT */ { 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, "helpcontext" },
1899 /* ATTR_HELPFILE */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, "helpfile" },
1900 /* ATTR_HELPSTRING */ { 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, "helpstring" },
1901 /* ATTR_HELPSTRINGCONTEXT */ { 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, "helpstringcontext" },
1902 /* ATTR_HELPSTRINGDLL */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, "helpstringdll" },
1903 /* ATTR_HIDDEN */ { 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, "hidden" },
1904 /* ATTR_ID */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, "id" },
1905 /* ATTR_IDEMPOTENT */ { 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "idempotent" },
1906 /* ATTR_IIDIS */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, "iid_is" },
1907 /* ATTR_IMMEDIATEBIND */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "immediatebind" },
1908 /* ATTR_IMPLICIT_HANDLE */ { 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "implicit_handle" },
1909 /* ATTR_IN */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "in" },
1910 /* ATTR_INLINE */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "inline" },
1911 /* ATTR_INPUTSYNC */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "inputsync" },
1912 /* ATTR_LENGTHIS */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, "length_is" },
1913 /* ATTR_LIBLCID */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, "lcid" },
1914 /* ATTR_LOCAL */ { 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "local" },
1915 /* ATTR_NONBROWSABLE */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "nonbrowsable" },
1916 /* ATTR_NONCREATABLE */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "noncreatable" },
1917 /* ATTR_NONEXTENSIBLE */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "nonextensible" },
1918 /* ATTR_OBJECT */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "object" },
1919 /* ATTR_ODL */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, "odl" },
1920 /* ATTR_OLEAUTOMATION */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "oleautomation" },
1921 /* ATTR_OPTIONAL */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "optional" },
1922 /* ATTR_OUT */ { 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "out" },
1923 /* ATTR_PARAMLCID */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "lcid" },
1924 /* ATTR_POINTERDEFAULT */ { 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "pointer_default" },
1925 /* ATTR_POINTERTYPE */ { 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, "ref, unique or ptr" },
1926 /* ATTR_PROPGET */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "propget" },
1927 /* ATTR_PROPPUT */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "propput" },
1928 /* ATTR_PROPPUTREF */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "propputref" },
1929 /* ATTR_PUBLIC */ { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "public" },
1930 /* ATTR_RANGE */ { 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, "range" },
1931 /* ATTR_READONLY */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, "readonly" },
1932 /* ATTR_REQUESTEDIT */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "requestedit" },
1933 /* ATTR_RESTRICTED */ { 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, "restricted" },
1934 /* ATTR_RETVAL */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, "retval" },
1935 /* ATTR_SIZEIS */ { 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, "size_is" },
1936 /* ATTR_SOURCE */ { 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, "source" },
1937 /* ATTR_STRICTCONTEXTHANDLE */ { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "strict_context_handle" },
1938 /* ATTR_STRING */ { 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, "string" },
1939 /* ATTR_SWITCHIS */ { 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, "switch_is" },
1940 /* ATTR_SWITCHTYPE */ { 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, "switch_type" },
1941 /* ATTR_TRANSMITAS */ { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "transmit_as" },
1942 /* ATTR_UUID */ { 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, "uuid" },
1943 /* ATTR_V1ENUM */ { 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, "v1_enum" },
1944 /* ATTR_VARARG */ { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "vararg" },
1945 /* ATTR_VERSION */ { 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, "version" },
1946 /* ATTR_WIREMARSHAL */ { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, "wire_marshal" },
1949 const char *get_attr_display_name
(enum attr_type type
)
1951 return allowed_attr
[type
].display_name
;
1954 static attr_list_t
*check_iface_attrs
(const char *name
, attr_list_t
*attrs
)
1957 if
(!attrs
) return attrs
;
1958 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
1960 if
(!allowed_attr
[attr
->type
].on_interface
)
1961 error_loc
("inapplicable attribute %s for interface %s\n",
1962 allowed_attr
[attr
->type
].display_name
, name
);
1967 static attr_list_t
*check_function_attrs
(const char *name
, attr_list_t
*attrs
)
1970 if
(!attrs
) return attrs
;
1971 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
1973 if
(!allowed_attr
[attr
->type
].on_function
)
1974 error_loc
("inapplicable attribute %s for function %s\n",
1975 allowed_attr
[attr
->type
].display_name
, name
);
1980 static void check_arg
(var_t
*arg
)
1982 const type_t
*t
= arg
->type
;
1985 if
(type_get_type
(t
) == TYPE_VOID
)
1986 error_loc
("argument '%s' has void type\n", arg
->name
);
1990 LIST_FOR_EACH_ENTRY
(attr
, arg
->attrs
, const attr_t
, entry
)
1992 if
(!allowed_attr
[attr
->type
].on_arg
)
1993 error_loc
("inapplicable attribute %s for argument %s\n",
1994 allowed_attr
[attr
->type
].display_name
, arg
->name
);
1999 static attr_list_t
*check_typedef_attrs
(attr_list_t
*attrs
)
2002 if
(!attrs
) return attrs
;
2003 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2005 if
(!allowed_attr
[attr
->type
].on_type
)
2006 error_loc
("inapplicable attribute %s for typedef\n",
2007 allowed_attr
[attr
->type
].display_name
);
2012 static attr_list_t
*check_enum_attrs
(attr_list_t
*attrs
)
2015 if
(!attrs
) return attrs
;
2016 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2018 if
(!allowed_attr
[attr
->type
].on_enum
)
2019 error_loc
("inapplicable attribute %s for enum\n",
2020 allowed_attr
[attr
->type
].display_name
);
2025 static attr_list_t
*check_struct_attrs
(attr_list_t
*attrs
)
2028 if
(!attrs
) return attrs
;
2029 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2031 if
(!allowed_attr
[attr
->type
].on_struct
)
2032 error_loc
("inapplicable attribute %s for struct\n",
2033 allowed_attr
[attr
->type
].display_name
);
2038 static attr_list_t
*check_union_attrs
(attr_list_t
*attrs
)
2041 if
(!attrs
) return attrs
;
2042 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2044 if
(!allowed_attr
[attr
->type
].on_union
)
2045 error_loc
("inapplicable attribute %s for union\n",
2046 allowed_attr
[attr
->type
].display_name
);
2051 static attr_list_t
*check_field_attrs
(const char *name
, attr_list_t
*attrs
)
2054 if
(!attrs
) return attrs
;
2055 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2057 if
(!allowed_attr
[attr
->type
].on_field
)
2058 error_loc
("inapplicable attribute %s for field %s\n",
2059 allowed_attr
[attr
->type
].display_name
, name
);
2064 static attr_list_t
*check_library_attrs
(const char *name
, attr_list_t
*attrs
)
2067 if
(!attrs
) return attrs
;
2068 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2070 if
(!allowed_attr
[attr
->type
].on_library
)
2071 error_loc
("inapplicable attribute %s for library %s\n",
2072 allowed_attr
[attr
->type
].display_name
, name
);
2077 static attr_list_t
*check_dispiface_attrs
(const char *name
, attr_list_t
*attrs
)
2080 if
(!attrs
) return attrs
;
2081 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2083 if
(!allowed_attr
[attr
->type
].on_dispinterface
)
2084 error_loc
("inapplicable attribute %s for dispinterface %s\n",
2085 allowed_attr
[attr
->type
].display_name
, name
);
2090 static attr_list_t
*check_module_attrs
(const char *name
, attr_list_t
*attrs
)
2093 if
(!attrs
) return attrs
;
2094 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2096 if
(!allowed_attr
[attr
->type
].on_module
)
2097 error_loc
("inapplicable attribute %s for module %s\n",
2098 allowed_attr
[attr
->type
].display_name
, name
);
2103 static attr_list_t
*check_coclass_attrs
(const char *name
, attr_list_t
*attrs
)
2106 if
(!attrs
) return attrs
;
2107 LIST_FOR_EACH_ENTRY
(attr
, attrs
, const attr_t
, entry
)
2109 if
(!allowed_attr
[attr
->type
].on_coclass
)
2110 error_loc
("inapplicable attribute %s for coclass %s\n",
2111 allowed_attr
[attr
->type
].display_name
, name
);
2116 static int is_allowed_conf_type
(const type_t
*type
)
2118 switch
(type_get_type
(type
))
2123 switch
(type_basic_get_type
(type
))
2125 case TYPE_BASIC_INT8
:
2126 case TYPE_BASIC_INT16
:
2127 case TYPE_BASIC_INT32
:
2128 case TYPE_BASIC_INT64
:
2129 case TYPE_BASIC_INT
:
2130 case TYPE_BASIC_CHAR
:
2131 case TYPE_BASIC_HYPER
:
2132 case TYPE_BASIC_BYTE
:
2133 case TYPE_BASIC_WCHAR
:
2134 case TYPE_BASIC_ERROR_STATUS_T
:
2140 /* shouldn't get here because of type_get_type call above */
2145 case TYPE_ENCAPSULATED_UNION
:
2152 case TYPE_INTERFACE
:
2158 static int is_ptr_guid_type
(const type_t
*type
)
2160 unsigned int align
= 0;
2162 /* first, make sure it is a pointer to something */
2163 if
(!is_ptr
(type
)) return FALSE
;
2165 /* second, make sure it is a pointer to something of size sizeof(GUID),
2167 return
(type_memsize
(type_pointer_get_ref
(type
), &align
) == 16);
2170 static void check_conformance_expr_list
(const char *attr_name
, const var_t
*arg
, const type_t
*container_type
, expr_list_t
*expr_list
)
2173 struct expr_loc expr_loc
;
2175 expr_loc.attr
= attr_name
;
2176 if
(expr_list
) LIST_FOR_EACH_ENTRY
(dim
, expr_list
, expr_t
, entry
)
2178 if
(dim
->type
!= EXPR_VOID
)
2180 const type_t
*expr_type
= expr_resolve_type
(&expr_loc
, container_type
, dim
);
2181 if
(!is_allowed_conf_type
(expr_type
))
2182 error_loc_info
(&arg
->loc_info
, "expression must resolve to integral type <= 32bits for attribute %s\n",
2188 static void check_remoting_fields
(const var_t
*var
, type_t
*type
);
2190 /* checks that properties common to fields and arguments are consistent */
2191 static void check_field_common
(const type_t
*container_type
,
2192 const char *container_name
, const var_t
*arg
)
2194 type_t
*type
= arg
->type
;
2196 const char *container_type_name
= NULL
;
2198 switch
(type_get_type_detect_alias
(type
))
2201 container_type_name
= "struct";
2204 container_type_name
= "union";
2206 case TYPE_ENCAPSULATED_UNION
:
2207 container_type_name
= "encapsulated union";
2210 container_type_name
= "function";
2216 if
(is_attr
(arg
->attrs
, ATTR_LENGTHIS
) &&
2217 (is_attr
(arg
->attrs
, ATTR_STRING
) || is_aliaschain_attr
(arg
->type
, ATTR_STRING
)))
2218 error_loc_info
(&arg
->loc_info
,
2219 "string and length_is specified for argument %s are mutually exclusive attributes\n",
2222 if
(is_attr
(arg
->attrs
, ATTR_SIZEIS
))
2224 expr_list_t
*size_is_exprs
= get_attrp
(arg
->attrs
, ATTR_SIZEIS
);
2225 check_conformance_expr_list
("size_is", arg
, container_type
, size_is_exprs
);
2227 if
(is_attr
(arg
->attrs
, ATTR_LENGTHIS
))
2229 expr_list_t
*length_is_exprs
= get_attrp
(arg
->attrs
, ATTR_LENGTHIS
);
2230 check_conformance_expr_list
("length_is", arg
, container_type
, length_is_exprs
);
2232 if
(is_attr
(arg
->attrs
, ATTR_IIDIS
))
2234 struct expr_loc expr_loc
;
2235 expr_t
*expr
= get_attrp
(arg
->attrs
, ATTR_IIDIS
);
2236 if
(expr
->type
!= EXPR_VOID
)
2238 const type_t
*expr_type
;
2240 expr_loc.attr
= "iid_is";
2241 expr_type
= expr_resolve_type
(&expr_loc
, container_type
, expr
);
2242 if
(!expr_type ||
!is_ptr_guid_type
(expr_type
))
2243 error_loc_info
(&arg
->loc_info
, "expression must resolve to pointer to GUID type for attribute iid_is\n");
2246 if
(is_attr
(arg
->attrs
, ATTR_SWITCHIS
))
2248 struct expr_loc expr_loc
;
2249 expr_t
*expr
= get_attrp
(arg
->attrs
, ATTR_SWITCHIS
);
2250 if
(expr
->type
!= EXPR_VOID
)
2252 const type_t
*expr_type
;
2254 expr_loc.attr
= "switch_is";
2255 expr_type
= expr_resolve_type
(&expr_loc
, container_type
, expr
);
2256 if
(!expr_type ||
!is_allowed_conf_type
(expr_type
))
2257 error_loc_info
(&arg
->loc_info
, "expression must resolve to integral type <= 32bits for attribute %s\n",
2266 switch
(typegen_detect_type
(type
, arg
->attrs
, TDT_IGNORE_STRINGS
))
2270 check_remoting_fields
(arg
, type
);
2273 switch
(type_get_type
(type
))
2276 error_loc_info
(&arg
->loc_info
, "parameter \'%s\' of %s \'%s\' cannot derive from void *\n",
2277 arg
->name
, container_type_name
, container_name
);
2280 error_loc_info
(&arg
->loc_info
, "parameter \'%s\' of %s \'%s\' cannot be a function pointer\n",
2281 arg
->name
, container_type_name
, container_name
);
2284 case TYPE_INTERFACE
:
2291 case TGT_CTXT_HANDLE
:
2292 case TGT_CTXT_HANDLE_POINTER
:
2296 type
= type_pointer_get_ref
(type
);
2300 type
= type_array_get_element
(type
);
2305 case TGT_IFACE_POINTER
:
2311 } while
(more_to_do
);
2314 static void check_remoting_fields
(const var_t
*var
, type_t
*type
)
2317 const var_list_t
*fields
= NULL
;
2319 type
= type_get_real_type
(type
);
2324 type
->checked
= TRUE
;
2326 if
(type_get_type
(type
) == TYPE_STRUCT
)
2328 if
(type_is_complete
(type
))
2329 fields
= type_struct_get_fields
(type
);
2331 error_loc_info
(&var
->loc_info
, "undefined type declaration %s\n", type
->name
);
2333 else if
(type_get_type
(type
) == TYPE_UNION || type_get_type
(type
) == TYPE_ENCAPSULATED_UNION
)
2334 fields
= type_union_get_cases
(type
);
2336 if
(fields
) LIST_FOR_EACH_ENTRY
( field
, fields
, const var_t
, entry
)
2337 if
(field
->type
) check_field_common
(type
, type
->name
, field
);
2340 /* checks that arguments for a function make sense for marshalling and unmarshalling */
2341 static void check_remoting_args
(const var_t
*func
)
2343 const char *funcname
= func
->name
;
2346 if
(func
->type
->details.function
->args
) LIST_FOR_EACH_ENTRY
( arg
, func
->type
->details.function
->args
, const var_t
, entry
)
2348 const type_t
*type
= arg
->type
;
2350 /* check that [out] parameters have enough pointer levels */
2351 if
(is_attr
(arg
->attrs
, ATTR_OUT
))
2353 switch
(typegen_detect_type
(type
, arg
->attrs
, TDT_ALL_TYPES
))
2359 case TGT_CTXT_HANDLE
:
2361 error_loc_info
(&arg
->loc_info
, "out parameter \'%s\' of function \'%s\' is not a pointer\n", arg
->name
, funcname
);
2363 case TGT_IFACE_POINTER
:
2364 error_loc_info
(&arg
->loc_info
, "out interface pointer \'%s\' of function \'%s\' is not a double pointer\n", arg
->name
, funcname
);
2367 if
(!is_array
(type
))
2373 /* already error'd before we get here */
2374 case TGT_CTXT_HANDLE_POINTER
:
2382 check_field_common
(func
->type
, funcname
, arg
);
2386 static void add_explicit_handle_if_necessary
(var_t
*func
)
2388 const var_t
* explicit_handle_var
;
2389 const var_t
* explicit_generic_handle_var
= NULL
;
2390 const var_t
* context_handle_var
= NULL
;
2392 /* check for a defined binding handle */
2393 explicit_handle_var
= get_explicit_handle_var
(func
);
2394 if
(!explicit_handle_var
)
2396 explicit_generic_handle_var
= get_explicit_generic_handle_var
(func
);
2397 if
(!explicit_generic_handle_var
)
2399 context_handle_var
= get_context_handle_var
(func
);
2400 if
(!context_handle_var
)
2402 /* no explicit handle specified so add
2403 * "[in] handle_t IDL_handle" as the first parameter to the
2405 var_t
*idl_handle
= make_var
(xstrdup
("IDL_handle"));
2406 idl_handle
->attrs
= append_attr
(NULL
, make_attr
(ATTR_IN
));
2407 idl_handle
->type
= find_type_or_error
("handle_t", 0);
2408 type_function_add_head_arg
(func
->type
, idl_handle
);
2414 static void check_functions
(const type_t
*iface
, int is_inside_library
)
2416 const statement_t
*stmt
;
2417 if
(is_attr
(iface
->attrs
, ATTR_EXPLICIT_HANDLE
))
2419 STATEMENTS_FOR_EACH_FUNC
( stmt
, type_iface_get_stmts
(iface
) )
2421 var_t
*func
= stmt
->u.var
;
2422 add_explicit_handle_if_necessary
(func
);
2425 if
(!is_inside_library
&& !is_attr
(iface
->attrs
, ATTR_LOCAL
))
2427 STATEMENTS_FOR_EACH_FUNC
( stmt
, type_iface_get_stmts
(iface
) )
2429 const var_t
*func
= stmt
->u.var
;
2430 if
(!is_attr
(func
->attrs
, ATTR_LOCAL
))
2431 check_remoting_args
(func
);
2436 static void check_statements
(const statement_list_t
*stmts
, int is_inside_library
)
2438 const statement_t
*stmt
;
2440 if
(stmts
) LIST_FOR_EACH_ENTRY
(stmt
, stmts
, const statement_t
, entry
)
2442 if
(stmt
->type
== STMT_LIBRARY
)
2443 check_statements
(stmt
->u.lib
->stmts
, TRUE
);
2444 else if
(stmt
->type
== STMT_TYPE
&& type_get_type
(stmt
->u.type
) == TYPE_INTERFACE
)
2445 check_functions
(stmt
->u.type
, is_inside_library
);
2449 static void check_all_user_types
(const statement_list_t
*stmts
)
2451 const statement_t
*stmt
;
2453 if
(stmts
) LIST_FOR_EACH_ENTRY
(stmt
, stmts
, const statement_t
, entry
)
2455 if
(stmt
->type
== STMT_LIBRARY
)
2456 check_all_user_types
(stmt
->u.lib
->stmts
);
2457 else if
(stmt
->type
== STMT_TYPE
&& type_get_type
(stmt
->u.type
) == TYPE_INTERFACE
&&
2458 !is_local
(stmt
->u.type
->attrs
))
2460 const statement_t
*stmt_func
;
2461 STATEMENTS_FOR_EACH_FUNC
(stmt_func
, type_iface_get_stmts
(stmt
->u.type
)) {
2462 const var_t
*func
= stmt_func
->u.var
;
2463 check_for_additional_prototype_types
(func
->type
->details.function
->args
);
2469 int is_valid_uuid
(const char *s
)
2473 for
(i
= 0; i
< 36; ++i
)
2474 if
(i
== 8 || i
== 13 || i
== 18 || i
== 23)
2480 if
(!isxdigit
(s
[i
]))
2483 return s
[i
] == '\0';
2486 static statement_t
*make_statement
(enum statement_type type
)
2488 statement_t
*stmt
= xmalloc
(sizeof
(*stmt
));
2493 static statement_t
*make_statement_type_decl
(type_t
*type
)
2495 statement_t
*stmt
= make_statement
(STMT_TYPE
);
2496 stmt
->u.type
= type
;
2500 static statement_t
*make_statement_reference
(type_t
*type
)
2502 statement_t
*stmt
= make_statement
(STMT_TYPEREF
);
2503 stmt
->u.type
= type
;
2507 static statement_t
*make_statement_declaration
(var_t
*var
)
2509 statement_t
*stmt
= make_statement
(STMT_DECLARATION
);
2511 if
(var
->stgclass
== STG_EXTERN
&& var
->eval
)
2512 warning
("'%s' initialised and declared extern\n", var
->name
);
2513 if
(is_const_decl
(var
))
2518 else if
(type_get_type
(var
->type
) == TYPE_FUNCTION
)
2519 check_function_attrs
(var
->name
, var
->attrs
);
2520 else if
(var
->stgclass
== STG_NONE || var
->stgclass
== STG_REGISTER
)
2521 error_loc
("instantiation of data is illegal\n");
2525 static statement_t
*make_statement_library
(typelib_t
*typelib
)
2527 statement_t
*stmt
= make_statement
(STMT_LIBRARY
);
2528 stmt
->u.lib
= typelib
;
2532 static statement_t
*make_statement_cppquote
(const char *str
)
2534 statement_t
*stmt
= make_statement
(STMT_CPPQUOTE
);
2539 static statement_t
*make_statement_importlib
(const char *str
)
2541 statement_t
*stmt
= make_statement
(STMT_IMPORTLIB
);
2546 static statement_t
*make_statement_import
(const char *str
)
2548 statement_t
*stmt
= make_statement
(STMT_IMPORT
);
2553 static statement_t
*make_statement_module
(type_t
*type
)
2555 statement_t
*stmt
= make_statement
(STMT_MODULE
);
2556 stmt
->u.type
= type
;
2560 static statement_t
*make_statement_typedef
(declarator_list_t
*decls
)
2562 declarator_t
*decl
, *next
;
2564 type_list_t
**type_list
;
2566 if
(!decls
) return NULL
;
2568 stmt
= make_statement
(STMT_TYPEDEF
);
2569 stmt
->u.type_list
= NULL
;
2570 type_list
= &stmt
->u.type_list
;
2572 LIST_FOR_EACH_ENTRY_SAFE
( decl
, next
, decls
, declarator_t
, entry
)
2574 var_t
*var
= decl
->var
;
2575 type_t
*type
= find_type_or_error
(var
->name
, 0);
2576 *type_list
= xmalloc
(sizeof
(type_list_t
));
2577 (*type_list
)->type
= type
;
2578 (*type_list
)->next
= NULL
;
2580 type_list
= &(*type_list
)->next
;
2588 static statement_list_t
*append_statement
(statement_list_t
*list
, statement_t
*stmt
)
2590 if
(!stmt
) return list
;
2593 list
= xmalloc
( sizeof
(*list
) );
2596 list_add_tail
( list
, &stmt
->entry
);
2600 void init_loc_info
(loc_info_t
*i
)
2602 i
->input_name
= input_name ? input_name
: "stdin";
2603 i
->line_number
= line_number
;
2604 i
->near_text
= parser_text
;
2607 static void check_def
(const type_t
*t
)
2610 error_loc
("%s: redefinition error; original definition was at %s:%d\n",
2611 t
->name
, t
->loc_info.input_name
, t
->loc_info.line_number
);