5 * Copyright 2002 Ove Kaaven
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
43 /* Berkeley yacc (byacc) doesn't seem to know about these */
44 /* Some *BSD supplied versions do define these though */
46 # define YYEMPTY (-1) /* Empty lookahead value of yychar */
49 # define YYLEX yylex()
52 #elif defined(YYBISON)
53 /* Bison was used for original development */
54 /* #define YYEMPTY -2 */
55 /* #define YYLEX yylex() */
58 /* No yacc we know yet */
59 # if !defined(YYEMPTY) || !defined(YYLEX)
60 # error Yacc version/type unknown. This version needs to be verified for settings of YYEMPTY and YYLEX.
61 # elif defined(__GNUC__) /* gcc defines the #warning directive */
62 # warning Yacc version/type unknown. It defines YYEMPTY and YYLEX, but is not tested
63 /* #else we just take a chance that it works... */
67 static attr_t
*make_attr
(enum attr_type type
);
68 static attr_t
*make_attrv
(enum attr_type type
, unsigned long val
);
69 static attr_t
*make_attrp
(enum attr_type type
, void *val
);
70 static expr_t
*make_expr
(enum expr_type type
);
71 static expr_t
*make_exprl
(enum expr_type type
, long val
);
72 static expr_t
*make_exprs
(enum expr_type type
, char *val
);
73 static expr_t
*make_exprt
(enum expr_type type
, typeref_t
*tref
, expr_t
*expr
);
74 static expr_t
*make_expr1
(enum expr_type type
, expr_t
*expr
);
75 static expr_t
*make_expr2
(enum expr_type type
, expr_t
*exp1
, expr_t
*exp2
);
76 static expr_t
*make_expr3
(enum expr_type type
, expr_t
*expr1
, expr_t
*expr2
, expr_t
*expr3
);
77 static type_t
*make_type
(unsigned char type
, type_t
*ref
);
78 static typeref_t
*make_tref
(char *name
, type_t
*ref
);
79 static typeref_t
*uniq_tref
(typeref_t
*ref
);
80 static type_t
*type_ref
(typeref_t
*ref
);
81 static void set_type
(var_t
*v
, typeref_t
*ref
, expr_t
*arr
);
82 static ifref_t
*make_ifref
(type_t
*iface
);
83 static var_t
*make_var
(char *name
);
84 static func_t
*make_func
(var_t
*def
, var_t
*args
);
85 static type_t
*make_class
(char *name
);
86 static type_t
*make_safearray
(void);
88 static type_t
*reg_type
(type_t
*type
, const char *name
, int t
);
89 static type_t
*reg_types
(type_t
*type
, var_t
*names
, int t
);
90 static type_t
*find_type
(const char *name
, int t
);
91 static type_t
*find_type2
(char *name
, int t
);
92 static type_t
*get_type
(unsigned char type
, char *name
, int t
);
93 static type_t
*get_typev
(unsigned char type
, var_t
*name
, int t
);
94 static int get_struct_type
(var_t
*fields
);
96 static var_t
*reg_const
(var_t
*var
);
97 static var_t
*find_const
(char *name
, int f
);
99 static void write_libid
(const char *name
, const attr_t
*attr
);
100 static void write_clsid
(type_t
*cls
);
101 static void write_diid
(type_t
*iface
);
102 static void write_iid
(type_t
*iface
);
108 static type_t std_bool
= { "boolean" };
109 static type_t std_int
= { "int" };
110 static type_t std_int64
= { "__int64" };
111 static type_t std_uhyper
= { "MIDL_uhyper" };
127 %token
<str
> aIDENTIFIER
128 %token
<str
> aKNOWNTYPE
129 %token
<num
> aNUM aHEXNUM
134 %token tAGGREGATABLE tALLOCATE tAPPOBJECT tASYNC tASYNCUUID
135 %token tAUTOHANDLE tBINDABLE tBOOLEAN tBROADCAST tBYTE tBYTECOUNT
136 %token tCALLAS tCALLBACK tCASE tCDECL tCHAR tCOCLASS tCODE tCOMMSTATUS
137 %token tCONST tCONTEXTHANDLE tCONTEXTHANDLENOSERIALIZE
138 %token tCONTEXTHANDLESERIALIZE tCONTROL tCPPQUOTE
140 %token tDEFAULTCOLLELEM
142 %token tDEFAULTVTABLE
144 %token tDISPINTERFACE
145 %token tDLLNAME tDOUBLE tDUAL
147 %token tENTRY tENUM tERRORSTATUST
148 %token tEXPLICITHANDLE tEXTERN
153 %token tHELPCONTEXT tHELPFILE
154 %token tHELPSTRING tHELPSTRINGCONTEXT tHELPSTRINGDLL
156 %token tHYPER tID tIDEMPOTENT
158 %token tIMMEDIATEBIND
159 %token tIMPLICITHANDLE
160 %token tIMPORT tIMPORTLIB
166 %token tLENGTHIS tLIBRARY
173 %token tNONEXTENSIBLE
174 %token tOBJECT tODL tOLEAUTOMATION
177 %token tPOINTERDEFAULT
179 %token tPROPGET tPROPPUT tPROPPUTREF
183 %token tREADONLY tREF
191 %token tSIZEIS tSIZEOF
195 %token tSTRING tSTRUCT
196 %token tSWITCH tSWITCHIS tSWITCHTYPE
208 %token tWCHAR tWIREMARSHAL
210 %type
<attr
> m_attributes attributes attrib_list attribute
211 %type
<expr
> m_exprs
/* exprs expr_list */ m_expr expr expr_list_const expr_const
212 %type
<expr
> array array_list
213 %type
<type
> inherit interface interfacehdr interfacedef interfacedec
214 %type
<type
> dispinterface dispinterfacehdr dispinterfacedef
215 %type
<type
> module modulehdr moduledef
216 %type
<type
> base_type int_std
217 %type
<type
> enumdef structdef typedef uniondef
218 %type
<ifref
> gbl_statements coclass_ints coclass_int
220 %type
<var
> m_args no_args args arg
221 %type
<var
> fields field s_field cases case enums enum_list
enum constdef externdef
222 %type
<var
> m_ident t_ident ident p_ident pident pident_list
223 %type
<var
> dispint_props
224 %type
<func
> funcdef int_statements
225 %type
<func
> dispint_meths
226 %type
<type
> coclass coclasshdr coclassdef
227 %type
<num
> pointer_type version
228 %type
<str
> libraryhdr
244 input: gbl_statements
{ write_proxies
($1); write_client
($1); write_server
($1); }
247 gbl_statements: { $$
= NULL
; }
248 | gbl_statements interfacedec
{ $$
= $1; }
249 | gbl_statements interfacedef
{ $$
= make_ifref
($2); LINK
($$
, $1); }
250 | gbl_statements coclass
';' { $$
= $1;
251 reg_type
($2, $2->name
, 0);
252 if
(!parse_only
&& do_header
) write_coclass_forward
($2);
254 | gbl_statements coclassdef
{ $$
= $1;
256 reg_type
($2, $2->name
, 0);
257 if
(!parse_only
&& do_header
) write_coclass_forward
($2);
259 | gbl_statements moduledef
{ $$
= $1; add_module
($2); }
260 | gbl_statements librarydef
{ $$
= $1; }
261 | gbl_statements statement
{ $$
= $1; }
265 | imp_statements interfacedec
{ if
(!parse_only
) add_interface
($2); }
266 | imp_statements interfacedef
{ if
(!parse_only
) add_interface
($2); }
267 | imp_statements coclass
';' { reg_type
($2, $2->name
, 0); if
(!parse_only
&& do_header
) write_coclass_forward
($2); }
268 | imp_statements coclassdef
{ if
(!parse_only
) add_coclass
($2);
269 reg_type
($2, $2->name
, 0);
270 if
(!parse_only
&& do_header
) write_coclass_forward
($2);
272 | imp_statements moduledef
{ if
(!parse_only
) add_module
($2); }
273 | imp_statements statement
{}
274 | imp_statements importlib
{}
277 int_statements: { $$
= NULL
; }
278 | int_statements funcdef
';' { $$
= $2; LINK
($$
, $1); }
279 | int_statements statement
{ $$
= $1; }
283 | constdef
';' { if
(!parse_only
&& do_header
) { write_constdef
($1); } }
285 | enumdef
';' { if
(!parse_only
&& do_header
) { write_type
(header
, $1, NULL
, NULL
); fprintf
(header
, ";\n\n"); } }
286 | externdef
';' { if
(!parse_only
&& do_header
) { write_externdef
($1); } }
288 | structdef
';' { if
(!parse_only
&& do_header
) { write_type
(header
, $1, NULL
, NULL
); fprintf
(header
, ";\n\n"); } }
290 | uniondef
';' { if
(!parse_only
&& do_header
) { write_type
(header
, $1, NULL
, NULL
); fprintf
(header
, ";\n\n"); } }
293 cppquote: tCPPQUOTE
'(' aSTRING
')' { if
(!parse_only
&& do_header
) fprintf
(header
, "%s\n", $3); }
295 import_start: tIMPORT aSTRING
';' { assert
(yychar == YYEMPTY
);
296 if
(!do_import
($2)) yychar = aEOF
; }
298 import: import_start imp_statements aEOF
{}
301 importlib: tIMPORTLIB
'(' aSTRING
')' { if
(!parse_only
) add_importlib
($3); }
304 libraryhdr: tLIBRARY aIDENTIFIER
{ $$
= $2; }
306 library_start: attributes libraryhdr
'{' { start_typelib
($2, $1);
307 if
(!parse_only
&& do_header
) write_library
($2, $1);
308 if
(!parse_only
&& do_idfile
) write_libid
($2, $1);
311 librarydef: library_start imp_statements
'}' { end_typelib
(); }
314 m_args: { $$
= NULL
; }
318 no_args: tVOID
{ $$
= NULL
; }
322 | args
',' arg
{ LINK
($3, $1); $$
= $3; }
326 /* split into two rules to get bison to resolve a tVOID conflict */
327 arg: attributes type pident array
{ $$
= $3;
328 set_type
($$
, $2, $4);
331 | type pident array
{ $$
= $2;
332 set_type
($$
, $1, $3);
334 | attributes type pident
'(' m_args
')' { $$
= $3;
336 set_type
($$
, $2, NULL
);
340 | type pident
'(' m_args
')' { $$
= $2;
342 set_type
($$
, $1, NULL
);
347 array: { $$
= NULL
; }
348 |
'[' array_list
']' { $$
= $2; }
349 |
'[' '*' ']' { $$
= make_expr
(EXPR_VOID
); }
352 array_list: m_expr
/* size of first dimension is optional */
353 | array_list
',' expr
{ LINK
($3, $1); $$
= $3; }
354 | array_list
']' '[' expr
{ LINK
($4, $1); $$
= $4; }
357 m_attributes: { $$
= NULL
; }
362 '[' attrib_list
']' { $$
= $2;
364 yyerror("empty attribute lists unsupported");
368 attrib_list: attribute
369 | attrib_list
',' attribute
{ if
($3) { LINK
($3, $1); $$
= $3; }
372 | attrib_list
']' '[' attribute
{ if
($4) { LINK
($4, $1); $$
= $4; }
377 attribute: { $$
= NULL
; }
378 | tAGGREGATABLE
{ $$
= make_attr
(ATTR_AGGREGATABLE
); }
379 | tAPPOBJECT
{ $$
= make_attr
(ATTR_APPOBJECT
); }
380 | tASYNC
{ $$
= make_attr
(ATTR_ASYNC
); }
381 | tAUTOHANDLE
{ $$
= make_attr
(ATTR_AUTO_HANDLE
); }
382 | tBINDABLE
{ $$
= make_attr
(ATTR_BINDABLE
); }
383 | tCALLAS
'(' ident
')' { $$
= make_attrp
(ATTR_CALLAS
, $3); }
384 | tCASE
'(' expr_list_const
')' { $$
= make_attrp
(ATTR_CASE
, $3); }
385 | tCONTEXTHANDLE
{ $$
= make_attrv
(ATTR_CONTEXTHANDLE
, 0); }
386 | tCONTEXTHANDLENOSERIALIZE
{ $$
= make_attrv
(ATTR_CONTEXTHANDLE
, 0); /* RPC_CONTEXT_HANDLE_DONT_SERIALIZE */ }
387 | tCONTEXTHANDLESERIALIZE
{ $$
= make_attrv
(ATTR_CONTEXTHANDLE
, 0); /* RPC_CONTEXT_HANDLE_SERIALIZE */ }
388 | tCONTROL
{ $$
= make_attr
(ATTR_CONTROL
); }
389 | tDEFAULT
{ $$
= make_attr
(ATTR_DEFAULT
); }
390 | tDEFAULTCOLLELEM
{ $$
= make_attr
(ATTR_DEFAULTCOLLELEM
); }
391 | tDEFAULTVALUE
'(' expr_const
')' { $$
= make_attrp
(ATTR_DEFAULTVALUE_EXPR
, $3); }
392 | tDEFAULTVALUE
'(' aSTRING
')' { $$
= make_attrp
(ATTR_DEFAULTVALUE_STRING
, $3); }
393 | tDEFAULTVTABLE
{ $$
= make_attr
(ATTR_DEFAULTVTABLE
); }
394 | tDISPLAYBIND
{ $$
= make_attr
(ATTR_DISPLAYBIND
); }
395 | tDLLNAME
'(' aSTRING
')' { $$
= make_attrp
(ATTR_DLLNAME
, $3); }
396 | tDUAL
{ $$
= make_attr
(ATTR_DUAL
); }
397 | tENDPOINT
'(' aSTRING
')' { $$
= make_attrp
(ATTR_ENDPOINT
, $3); }
398 | tENTRY
'(' aSTRING
')' { $$
= make_attrp
(ATTR_ENTRY_STRING
, $3); }
399 | tENTRY
'(' expr_const
')' { $$
= make_attrp
(ATTR_ENTRY_ORDINAL
, $3); }
400 | tEXPLICITHANDLE
{ $$
= make_attr
(ATTR_EXPLICIT_HANDLE
); }
401 | tHANDLE
{ $$
= make_attr
(ATTR_HANDLE
); }
402 | tHELPCONTEXT
'(' expr_const
')' { $$
= make_attrp
(ATTR_HELPCONTEXT
, $3); }
403 | tHELPFILE
'(' aSTRING
')' { $$
= make_attrp
(ATTR_HELPFILE
, $3); }
404 | tHELPSTRING
'(' aSTRING
')' { $$
= make_attrp
(ATTR_HELPSTRING
, $3); }
405 | tHELPSTRINGCONTEXT
'(' expr_const
')' { $$
= make_attrp
(ATTR_HELPSTRINGCONTEXT
, $3); }
406 | tHELPSTRINGDLL
'(' aSTRING
')' { $$
= make_attrp
(ATTR_HELPSTRINGDLL
, $3); }
407 | tHIDDEN
{ $$
= make_attr
(ATTR_HIDDEN
); }
408 | tID
'(' expr_const
')' { $$
= make_attrp
(ATTR_ID
, $3); }
409 | tIDEMPOTENT
{ $$
= make_attr
(ATTR_IDEMPOTENT
); }
410 | tIIDIS
'(' ident
')' { $$
= make_attrp
(ATTR_IIDIS
, $3); }
411 | tIMMEDIATEBIND
{ $$
= make_attr
(ATTR_IMMEDIATEBIND
); }
412 | tIMPLICITHANDLE
'(' tHANDLET aIDENTIFIER
')' { $$
= make_attrp
(ATTR_IMPLICIT_HANDLE
, $4); }
413 | tIN
{ $$
= make_attr
(ATTR_IN
); }
414 | tINPUTSYNC
{ $$
= make_attr
(ATTR_INPUTSYNC
); }
415 | tLENGTHIS
'(' m_exprs
')' { $$
= make_attrp
(ATTR_LENGTHIS
, $3); }
416 | tLOCAL
{ $$
= make_attr
(ATTR_LOCAL
); }
417 | tNONBROWSABLE
{ $$
= make_attr
(ATTR_NONBROWSABLE
); }
418 | tNONCREATABLE
{ $$
= make_attr
(ATTR_NONCREATABLE
); }
419 | tNONEXTENSIBLE
{ $$
= make_attr
(ATTR_NONEXTENSIBLE
); }
420 | tOBJECT
{ $$
= make_attr
(ATTR_OBJECT
); }
421 | tODL
{ $$
= make_attr
(ATTR_ODL
); }
422 | tOLEAUTOMATION
{ $$
= make_attr
(ATTR_OLEAUTOMATION
); }
423 | tOPTIONAL
{ $$
= make_attr
(ATTR_OPTIONAL
); }
424 | tOUT
{ $$
= make_attr
(ATTR_OUT
); }
425 | tPOINTERDEFAULT
'(' pointer_type
')' { $$
= make_attrv
(ATTR_POINTERDEFAULT
, $3); }
426 | tPROPGET
{ $$
= make_attr
(ATTR_PROPGET
); }
427 | tPROPPUT
{ $$
= make_attr
(ATTR_PROPPUT
); }
428 | tPROPPUTREF
{ $$
= make_attr
(ATTR_PROPPUTREF
); }
429 | tPUBLIC
{ $$
= make_attr
(ATTR_PUBLIC
); }
430 | tRANGE
'(' expr_const
',' expr_const
')' { LINK
($5, $3); $$
= make_attrp
(ATTR_RANGE
, $5); }
431 | tREADONLY
{ $$
= make_attr
(ATTR_READONLY
); }
432 | tREQUESTEDIT
{ $$
= make_attr
(ATTR_REQUESTEDIT
); }
433 | tRESTRICTED
{ $$
= make_attr
(ATTR_RESTRICTED
); }
434 | tRETVAL
{ $$
= make_attr
(ATTR_RETVAL
); }
435 | tSIZEIS
'(' m_exprs
')' { $$
= make_attrp
(ATTR_SIZEIS
, $3); }
436 | tSOURCE
{ $$
= make_attr
(ATTR_SOURCE
); }
437 | tSTRING
{ $$
= make_attr
(ATTR_STRING
); }
438 | tSWITCHIS
'(' expr
')' { $$
= make_attrp
(ATTR_SWITCHIS
, $3); }
439 | tSWITCHTYPE
'(' type
')' { $$
= make_attrp
(ATTR_SWITCHTYPE
, type_ref
($3)); }
440 | tTRANSMITAS
'(' type
')' { $$
= make_attrp
(ATTR_TRANSMITAS
, type_ref
($3)); }
441 | tUUID
'(' aUUID
')' { $$
= make_attrp
(ATTR_UUID
, $3); }
442 | tV1ENUM
{ $$
= make_attr
(ATTR_V1ENUM
); }
443 | tVARARG
{ $$
= make_attr
(ATTR_VARARG
); }
444 | tVERSION
'(' version
')' { $$
= make_attrv
(ATTR_VERSION
, $3); }
445 | tWIREMARSHAL
'(' type
')' { $$
= make_attrp
(ATTR_WIREMARSHAL
, type_ref
($3)); }
446 | pointer_type
{ $$
= make_attrv
(ATTR_POINTERTYPE
, $1); }
453 cases: { $$
= NULL
; }
454 | cases case
{ if
($2) { LINK
($2, $1); $$
= $2; }
459 case: tCASE expr
':' field
{ attr_t
*a
= make_attrp
(ATTR_CASE
, $2);
460 $$
= $4; if
(!$$
) $$
= make_var
(NULL
);
461 LINK
(a
, $$
->attrs
); $$
->attrs
= a
;
463 | tDEFAULT
':' field
{ attr_t
*a
= make_attr
(ATTR_DEFAULT
);
464 $$
= $3; if
(!$$
) $$
= make_var
(NULL
);
465 LINK
(a
, $$
->attrs
); $$
->attrs
= a
;
469 constdef: tCONST type ident
'=' expr_const
{ $$
= reg_const
($3);
470 set_type
($$
, $2, NULL
);
475 enums: { $$
= NULL
; }
476 | enum_list
',' { $$
= $1; }
480 enum_list: enum { if
(!$$
->eval
)
481 $$
->eval
= make_exprl
(EXPR_NUM
, 0 /* default for first enum entry */);
483 | enum_list
',' enum { LINK
($3, $1); $$
= $3;
485 $$
->eval
= make_exprl
(EXPR_NUM
, $1->eval
->cval
+ 1);
489 enum: ident
'=' expr_const
{ $$
= reg_const
($1);
491 $$
->type
= make_type
(RPC_FC_LONG
, &std_int
);
493 | ident
{ $$
= reg_const
($1);
494 $$
->type
= make_type
(RPC_FC_LONG
, &std_int
);
498 enumdef: tENUM t_ident
'{' enums
'}' { $$
= get_typev
(RPC_FC_ENUM16
, $2, tsENUM
);
499 $$
->kind
= TKIND_ENUM
;
508 | m_exprs
',' m_expr
{ LINK
($3, $1); $$
= $3; }
512 exprs: { $$ = make_expr(EXPR_VOID); }
517 | expr_list ',' expr { LINK($3, $1); $$ = $3; }
521 m_expr: { $$
= make_expr
(EXPR_VOID
); }
525 expr: aNUM
{ $$
= make_exprl
(EXPR_NUM
, $1); }
526 | aHEXNUM
{ $$
= make_exprl
(EXPR_HEXNUM
, $1); }
527 | tFALSE
{ $$
= make_exprl
(EXPR_TRUEFALSE
, 0); }
528 | tTRUE
{ $$
= make_exprl
(EXPR_TRUEFALSE
, 1); }
529 | aIDENTIFIER
{ $$
= make_exprs
(EXPR_IDENTIFIER
, $1); }
530 | expr
'?' expr
':' expr
{ $$
= make_expr3
(EXPR_COND
, $1, $3, $5); }
531 | expr
'|' expr
{ $$
= make_expr2
(EXPR_OR
, $1, $3); }
532 | expr
'&' expr
{ $$
= make_expr2
(EXPR_AND
, $1, $3); }
533 | expr
'+' expr
{ $$
= make_expr2
(EXPR_ADD
, $1, $3); }
534 | expr
'-' expr
{ $$
= make_expr2
(EXPR_SUB
, $1, $3); }
535 | expr
'*' expr
{ $$
= make_expr2
(EXPR_MUL
, $1, $3); }
536 | expr
'/' expr
{ $$
= make_expr2
(EXPR_DIV
, $1, $3); }
537 | expr SHL expr
{ $$
= make_expr2
(EXPR_SHL
, $1, $3); }
538 | expr SHR expr
{ $$
= make_expr2
(EXPR_SHR
, $1, $3); }
539 |
'~' expr
{ $$
= make_expr1
(EXPR_NOT
, $2); }
540 |
'-' expr %prec NEG
{ $$
= make_expr1
(EXPR_NEG
, $2); }
541 |
'*' expr %prec PPTR
{ $$
= make_expr1
(EXPR_PPTR
, $2); }
542 |
'(' type
')' expr %prec CAST
{ $$
= make_exprt
(EXPR_CAST
, $2, $4); }
543 | tSIZEOF
'(' type
')' { $$
= make_exprt
(EXPR_SIZEOF
, $3, NULL
); }
544 |
'(' expr
')' { $$
= $2; }
547 expr_list_const: expr_const
548 | expr_list_const
',' expr_const
{ LINK
($3, $1); $$
= $3; }
551 expr_const: expr
{ $$
= $1;
553 yyerror("expression is not constant");
557 externdef: tEXTERN tCONST type ident
{ $$
= $4;
558 set_type
($$
, $3, NULL
);
562 fields: { $$
= NULL
; }
563 | fields field
{ if
($2) { LINK
($2, $1); $$
= $2; }
568 field: s_field
';' { $$
= $1; }
569 | m_attributes uniondef
';' { $$
= make_var
(NULL
); $$
->type
= $2; $$
->attrs
= $1; }
570 | attributes
';' { $$
= make_var
(NULL
); $$
->attrs
= $1; }
574 s_field: m_attributes type pident array
{ $$
= $3; set_type
($$
, $2, $4); $$
->attrs
= $1; }
578 m_attributes type callconv pident
579 '(' m_args
')' { set_type
($4, $2, NULL
);
581 $$
= make_func
($4, $6);
582 if
(is_attr
($4->attrs
, ATTR_IN
)) {
583 yyerror("inapplicable attribute [in] for function '%s'",$$
->def
->name
);
588 m_ident: { $$
= NULL
; }
592 t_ident: { $$
= NULL
; }
593 | aIDENTIFIER
{ $$
= make_var
($1); }
594 | aKNOWNTYPE
{ $$
= make_var
($1); }
597 ident: aIDENTIFIER
{ $$
= make_var
($1); }
598 /* some "reserved words" used in attributes are also used as field names in some MS IDL files */
599 | aKNOWNTYPE
{ $$
= make_var
($
<str
>1); }
600 | tASYNC
{ $$
= make_var
($
<str
>1); }
601 | tID
{ $$
= make_var
($
<str
>1); }
602 | tLCID
{ $$
= make_var
($
<str
>1); }
603 | tOBJECT
{ $$
= make_var
($
<str
>1); }
604 | tRANGE
{ $$
= make_var
($
<str
>1); }
605 | tRETVAL
{ $$
= make_var
($
<str
>1); }
606 | tUUID
{ $$
= make_var
($
<str
>1); }
607 | tVERSION
{ $$
= make_var
($
<str
>1); }
610 base_type: tBYTE
{ $$
= make_type
(RPC_FC_BYTE
, NULL
); }
611 | tWCHAR
{ $$
= make_type
(RPC_FC_WCHAR
, NULL
); }
613 | tSIGNED int_std
{ $$
= $2; $$
->sign
= 1; }
614 | tUNSIGNED int_std
{ $$
= $2; $$
->sign
= -1;
616 case RPC_FC_CHAR
: break
;
617 case RPC_FC_SMALL
: $$
->type
= RPC_FC_USMALL
; break
;
618 case RPC_FC_SHORT
: $$
->type
= RPC_FC_USHORT
; break
;
619 case RPC_FC_LONG
: $$
->type
= RPC_FC_ULONG
; break
;
621 if
(!$$
->ref
) { $$
->ref
= &std_uhyper
; $$
->sign
= 0; }
626 | tUNSIGNED
{ $$
= make_type
(RPC_FC_ULONG
, &std_int
); $$
->sign
= -1; }
627 | tFLOAT
{ $$
= make_type
(RPC_FC_FLOAT
, NULL
); }
628 | tSINGLE
{ $$
= make_type
(RPC_FC_FLOAT
, NULL
); }
629 | tDOUBLE
{ $$
= make_type
(RPC_FC_DOUBLE
, NULL
); }
630 | tBOOLEAN
{ $$
= make_type
(RPC_FC_BYTE
, &std_bool
); /* ? */ }
631 | tERRORSTATUST
{ $$
= make_type
(RPC_FC_ERROR_STATUS_T
, NULL
); }
632 | tHANDLET
{ $$
= make_type
(RPC_FC_BIND_PRIMITIVE
, NULL
); /* ? */ }
639 int_std: tINT
{ $$
= make_type
(RPC_FC_LONG
, &std_int
); } /* win32 only */
640 | tSHORT m_int
{ $$
= make_type
(RPC_FC_SHORT
, NULL
); }
641 | tSMALL
{ $$
= make_type
(RPC_FC_SMALL
, NULL
); }
642 | tLONG m_int
{ $$
= make_type
(RPC_FC_LONG
, NULL
); }
643 | tHYPER m_int
{ $$
= make_type
(RPC_FC_HYPER
, NULL
); }
644 | tINT64
{ $$
= make_type
(RPC_FC_HYPER
, &std_int64
); }
645 | tCHAR
{ $$
= make_type
(RPC_FC_CHAR
, NULL
); }
648 coclass: tCOCLASS aIDENTIFIER
{ $$
= make_class
($2); }
649 | tCOCLASS aKNOWNTYPE
{ $$
= find_type
($2, 0);
650 if
($$
->defined
) yyerror("multiple definition error");
651 if
($$
->kind
!= TKIND_COCLASS
) yyerror("%s was not declared a coclass", $2);
655 coclasshdr: attributes coclass
{ $$
= $2;
657 if
(!parse_only
&& do_header
)
659 if
(!parse_only
&& do_idfile
)
664 coclassdef: coclasshdr
'{' coclass_ints
'}' { $$
= $1;
670 coclass_ints: { $$
= NULL
; }
671 | coclass_ints coclass_int
{ LINK
($2, $1); $$
= $2; }
675 m_attributes interfacedec
{ $$
= make_ifref
($2); $$
->attrs
= $1; }
678 dispinterface: tDISPINTERFACE aIDENTIFIER
{ $$
= get_type
(0, $2, 0); $$
->kind
= TKIND_DISPATCH
; }
679 | tDISPINTERFACE aKNOWNTYPE
{ $$
= get_type
(0, $2, 0); $$
->kind
= TKIND_DISPATCH
; }
682 dispinterfacehdr: attributes dispinterface
{ attr_t
*attrs
;
684 if
($$
->defined
) yyerror("multiple definition error");
685 attrs
= make_attr
(ATTR_DISPINTERFACE
);
688 $$
->ref
= find_type
("IDispatch", 0);
689 if
(!$$
->ref
) yyerror("IDispatch is undefined");
691 if
(!parse_only
&& do_header
) write_forward
($$
);
695 dispint_props: tPROPERTIES
':' { $$
= NULL
; }
696 | dispint_props s_field
';' { LINK
($2, $1); $$
= $2; }
699 dispint_meths: tMETHODS
':' { $$
= NULL
; }
700 | dispint_meths funcdef
';' { LINK
($2, $1); $$
= $2; }
703 dispinterfacedef: dispinterfacehdr
'{'
709 if
(!parse_only
&& do_header
) write_dispinterface
($$
);
710 if
(!parse_only
&& do_idfile
) write_diid
($$
);
712 /* FIXME: not sure how to handle this yet
713 | dispinterfacehdr '{' interface '}' { $$ = $1;
714 if (!parse_only && do_header) write_interface($$);
715 if (!parse_only && do_idfile) write_iid($$);
720 inherit: { $$
= NULL
; }
721 |
':' aKNOWNTYPE
{ $$
= find_type2
($2, 0); }
724 interface: tINTERFACE aIDENTIFIER
{ $$
= get_type
(RPC_FC_IP
, $2, 0); $$
->kind
= TKIND_INTERFACE
; }
725 | tINTERFACE aKNOWNTYPE
{ $$
= get_type
(RPC_FC_IP
, $2, 0); $$
->kind
= TKIND_INTERFACE
; }
728 interfacehdr: attributes interface
{ $$
= $2;
729 if
($$
->defined
) yyerror("multiple definition error");
732 if
(!parse_only
&& do_header
) write_forward
($$
);
736 interfacedef: interfacehdr inherit
737 '{' int_statements
'}' { $$
= $1;
740 if
(!parse_only
&& do_header
) write_interface
($$
);
741 if
(!parse_only
&& do_idfile
) write_iid
($$
);
743 /* MIDL is able to import the definition of a base class from inside the
744 * definition of a derived class, I'll try to support it with this rule */
745 | interfacehdr
':' aIDENTIFIER
746 '{' import int_statements
'}' { $$
= $1;
747 $$
->ref
= find_type2
($3, 0);
748 if
(!$$
->ref
) yyerror("base class '%s' not found in import", $3);
750 if
(!parse_only
&& do_header
) write_interface
($$
);
751 if
(!parse_only
&& do_idfile
) write_iid
($$
);
753 | dispinterfacedef
{ $$
= $1; }
757 interface
';' { $$
= $1; if
(!parse_only
&& do_header
) write_forward
($$
); }
758 | dispinterface
';' { $$
= $1; if
(!parse_only
&& do_header
) write_forward
($$
); }
761 module: tMODULE aIDENTIFIER
{ $$
= make_type
(0, NULL
); $$
->name
= $2; $$
->kind
= TKIND_MODULE
; }
762 | tMODULE aKNOWNTYPE
{ $$
= make_type
(0, NULL
); $$
->name
= $2; $$
->kind
= TKIND_MODULE
; }
765 modulehdr: attributes module
{ $$
= $2;
770 moduledef: modulehdr
'{' int_statements
'}' { $$
= $1;
772 /* FIXME: if (!parse_only && do_header) write_module($$); */
776 p_ident: '*' pident %prec PPTR
{ $$
= $2; $$
->ptr_level
++; }
777 | tCONST p_ident
{ $$
= $2; /* FIXME */ }
782 |
'(' pident
')' { $$
= $2; }
787 | pident_list
',' pident
{ LINK
($3, $1); $$
= $3; }
791 tREF
{ $$
= RPC_FC_RP
; }
792 | tUNIQUE
{ $$
= RPC_FC_UP
; }
793 | tPTR
{ $$
= RPC_FC_FP
; }
796 structdef: tSTRUCT t_ident
'{' fields
'}' { $$
= get_typev
(RPC_FC_STRUCT
, $2, tsSTRUCT
);
797 /* overwrite RPC_FC_STRUCT with a more exact type */
798 $$
->type
= get_struct_type
( $4 );
799 $$
->kind
= TKIND_RECORD
;
807 type: tVOID
{ $$
= make_tref
(NULL
, make_type
(0, NULL
)); }
808 | aKNOWNTYPE
{ $$
= make_tref
($1, find_type
($1, 0)); }
809 | base_type
{ $$
= make_tref
(NULL
, $1); }
810 | tCONST type
{ $$
= uniq_tref
($2); $$
->ref
->is_const
= TRUE
; }
811 | enumdef
{ $$
= make_tref
(NULL
, $1); }
812 | tENUM aIDENTIFIER
{ $$
= make_tref
(NULL
, find_type2
($2, tsENUM
)); }
813 | structdef
{ $$
= make_tref
(NULL
, $1); }
814 | tSTRUCT aIDENTIFIER
{ $$
= make_tref
(NULL
, get_type
(RPC_FC_STRUCT
, $2, tsSTRUCT
)); }
815 | uniondef
{ $$
= make_tref
(NULL
, $1); }
816 | tUNION aIDENTIFIER
{ $$
= make_tref
(NULL
, find_type2
($2, tsUNION
)); }
817 | tSAFEARRAY
'(' type
')' { $$
= make_tref
(NULL
, make_safearray
()); }
820 typedef: tTYPEDEF m_attributes type pident_list
{ typeref_t
*tref
= uniq_tref
($3);
821 $4->tname
= tref
->name
;
825 if
(!parse_only
&& do_header
)
826 write_typedef
($$
, $4);
827 if
(in_typelib
&& $$
->attrs
)
829 reg_types
($$
, $4, 0);
833 uniondef: tUNION t_ident
'{' fields
'}' { $$
= get_typev
(RPC_FC_NON_ENCAPSULATED_UNION
, $2, tsUNION
);
834 $$
->kind
= TKIND_UNION
;
839 tSWITCH
'(' s_field
')'
840 m_ident
'{' cases
'}' { var_t
*u
= $7;
841 $$
= get_typev
(RPC_FC_ENCAPSULATED_UNION
, $2, tsUNION
);
842 $$
->kind
= TKIND_UNION
;
843 if
(!u
) u
= make_var
("tagged_union");
844 u
->type
= make_type
(RPC_FC_NON_ENCAPSULATED_UNION
, NULL
);
845 u
->type
->kind
= TKIND_UNION
;
846 u
->type
->fields
= $9;
847 u
->type
->defined
= TRUE
;
848 LINK
(u
, $5); $$
->fields
= u
;
854 aNUM
{ $$
= MAKELONG
($1, 0); }
855 | aNUM
'.' aNUM
{ $$
= MAKELONG
($1, $3); }
860 static attr_t
*make_attr
(enum attr_type type
)
862 attr_t
*a
= xmalloc
(sizeof
(attr_t
));
869 static attr_t
*make_attrv
(enum attr_type type
, unsigned long val
)
871 attr_t
*a
= xmalloc
(sizeof
(attr_t
));
878 static attr_t
*make_attrp
(enum attr_type type
, void *val
)
880 attr_t
*a
= xmalloc
(sizeof
(attr_t
));
887 static expr_t
*make_expr
(enum expr_type type
)
889 expr_t
*e
= xmalloc
(sizeof
(expr_t
));
898 static expr_t
*make_exprl
(enum expr_type type
, long val
)
900 expr_t
*e
= xmalloc
(sizeof
(expr_t
));
906 /* check for numeric constant */
907 if
(type
== EXPR_NUM || type
== EXPR_HEXNUM || type
== EXPR_TRUEFALSE
) {
908 /* make sure true/false value is valid */
909 assert
(type
!= EXPR_TRUEFALSE || val
== 0 || val
== 1);
916 static expr_t
*make_exprs
(enum expr_type type
, char *val
)
919 e
= xmalloc
(sizeof
(expr_t
));
925 /* check for predefined constants */
926 if
(type
== EXPR_IDENTIFIER
) {
927 var_t
*c
= find_const
(val
, 0);
932 e
->cval
= c
->eval
->cval
;
938 static expr_t
*make_exprt
(enum expr_type type
, typeref_t
*tref
, expr_t
*expr
)
941 e
= xmalloc
(sizeof
(expr_t
));
947 /* check for cast of constant expression */
948 if
(type
== EXPR_SIZEOF
) {
949 switch
(tref
->ref
->type
) {
966 case RPC_FC_ERROR_STATUS_T
:
977 if
(type
== EXPR_CAST
&& expr
->is_const
) {
979 e
->cval
= expr
->cval
;
984 static expr_t
*make_expr1
(enum expr_type type
, expr_t
*expr
)
987 e
= xmalloc
(sizeof
(expr_t
));
993 /* check for compile-time optimization */
994 if
(expr
->is_const
) {
998 e
->cval
= -expr
->cval
;
1001 e
->cval
= ~expr
->cval
;
1004 e
->is_const
= FALSE
;
1011 static expr_t
*make_expr2
(enum expr_type type
, expr_t
*expr1
, expr_t
*expr2
)
1014 e
= xmalloc
(sizeof
(expr_t
));
1018 e
->is_const
= FALSE
;
1020 /* check for compile-time optimization */
1021 if
(expr1
->is_const
&& expr2
->is_const
) {
1025 e
->cval
= expr1
->cval
+ expr2
->cval
;
1028 e
->cval
= expr1
->cval
- expr2
->cval
;
1031 e
->cval
= expr1
->cval
* expr2
->cval
;
1034 e
->cval
= expr1
->cval
/ expr2
->cval
;
1037 e
->cval
= expr1
->cval | expr2
->cval
;
1040 e
->cval
= expr1
->cval
& expr2
->cval
;
1043 e
->cval
= expr1
->cval
<< expr2
->cval
;
1046 e
->cval
= expr1
->cval
>> expr2
->cval
;
1049 e
->is_const
= FALSE
;
1056 static expr_t
*make_expr3
(enum expr_type type
, expr_t
*expr1
, expr_t
*expr2
, expr_t
*expr3
)
1059 e
= xmalloc
(sizeof
(expr_t
));
1064 e
->is_const
= FALSE
;
1066 /* check for compile-time optimization */
1067 if
(expr1
->is_const
&& expr2
->is_const
&& expr3
->is_const
) {
1071 e
->cval
= expr1
->cval ? expr2
->cval
: expr3
->cval
;
1074 e
->is_const
= FALSE
;
1081 static type_t
*make_type
(unsigned char type
, type_t
*ref
)
1083 type_t
*t
= xmalloc
(sizeof
(type_t
));
1085 t
->kind
= TKIND_PRIMITIVE
;
1092 t
->ignore
= parse_only
;
1093 t
->is_const
= FALSE
;
1097 t
->typelib_idx
= -1;
1102 static typeref_t
*make_tref
(char *name
, type_t
*ref
)
1104 typeref_t
*t
= xmalloc
(sizeof
(typeref_t
));
1107 t
->uniq
= ref ?
0 : 1;
1111 static typeref_t
*uniq_tref
(typeref_t
*ref
)
1115 if
(t
->uniq
) return t
;
1116 tp
= make_type
(0, t
->ref
);
1124 static type_t
*type_ref
(typeref_t
*ref
)
1126 type_t
*t
= ref
->ref
;
1127 if
(ref
->name
) free
(ref
->name
);
1132 static void set_type
(var_t
*v
, typeref_t
*ref
, expr_t
*arr
)
1135 v
->tname
= ref
->name
;
1141 static ifref_t
*make_ifref
(type_t
*iface
)
1143 ifref_t
*l
= xmalloc
(sizeof
(ifref_t
));
1150 static var_t
*make_var
(char *name
)
1152 var_t
*v
= xmalloc
(sizeof
(var_t
));
1164 static func_t
*make_func
(var_t
*def
, var_t
*args
)
1166 func_t
*f
= xmalloc
(sizeof
(func_t
));
1169 f
->ignore
= parse_only
;
1175 static type_t
*make_class
(char *name
)
1177 type_t
*c
= make_type
(0, NULL
);
1179 c
->kind
= TKIND_COCLASS
;
1184 static type_t
*make_safearray
(void)
1186 return make_type
(RPC_FC_FP
, find_type
("SAFEARRAY", 0));
1191 static int hash_ident
(const char *name
)
1193 const char *p
= name
;
1195 /* a simple sum hash is probably good enough */
1200 return sum
& (HASHMAX
-1);
1203 /***** type repository *****/
1212 struct rtype
*type_hash
[HASHMAX
];
1214 static type_t
*reg_type
(type_t
*type
, const char *name
, int t
)
1219 yyerror("registering named type without name");
1222 hash
= hash_ident
(name
);
1223 nt
= xmalloc
(sizeof
(struct rtype
));
1227 nt
->next
= type_hash
[hash
];
1228 type_hash
[hash
] = nt
;
1232 /* determine pointer type from attrs */
1233 static unsigned char get_pointer_type
( type_t
*type
)
1236 if
(is_attr
( type
->attrs
, ATTR_STRING
))
1239 while
( t
->type
== 0 && t
->ref
)
1244 return RPC_FC_C_CSTRING
;
1246 return RPC_FC_C_WSTRING
;
1249 t
= get_attrv
( type
->attrs
, ATTR_POINTERTYPE
);
1254 static type_t
*reg_types
(type_t
*type
, var_t
*names
, int t
)
1260 var_t
*next
= NEXT_LINK
(names
);
1263 int cptr
= names
->ptr_level
;
1265 while
(cptr
> ptrc
) {
1266 int t
= get_pointer_type
( cur
);
1267 cur
= ptr
= make_type
(t
, cur
);
1271 while
(cptr
< ptrc
) {
1276 reg_type
(cur
, names
->name
, t
);
1284 static type_t
*find_type
(const char *name
, int t
)
1286 struct rtype
*cur
= type_hash
[hash_ident
(name
)];
1287 while
(cur
&& (cur
->t
!= t || strcmp
(cur
->name
, name
)))
1290 yyerror("type '%s' not found", name
);
1296 static type_t
*find_type2
(char *name
, int t
)
1298 type_t
*tp
= find_type
(name
, t
);
1303 int is_type
(const char *name
)
1305 struct rtype
*cur
= type_hash
[hash_ident
(name
)];
1306 while
(cur
&& (cur
->t || strcmp
(cur
->name
, name
)))
1308 if
(cur
) return TRUE
;
1312 static type_t
*get_type
(unsigned char type
, char *name
, int t
)
1314 struct rtype
*cur
= NULL
;
1317 cur
= type_hash
[hash_ident
(name
)];
1318 while
(cur
&& (cur
->t
!= t || strcmp
(cur
->name
, name
)))
1325 tp
= make_type
(type
, NULL
);
1327 if
(!name
) return tp
;
1328 return reg_type
(tp
, name
, t
);
1331 static type_t
*get_typev
(unsigned char type
, var_t
*name
, int t
)
1338 return get_type
(type
, sname
, t
);
1341 static int get_struct_type
(var_t
*field
)
1343 int has_pointer
= 0;
1344 int has_conformance
= 0;
1345 int has_variance
= 0;
1347 for
(; field
; field
= NEXT_LINK
(field
))
1349 type_t
*t
= field
->type
;
1351 /* get the base type */
1352 while
( (t
->type
== 0) && t
->ref
)
1355 if
(field
->ptr_level
> 0)
1361 if
(is_string_type
(field
->attrs
, 0, field
->array
))
1363 has_conformance
= 1;
1368 if
(is_array_type
(field
->attrs
, 0, field
->array
))
1370 if
(field
->array
&& !field
->array
->is_const
)
1372 has_conformance
= 1;
1373 if
(PREV_LINK
(field
))
1374 yyerror("field '%s' deriving from a conformant array must be the last field in the structure",
1377 if
(is_attr
(field
->attrs
, ATTR_LENGTHIS
))
1384 * RPC_FC_BYTE, RPC_FC_STRUCT, etc
1385 * Simple types don't effect the type of struct.
1386 * A struct containing a simple struct is still a simple struct.
1387 * So long as we can block copy the data, we return RPC_FC_STRUCT.
1389 case
0: /* void pointer */
1399 case RPC_FC_INT3264
:
1400 case RPC_FC_UINT3264
:
1414 has_conformance
= 1;
1415 if
(PREV_LINK
(field
))
1416 yyerror("field '%s' deriving from a conformant array must be the last field in the structure",
1419 case RPC_FC_C_CSTRING
:
1420 case RPC_FC_C_WSTRING
:
1421 has_conformance
= 1;
1426 * Propagate member attributes
1427 * a struct should be at least as complex as its member
1429 case RPC_FC_CVSTRUCT
:
1430 has_conformance
= 1;
1435 case RPC_FC_CPSTRUCT
:
1436 has_conformance
= 1;
1437 if
(PREV_LINK
(field
))
1438 yyerror("field '%s' deriving from a conformant array must be the last field in the structure",
1443 case RPC_FC_CSTRUCT
:
1444 has_conformance
= 1;
1445 if
(PREV_LINK
(field
))
1446 yyerror("field '%s' deriving from a conformant array must be the last field in the structure",
1450 case RPC_FC_PSTRUCT
:
1455 fprintf
(stderr
,"Unknown struct member %s with type (0x%02x)\n",
1456 field
->name
, t
->type
);
1457 /* fallthru - treat it as complex */
1459 /* as soon as we see one of these these members, it's bogus... */
1461 case RPC_FC_ENCAPSULATED_UNION
:
1462 case RPC_FC_NON_ENCAPSULATED_UNION
:
1463 case RPC_FC_TRANSMIT_AS
:
1464 case RPC_FC_REPRESENT_AS
:
1466 case RPC_FC_EMBEDDED_COMPLEX
:
1467 case RPC_FC_BOGUS_STRUCT
:
1468 return RPC_FC_BOGUS_STRUCT
;
1473 return RPC_FC_CVSTRUCT
;
1474 if
( has_conformance
&& has_pointer
)
1475 return RPC_FC_CPSTRUCT
;
1476 if
( has_conformance
)
1477 return RPC_FC_CSTRUCT
;
1479 return RPC_FC_PSTRUCT
;
1480 return RPC_FC_STRUCT
;
1483 /***** constant repository *****/
1488 struct rconst
*next
;
1491 struct rconst
*const_hash
[HASHMAX
];
1493 static var_t
*reg_const
(var_t
*var
)
1498 yyerror("registering constant without name");
1501 hash
= hash_ident
(var
->name
);
1502 nc
= xmalloc
(sizeof
(struct rconst
));
1503 nc
->name
= var
->name
;
1505 nc
->next
= const_hash
[hash
];
1506 const_hash
[hash
] = nc
;
1510 static var_t
*find_const
(char *name
, int f
)
1512 struct rconst
*cur
= const_hash
[hash_ident
(name
)];
1513 while
(cur
&& strcmp
(cur
->name
, name
))
1516 if
(f
) yyerror("constant '%s' not found", name
);
1522 static void write_libid
(const char *name
, const attr_t
*attr
)
1524 const UUID
*uuid
= get_attrp
(attr
, ATTR_UUID
);
1525 write_guid
(idfile
, "LIBID", name
, uuid
);
1528 static void write_clsid
(type_t
*cls
)
1530 const UUID
*uuid
= get_attrp
(cls
->attrs
, ATTR_UUID
);
1531 write_guid
(idfile
, "CLSID", cls
->name
, uuid
);
1534 static void write_diid
(type_t
*iface
)
1536 const UUID
*uuid
= get_attrp
(iface
->attrs
, ATTR_UUID
);
1537 write_guid
(idfile
, "DIID", iface
->name
, uuid
);
1540 static void write_iid
(type_t
*iface
)
1542 const UUID
*uuid
= get_attrp
(iface
->attrs
, ATTR_UUID
);
1543 write_guid
(idfile
, "IID", iface
->name
, uuid
);