?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- Handle "? :" conditionals.
[wine.git] / tools / widl / parser.y
blob9a85a3ba2036fbfd8336886bce98b51eea05ffef
1 %{
2 /*
3 * IDL Compiler
4 *
5 * Copyright 2002 Ove Kaaven
6 *
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.
11 *
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.
16 *
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 #include "config.h"
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <stdarg.h>
27 #include <assert.h>
28 #include <ctype.h>
29 #include <string.h>
30 #ifdef HAVE_ALLOCA_H
31 #include <alloca.h>
32 #endif
33
34 #include "widl.h"
35 #include "utils.h"
36 #include "parser.h"
37 #include "header.h"
38 #include "proxy.h"
39 #include "typelib.h"
40
41 #if defined(YYBYACC)
42 /* Berkeley yacc (byacc) doesn't seem to know about these */
43 /* Some *BSD supplied versions do define these though */
44 # ifndef YYEMPTY
45 # define YYEMPTY (-1) /* Empty lookahead value of yychar */
46 # endif
47 # ifndef YYLEX
48 # define YYLEX yylex()
49 # endif
50
51 #elif defined(YYBISON)
52 /* Bison was used for original development */
53 /* #define YYEMPTY -2 */
54 /* #define YYLEX yylex() */
55
56 #else
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... */
63 # endif
64 #endif
65
66 static attr_t *make_attr(enum attr_type type);
67 static attr_t *make_attrv(enum attr_type type, DWORD val);
68 static attr_t *make_attrp(enum attr_type type, void *val);
69 static expr_t *make_expr(enum expr_type type);
70 static expr_t *make_exprl(enum expr_type type, long val);
71 static expr_t *make_exprs(enum expr_type type, char *val);
72 static expr_t *make_exprt(enum expr_type type, typeref_t *tref, expr_t *expr);
73 static expr_t *make_expr1(enum expr_type type, expr_t *expr);
74 static expr_t *make_expr2(enum expr_type type, expr_t *exp1, expr_t *exp2);
75 static expr_t *make_expr3(enum expr_type type, expr_t *exp1, expr_t *exp2, expr_t *exp3);
76 static type_t *make_type(BYTE type, type_t *ref);
77 static typeref_t *make_tref(char *name, type_t *ref);
78 static typeref_t *uniq_tref(typeref_t *ref);
79 static type_t *type_ref(typeref_t *ref);
80 static void set_type(var_t *v, typeref_t *ref, expr_t *arr);
81 static ifref_t *make_ifref(type_t *iface);
82 static var_t *make_var(char *name);
83 static func_t *make_func(var_t *def, var_t *args);
84 static class_t *make_class(char *name);
85
86 static type_t *reg_type(type_t *type, char *name, int t);
87 static type_t *reg_types(type_t *type, var_t *names, int t);
88 static type_t *find_type(char *name, int t);
89 static type_t *find_type2(char *name, int t);
90 static type_t *get_type(BYTE type, char *name, int t);
91 static type_t *get_typev(BYTE type, var_t *name, int t);
92
93 static var_t *reg_const(var_t *var);
94 static var_t *find_const(char *name, int f);
95
96 #define tsENUM 1
97 #define tsSTRUCT 2
98 #define tsUNION 3
99
100 static type_t std_bool = { "boolean" };
101 static type_t std_int = { "int" };
102 static type_t std_int64 = { "__int64" };
103 static type_t std_uhyper = { "MIDL_uhyper" };
104
105 %}
106 %union {
107 attr_t *attr;
108 expr_t *expr;
109 type_t *type;
110 typeref_t *tref;
111 var_t *var;
112 func_t *func;
113 ifref_t *ifref;
114 class_t *clas;
115 char *str;
116 UUID *uuid;
117 unsigned int num;
118 }
119
120 %token <str> aIDENTIFIER
121 %token <str> aKNOWNTYPE
122 %token <num> aNUM aHEXNUM
123 %token <str> aSTRING
124 %token <uuid> aUUID
125 %token aEOF
126 %token SHL SHR
127 %token tAGGREGATABLE tALLOCATE tAPPOBJECT tARRAYS tASYNC tASYNCUUID
128 %token tAUTOHANDLE tBINDABLE tBOOLEAN tBROADCAST tBYTE tBYTECOUNT
129 %token tCALLAS tCALLBACK tCASE tCDECL tCHAR tCOCLASS tCODE tCOMMSTATUS
130 %token tCONST tCONTEXTHANDLE tCONTEXTHANDLENOSERIALIZE
131 %token tCONTEXTHANDLESERIALIZE tCONTROL tCPPQUOTE
132 %token tDEFAULT
133 %token tDISPINTERFACE
134 %token tDLLNAME tDOUBLE tDUAL
135 %token tENTRY tENUM tERRORSTATUST
136 %token tEXTERN
137 %token tFLOAT
138 %token tHANDLE
139 %token tHANDLET
140 %token tHELPSTRING
141 %token tHYPER tID tIDEMPOTENT
142 %token tIIDIS
143 %token tIMPORT tIMPORTLIB
144 %token tIN tINCLUDE tINLINE
145 %token tINPUTSYNC
146 %token tINT tINT64
147 %token tINTERFACE
148 %token tLENGTHIS tLIBRARY
149 %token tLOCAL
150 %token tLONG
151 %token tMETHODS
152 %token tMODULE
153 %token tOBJECT tODL tOLEAUTOMATION
154 %token tOUT
155 %token tPOINTERDEFAULT
156 %token tPROPERTIES
157 %token tPUBLIC
158 %token tREADONLY tREF
159 %token tRETVAL
160 %token tSHORT
161 %token tSIGNED
162 %token tSIZEIS tSIZEOF
163 %token tSOURCE
164 %token tSTDCALL
165 %token tSTRING tSTRUCT
166 %token tSWITCH tSWITCHIS tSWITCHTYPE
167 %token tTYPEDEF
168 %token tUNION
169 %token tUNIQUE
170 %token tUNSIGNED
171 %token tUUID
172 %token tV1ENUM
173 %token tVERSION
174 %token tVOID
175 %token tWCHAR tWIREMARSHAL
176
177 /* used in attr_t */
178 %token tPOINTERTYPE
179
180 %type <attr> m_attributes attributes attrib_list attribute
181 %type <expr> m_exprs /* exprs expr_list */ m_expr expr expr_list_const expr_const
182 %type <expr> array array_list
183 %type <type> inherit interface interfacehdr interfacedef interfacedec
184 %type <type> dispinterface dispinterfacehdr dispinterfacedef
185 %type <type> module modulehdr moduledef
186 %type <type> base_type int_std
187 %type <type> enumdef structdef typedef uniondef
188 %type <ifref> gbl_statements coclass_ints coclass_int
189 %type <tref> type
190 %type <var> m_args no_args args arg
191 %type <var> fields field s_field cases case enums enum_list enum constdef externdef
192 %type <var> m_ident t_ident ident p_ident pident pident_list
193 %type <var> dispint_props
194 %type <func> funcdef int_statements
195 %type <func> dispint_meths
196 %type <clas> coclass coclasshdr coclassdef
197 %type <num> pointer_type version
198 %type <str> libraryhdr
199
200 %left ','
201 %left '|'
202 %left '&'
203 %left '-' '+'
204 %left '*' '/'
205 %left SHL SHR
206 %right '~'
207 %right CAST
208 %right PPTR
209 %right NEG
210
211 %%
212
213 input: gbl_statements { write_proxies($1); }
214 ;
215
216 gbl_statements: { $$ = NULL; }
217 | gbl_statements interfacedec { $$ = $1; }
218 | gbl_statements interfacedef { $$ = make_ifref($2); LINK($$, $1); }
219 | gbl_statements coclassdef { $$ = $1; add_coclass($2); }
220 | gbl_statements moduledef { $$ = $1; add_module($2); }
221 | gbl_statements librarydef { $$ = $1; }
222 | gbl_statements statement { $$ = $1; }
223 ;
224
225 imp_statements: {}
226 | imp_statements interfacedec { if (!parse_only) add_interface($2); }
227 | imp_statements interfacedef { if (!parse_only) add_interface($2); }
228 | imp_statements coclassdef { if (!parse_only) add_coclass($2); }
229 | imp_statements moduledef { if (!parse_only) add_module($2); }
230 | imp_statements statement {}
231 ;
232
233 int_statements: { $$ = NULL; }
234 | int_statements funcdef ';' { $$ = $2; LINK($$, $1); }
235 | int_statements statement { $$ = $1; }
236 ;
237
238 statement: ';' {}
239 | constdef ';' { if (!parse_only) { write_constdef($1); } }
240 | cppquote {}
241 | enumdef ';' { if (!parse_only) { write_type(header, $1, NULL, NULL); fprintf(header, ";\n\n"); } }
242 | externdef ';' { if (!parse_only) { write_externdef($1); } }
243 | import {}
244 | structdef ';' { if (!parse_only) { write_type(header, $1, NULL, NULL); fprintf(header, ";\n\n"); } }
245 | typedef ';' {}
246 | uniondef ';' { if (!parse_only) { write_type(header, $1, NULL, NULL); fprintf(header, ";\n\n"); } }
247 ;
248
249 cppquote: tCPPQUOTE '(' aSTRING ')' { if (!parse_only) fprintf(header, "%s\n", $3); }
250 ;
251 import_start: tIMPORT aSTRING ';' { assert(yychar == YYEMPTY);
252 if (!do_import($2)) yychar = aEOF; }
253 ;
254 import: import_start imp_statements aEOF {}
255 ;
256
257 libraryhdr: tLIBRARY aIDENTIFIER { $$ = $2; }
258 ;
259 library_start: attributes libraryhdr '{' { start_typelib($2, $1); }
260 ;
261 librarydef: library_start imp_statements '}' { end_typelib(); }
262 ;
263
264 m_args: { $$ = NULL; }
265 | args
266 ;
267
268 no_args: tVOID { $$ = NULL; }
269 ;
270
271 args: arg
272 | args ',' arg { LINK($3, $1); $$ = $3; }
273 | no_args
274 ;
275
276 /* split into two rules to get bison to resolve a tVOID conflict */
277 arg: attributes type pident array { $$ = $3;
278 set_type($$, $2, $4);
279 $$->attrs = $1;
280 }
281 | type pident array { $$ = $2;
282 set_type($$, $1, $3);
283 }
284 | attributes type pident '(' m_args ')' { $$ = $3;
285 $$->ptr_level--;
286 set_type($$, $2, NULL);
287 $$->attrs = $1;
288 $$->args = $5;
289 }
290 | type pident '(' m_args ')' { $$ = $2;
291 $$->ptr_level--;
292 set_type($$, $1, NULL);
293 $$->args = $4;
294 }
295 ;
296
297 array: { $$ = NULL; }
298 | '[' array_list ']' { $$ = $2; }
299 | '[' '*' ']' { $$ = make_expr(EXPR_VOID); }
300 ;
301
302 array_list: m_expr /* size of first dimension is optional */
303 | array_list ',' expr { LINK($3, $1); $$ = $3; }
304 | array_list ']' '[' expr { LINK($4, $1); $$ = $4; }
305 ;
306
307 m_attributes: { $$ = NULL; }
308 | attributes
309 ;
310
311 attributes:
312 '[' attrib_list ']' { $$ = $2; }
313 ;
314
315 attrib_list: attribute
316 | attrib_list ',' attribute { LINK($3, $1); $$ = $3; }
317 | attrib_list ']' '[' attribute { LINK($4, $1); $$ = $4; }
318 ;
319
320 attribute:
321 tASYNC { $$ = make_attr(ATTR_ASYNC); }
322 | tCALLAS '(' ident ')' { $$ = make_attrp(ATTR_CALLAS, $3); }
323 | tCASE '(' expr_list_const ')' { $$ = make_attrp(ATTR_CASE, $3); }
324 | tCONTEXTHANDLE { $$ = make_attrv(ATTR_CONTEXTHANDLE, 0); }
325 | tCONTEXTHANDLENOSERIALIZE { $$ = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_DONT_SERIALIZE */ }
326 | tCONTEXTHANDLESERIALIZE { $$ = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_SERIALIZE */ }
327 | tDEFAULT { $$ = make_attr(ATTR_DEFAULT); }
328 | tDLLNAME '(' aSTRING ')' { $$ = make_attrp(ATTR_DLLNAME, $3); }
329 | tDUAL { $$ = make_attr(ATTR_DUAL); }
330 | tENTRY '(' aSTRING ')' { $$ = make_attrp(ATTR_ENTRY_STRING, $3); }
331 | tENTRY '(' expr_const ')' { $$ = make_attrp(ATTR_ENTRY_ORDINAL, $3); }
332 | tHANDLE { $$ = make_attr(ATTR_HANDLE); }
333 | tHELPSTRING '(' aSTRING ')' { $$ = make_attrp(ATTR_HELPSTRING, $3); }
334 | tID '(' expr_const ')' { $$ = make_attrp(ATTR_ID, $3); }
335 | tIDEMPOTENT { $$ = make_attr(ATTR_IDEMPOTENT); }
336 | tIIDIS '(' ident ')' { $$ = make_attrp(ATTR_IIDIS, $3); }
337 | tIN { $$ = make_attr(ATTR_IN); }
338 | tINPUTSYNC { $$ = make_attr(ATTR_INPUTSYNC); }
339 | tLENGTHIS '(' m_exprs ')' { $$ = make_attrp(ATTR_LENGTHIS, $3); }
340 | tLOCAL { $$ = make_attr(ATTR_LOCAL); }
341 | tOBJECT { $$ = make_attr(ATTR_OBJECT); }
342 | tODL { $$ = make_attr(ATTR_ODL); }
343 | tOLEAUTOMATION { $$ = make_attr(ATTR_OLEAUTOMATION); }
344 | tOUT { $$ = make_attr(ATTR_OUT); }
345 | tPOINTERDEFAULT '(' pointer_type ')' { $$ = make_attrv(ATTR_POINTERDEFAULT, $3); }
346 | tPUBLIC { $$ = make_attr(ATTR_PUBLIC); }
347 | tREADONLY { $$ = make_attr(ATTR_READONLY); }
348 | tRETVAL { $$ = make_attr(ATTR_RETVAL); }
349 | tSIZEIS '(' m_exprs ')' { $$ = make_attrp(ATTR_SIZEIS, $3); }
350 | tSOURCE { $$ = make_attr(ATTR_SOURCE); }
351 | tSTRING { $$ = make_attr(ATTR_STRING); }
352 | tSWITCHIS '(' expr ')' { $$ = make_attrp(ATTR_SWITCHIS, $3); }
353 | tSWITCHTYPE '(' type ')' { $$ = make_attrp(ATTR_SWITCHTYPE, type_ref($3)); }
354 | tUUID '(' aUUID ')' { $$ = make_attrp(ATTR_UUID, $3); }
355 | tV1ENUM { $$ = make_attr(ATTR_V1ENUM); }
356 | tVERSION '(' version ')' { $$ = make_attrv(ATTR_VERSION, $3); }
357 | tWIREMARSHAL '(' type ')' { $$ = make_attrp(ATTR_WIREMARSHAL, type_ref($3)); }
358 | pointer_type { $$ = make_attrv(ATTR_POINTERTYPE, $1); }
359 ;
360
361 callconv:
362 | tSTDCALL
363 ;
364
365 cases: { $$ = NULL; }
366 | cases case { if ($2) { LINK($2, $1); $$ = $2; }
367 else { $$ = $1; }
368 }
369 ;
370
371 case: tCASE expr ':' field { attr_t *a = make_attrp(ATTR_CASE, $2);
372 $$ = $4; if (!$$) $$ = make_var(NULL);
373 LINK(a, $$->attrs); $$->attrs = a;
374 }
375 | tDEFAULT ':' field { attr_t *a = make_attr(ATTR_DEFAULT);
376 $$ = $3; if (!$$) $$ = make_var(NULL);
377 LINK(a, $$->attrs); $$->attrs = a;
378 }
379 ;
380
381 constdef: tCONST type ident '=' expr_const { $$ = reg_const($3);
382 set_type($$, $2, NULL);
383 $$->eval = $5;
384 $$->lval = $5->cval;
385 }
386 ;
387
388 enums: { $$ = NULL; }
389 | enum_list ',' { $$ = $1; }
390 | enum_list
391 ;
392
393 enum_list: enum
394 | enum_list ',' enum { LINK($3, $1); $$ = $3;
395 if ($1 && !$3->eval)
396 $3->lval = $1->lval + 1;
397 }
398 ;
399
400 enum: ident '=' expr_const { $$ = reg_const($1);
401 $$->eval = $3;
402 $$->lval = $3->cval;
403 }
404 | ident { $$ = reg_const($1);
405 $$->lval = 0; /* default for first enum entry */
406 }
407 ;
408
409 enumdef: tENUM t_ident '{' enums '}' { $$ = get_typev(RPC_FC_ENUM16, $2, tsENUM);
410 $$->fields = $4;
411 $$->defined = TRUE;
412 }
413 ;
414
415 m_exprs: m_expr
416 | m_exprs ',' m_expr { LINK($3, $1); $$ = $3; }
417 ;
418
419 /*
420 exprs: { $$ = make_expr(EXPR_VOID); }
421 | expr_list
422 ;
423
424 expr_list: expr
425 | expr_list ',' expr { LINK($3, $1); $$ = $3; }
426 ;
427 */
428
429 m_expr: { $$ = make_expr(EXPR_VOID); }
430 | expr
431 ;
432
433 expr: aNUM { $$ = make_exprl(EXPR_NUM, $1); }
434 | aHEXNUM { $$ = make_exprl(EXPR_HEXNUM, $1); }
435 | aIDENTIFIER { $$ = make_exprs(EXPR_IDENTIFIER, $1); }
436 | expr '?' expr ':' expr { $$ = make_expr3(EXPR_COND, $1, $3, $5); }
437 | expr '|' expr { $$ = make_expr2(EXPR_OR , $1, $3); }
438 | expr '&' expr { $$ = make_expr2(EXPR_AND, $1, $3); }
439 | expr '+' expr { $$ = make_expr2(EXPR_ADD, $1, $3); }
440 | expr '-' expr { $$ = make_expr2(EXPR_SUB, $1, $3); }
441 | expr '*' expr { $$ = make_expr2(EXPR_MUL, $1, $3); }
442 | expr '/' expr { $$ = make_expr2(EXPR_DIV, $1, $3); }
443 | expr SHL expr { $$ = make_expr2(EXPR_SHL, $1, $3); }
444 | expr SHR expr { $$ = make_expr2(EXPR_SHR, $1, $3); }
445 | '~' expr { $$ = make_expr1(EXPR_NOT, $2); }
446 | '-' expr %prec NEG { $$ = make_expr1(EXPR_NEG, $2); }
447 | '*' expr %prec PPTR { $$ = make_expr1(EXPR_PPTR, $2); }
448 | '(' type ')' expr %prec CAST { $$ = make_exprt(EXPR_CAST, $2, $4); }
449 | tSIZEOF '(' type ')' { $$ = make_exprt(EXPR_SIZEOF, $3, NULL); }
450 | '(' expr ')' { $$ = $2; }
451 ;
452
453 expr_list_const: expr_const
454 | expr_list_const ',' expr_const { LINK($3, $1); $$ = $3; }
455 ;
456
457 expr_const: expr { $$ = $1;
458 if (!$$->is_const) yyerror("expression is not constant\n");
459 }
460 ;
461
462 externdef: tEXTERN tCONST type ident { $$ = $4;
463 set_type($$, $3, NULL);
464 }
465 ;
466
467 fields: { $$ = NULL; }
468 | fields field { if ($2) { LINK($2, $1); $$ = $2; }
469 else { $$ = $1; }
470 }
471 ;
472
473 field: s_field ';' { $$ = $1; }
474 | m_attributes uniondef ';' { $$ = make_var(NULL); $$->type = $2; $$->attrs = $1; }
475 | attributes ';' { $$ = make_var(NULL); $$->attrs = $1; }
476 | ';' { $$ = NULL; }
477 ;
478
479 s_field: m_attributes type pident array { $$ = $3; set_type($$, $2, $4); $$->attrs = $1; }
480 ;
481
482 funcdef:
483 m_attributes type callconv pident
484 '(' m_args ')' { set_type($4, $2, NULL);
485 $4->attrs = $1;
486 $$ = make_func($4, $6);
487 }
488 ;
489
490 m_ident: { $$ = NULL; }
491 | ident
492 ;
493
494 t_ident: { $$ = NULL; }
495 | aIDENTIFIER { $$ = make_var($1); }
496 | aKNOWNTYPE { $$ = make_var($1); }
497 ;
498
499 ident: aIDENTIFIER { $$ = make_var($1); }
500 /* some "reserved words" used in attributes are also used as field names in some MS IDL files */
501 | tID { $$ = make_var($<str>1); }
502 | tRETVAL { $$ = make_var($<str>1); }
503 | tVERSION { $$ = make_var($<str>1); }
504 ;
505
506 base_type: tBYTE { $$ = make_type(RPC_FC_BYTE, NULL); }
507 | tWCHAR { $$ = make_type(RPC_FC_WCHAR, NULL); }
508 | int_std
509 | tSIGNED int_std { $$ = $2; $$->sign = 1; }
510 | tUNSIGNED int_std { $$ = $2; $$->sign = -1;
511 switch ($$->type) {
512 case RPC_FC_SMALL: $$->type = RPC_FC_USMALL; break;
513 case RPC_FC_SHORT: $$->type = RPC_FC_USHORT; break;
514 case RPC_FC_LONG: $$->type = RPC_FC_ULONG; break;
515 case RPC_FC_HYPER:
516 if (!$$->ref) { $$->ref = &std_uhyper; $$->sign = 0; }
517 break;
518 default: break;
519 }
520 }
521 | tFLOAT { $$ = make_type(RPC_FC_FLOAT, NULL); }
522 | tDOUBLE { $$ = make_type(RPC_FC_DOUBLE, NULL); }
523 | tBOOLEAN { $$ = make_type(RPC_FC_BYTE, &std_bool); /* ? */ }
524 | tERRORSTATUST { $$ = make_type(RPC_FC_ERROR_STATUS_T, NULL); }
525 | tHANDLET { $$ = make_type(RPC_FC_BIND_PRIMITIVE, NULL); /* ? */ }
526 ;
527
528 m_int:
529 | tINT
530 ;
531
532 int_std: tINT { $$ = make_type(RPC_FC_LONG, &std_int); } /* win32 only */
533 | tSHORT m_int { $$ = make_type(RPC_FC_SHORT, NULL); }
534 | tLONG m_int { $$ = make_type(RPC_FC_LONG, NULL); }
535 | tHYPER m_int { $$ = make_type(RPC_FC_HYPER, NULL); }
536 | tINT64 { $$ = make_type(RPC_FC_HYPER, &std_int64); }
537 | tCHAR { $$ = make_type(RPC_FC_CHAR, NULL); }
538 ;
539
540 coclass: tCOCLASS aIDENTIFIER { $$ = make_class($2); }
541 | tCOCLASS aKNOWNTYPE { $$ = make_class($2); }
542 ;
543
544 coclasshdr: attributes coclass { $$ = $2;
545 $$->attrs = $1;
546 }
547 ;
548
549 coclassdef: coclasshdr '{' coclass_ints '}' { $$ = $1;
550 $$->ifaces = $3;
551 }
552 ;
553
554 coclass_ints: { $$ = NULL; }
555 | coclass_ints coclass_int { LINK($2, $1); $$ = $2; }
556 ;
557
558 coclass_int:
559 m_attributes interfacedec { $$ = make_ifref($2); $$->attrs = $1; }
560 ;
561
562 dispinterface: tDISPINTERFACE aIDENTIFIER { $$ = get_type(0, $2, 0); }
563 | tDISPINTERFACE aKNOWNTYPE { $$ = get_type(0, $2, 0); }
564 ;
565
566 dispinterfacehdr: attributes dispinterface { $$ = $2;
567 if ($$->defined) yyerror("multiple definition error\n");
568 $$->attrs = $1;
569 /* $$->attrs = make_attr(ATTR_DISPINTERFACE); */
570 /* LINK($$->attrs, $1); */
571 $$->ref = find_type("IDispatch", 0);
572 if (!$$->ref) yyerror("IDispatch is undefined\n");
573 $$->defined = TRUE;
574 if (!parse_only) write_forward($$);
575 }
576 ;
577
578 dispint_props: tPROPERTIES ':' { $$ = NULL; }
579 | dispint_props s_field ';' { LINK($2, $1); $$ = $2; }
580 ;
581
582 dispint_meths: tMETHODS ':' { $$ = NULL; }
583 | dispint_meths funcdef ';' { LINK($2, $1); $$ = $2; }
584 ;
585
586 dispinterfacedef: dispinterfacehdr '{'
587 dispint_props
588 dispint_meths
589 '}' { $$ = $1;
590 $$->fields = $3;
591 $$->funcs = $4;
592 if (!parse_only) write_interface($$);
593 }
594 /* FIXME: not sure how to handle this yet
595 | dispinterfacehdr '{' interface '}' { $$ = $1;
596 if (!parse_only) write_interface($$);
597 }
598 */
599 ;
600
601 inherit: { $$ = NULL; }
602 | ':' aKNOWNTYPE { $$ = find_type2($2, 0); }
603 ;
604
605 interface: tINTERFACE aIDENTIFIER { $$ = get_type(RPC_FC_IP, $2, 0); }
606 | tINTERFACE aKNOWNTYPE { $$ = get_type(RPC_FC_IP, $2, 0); }
607 ;
608
609 interfacehdr: attributes interface { $$ = $2;
610 if ($$->defined) yyerror("multiple definition error\n");
611 $$->attrs = $1;
612 $$->defined = TRUE;
613 if (!parse_only) write_forward($$);
614 }
615 ;
616
617 interfacedef: interfacehdr inherit
618 '{' int_statements '}' { $$ = $1;
619 $$->ref = $2;
620 $$->funcs = $4;
621 if (!parse_only) write_interface($$);
622 }
623 /* MIDL is able to import the definition of a base class from inside the
624 * definition of a derived class, I'll try to support it with this rule */
625 | interfacehdr ':' aIDENTIFIER
626 '{' import int_statements '}' { $$ = $1;
627 $$->ref = find_type2($3, 0);
628 if (!$$->ref) yyerror("base class %s not found in import\n", $3);
629 $$->funcs = $6;
630 if (!parse_only) write_interface($$);
631 }
632 | dispinterfacedef { $$ = $1; }
633 ;
634
635 interfacedec:
636 interface ';' { $$ = $1; if (!parse_only) write_forward($$); }
637 | dispinterface ';' { $$ = $1; if (!parse_only) write_forward($$); }
638 ;
639
640 module: tMODULE aIDENTIFIER { $$ = make_type(0, NULL); $$->name = $2; }
641 | tMODULE aKNOWNTYPE { $$ = make_type(0, NULL); $$->name = $2; }
642 ;
643
644 modulehdr: attributes module { $$ = $2;
645 $$->attrs = $1;
646 }
647 ;
648
649 moduledef: modulehdr '{' int_statements '}' { $$ = $1;
650 $$->funcs = $3;
651 /* FIXME: if (!parse_only) write_module($$); */
652 }
653 ;
654
655 p_ident: '*' pident %prec PPTR { $$ = $2; $$->ptr_level++; }
656 | tCONST p_ident { $$ = $2; /* FIXME */ }
657 ;
658
659 pident: ident
660 | p_ident
661 | '(' pident ')' { $$ = $2; }
662 ;
663
664 pident_list:
665 pident
666 | pident_list ',' pident { LINK($3, $1); $$ = $3; }
667 ;
668
669 pointer_type:
670 tREF { $$ = RPC_FC_RP; }
671 | tUNIQUE { $$ = RPC_FC_UP; }
672 ;
673
674 structdef: tSTRUCT t_ident '{' fields '}' { $$ = get_typev(RPC_FC_STRUCT, $2, tsSTRUCT);
675 $$->fields = $4;
676 $$->defined = TRUE;
677 }
678 ;
679
680 type: tVOID { $$ = make_tref(NULL, make_type(0, NULL)); }
681 | aKNOWNTYPE { $$ = make_tref($1, find_type($1, 0)); }
682 | base_type { $$ = make_tref(NULL, $1); }
683 | tCONST type { $$ = uniq_tref($2); $$->ref->is_const = TRUE; }
684 | enumdef { $$ = make_tref(NULL, $1); }
685 | tENUM aIDENTIFIER { $$ = make_tref(NULL, find_type2($2, tsENUM)); }
686 | structdef { $$ = make_tref(NULL, $1); }
687 | tSTRUCT aIDENTIFIER { $$ = make_tref(NULL, get_type(RPC_FC_STRUCT, $2, tsSTRUCT)); }
688 | uniondef { $$ = make_tref(NULL, $1); }
689 | tUNION aIDENTIFIER { $$ = make_tref(NULL, find_type2($2, tsUNION)); }
690 ;
691
692 typedef: tTYPEDEF m_attributes type pident_list { typeref_t *tref = uniq_tref($3);
693 $4->tname = tref->name;
694 tref->name = NULL;
695 $$ = type_ref(tref);
696 $$->attrs = $2;
697 if (!parse_only) write_typedef($$, $4);
698 reg_types($$, $4, 0);
699 }
700 ;
701
702 uniondef: tUNION t_ident '{' fields '}' { $$ = get_typev(RPC_FC_NON_ENCAPSULATED_UNION, $2, tsUNION);
703 $$->fields = $4;
704 $$->defined = TRUE;
705 }
706 | tUNION t_ident
707 tSWITCH '(' s_field ')'
708 m_ident '{' cases '}' { var_t *u = $7;
709 $$ = get_typev(RPC_FC_ENCAPSULATED_UNION, $2, tsUNION);
710 if (!u) u = make_var("tagged_union");
711 u->type = make_type(RPC_FC_NON_ENCAPSULATED_UNION, NULL);
712 u->type->fields = $9;
713 u->type->defined = TRUE;
714 LINK(u, $5); $$->fields = u;
715 $$->defined = TRUE;
716 }
717 ;
718
719 version:
720 aNUM { $$ = MAKELONG($1, 0); }
721 | aNUM '.' aNUM { $$ = MAKELONG($1, $3); }
722 ;
723
724 %%
725
726 static attr_t *make_attr(enum attr_type type)
727 {
728 attr_t *a = xmalloc(sizeof(attr_t));
729 a->type = type;
730 a->u.ival = 0;
731 INIT_LINK(a);
732 return a;
733 }
734
735 static attr_t *make_attrv(enum attr_type type, DWORD val)
736 {
737 attr_t *a = xmalloc(sizeof(attr_t));
738 a->type = type;
739 a->u.ival = val;
740 INIT_LINK(a);
741 return a;
742 }
743
744 static attr_t *make_attrp(enum attr_type type, void *val)
745 {
746 attr_t *a = xmalloc(sizeof(attr_t));
747 a->type = type;
748 a->u.pval = val;
749 INIT_LINK(a);
750 return a;
751 }
752
753 static expr_t *make_expr(enum expr_type type)
754 {
755 expr_t *e = xmalloc(sizeof(expr_t));
756 e->type = type;
757 e->ref = NULL;
758 e->u.lval = 0;
759 e->is_const = FALSE;
760 INIT_LINK(e);
761 return e;
762 }
763
764 static expr_t *make_exprl(enum expr_type type, long val)
765 {
766 expr_t *e = xmalloc(sizeof(expr_t));
767 e->type = type;
768 e->ref = NULL;
769 e->u.lval = val;
770 e->is_const = FALSE;
771 INIT_LINK(e);
772 /* check for numeric constant */
773 if (type == EXPR_NUM || type == EXPR_HEXNUM) {
774 e->is_const = TRUE;
775 e->cval = val;
776 }
777 return e;
778 }
779
780 static expr_t *make_exprs(enum expr_type type, char *val)
781 {
782 expr_t *e;
783 e = xmalloc(sizeof(expr_t));
784 e->type = type;
785 e->ref = NULL;
786 e->u.sval = val;
787 e->is_const = FALSE;
788 INIT_LINK(e);
789 /* check for predefined constants */
790 if (type == EXPR_IDENTIFIER) {
791 var_t *c = find_const(val, 0);
792 if (c) {
793 e->u.sval = c->name;
794 free(val);
795 e->is_const = TRUE;
796 e->cval = c->lval;
797 }
798 }
799 return e;
800 }
801
802 static expr_t *make_exprt(enum expr_type type, typeref_t *tref, expr_t *expr)
803 {
804 expr_t *e;
805 e = xmalloc(sizeof(expr_t));
806 e->type = type;
807 e->ref = expr;
808 e->u.tref = tref;
809 e->is_const = FALSE;
810 INIT_LINK(e);
811 /* check for cast of constant expression */
812 if (type == EXPR_CAST && expr->is_const) {
813 e->is_const = TRUE;
814 e->cval = expr->cval;
815 }
816 return e;
817 }
818
819 static expr_t *make_expr1(enum expr_type type, expr_t *expr)
820 {
821 expr_t *e;
822 e = xmalloc(sizeof(expr_t));
823 e->type = type;
824 e->ref = expr;
825 e->u.lval = 0;
826 e->is_const = FALSE;
827 INIT_LINK(e);
828 /* check for compile-time optimization */
829 if (expr->is_const) {
830 e->is_const = TRUE;
831 switch (type) {
832 case EXPR_NEG:
833 e->cval = -expr->cval;
834 break;
835 case EXPR_NOT:
836 e->cval = ~expr->cval;
837 break;
838 default:
839 e->is_const = FALSE;
840 break;
841 }
842 }
843 return e;
844 }
845
846 static expr_t *make_expr2(enum expr_type type, expr_t *expr1, expr_t *expr2)
847 {
848 expr_t *e;
849 e = xmalloc(sizeof(expr_t));
850 e->type = type;
851 e->ref = expr1;
852 e->u.ext = expr2;
853 e->is_const = FALSE;
854 INIT_LINK(e);
855 /* check for compile-time optimization */
856 if (expr1->is_const && expr2->is_const) {
857 e->is_const = TRUE;
858 switch (type) {
859 case EXPR_ADD:
860 e->cval = expr1->cval + expr2->cval;
861 break;
862 case EXPR_SUB:
863 e->cval = expr1->cval - expr2->cval;
864 break;
865 case EXPR_MUL:
866 e->cval = expr1->cval * expr2->cval;
867 break;
868 case EXPR_DIV:
869 e->cval = expr1->cval / expr2->cval;
870 break;
871 case EXPR_OR:
872 e->cval = expr1->cval | expr2->cval;
873 break;
874 case EXPR_AND:
875 e->cval = expr1->cval & expr2->cval;
876 break;
877 case EXPR_SHL:
878 e->cval = expr1->cval << expr2->cval;
879 break;
880 case EXPR_SHR:
881 e->cval = expr1->cval >> expr2->cval;
882 break;
883 default:
884 e->is_const = FALSE;
885 break;
886 }
887 }
888 return e;
889 }
890
891 static expr_t *make_expr3(enum expr_type type, expr_t *expr1, expr_t *expr2, expr_t *expr3)
892 {
893 expr_t *e;
894 e = xmalloc(sizeof(expr_t));
895 e->type = type;
896 e->ref = expr1;
897 e->u.ext = expr2;
898 e->ext2 = expr3;
899 e->is_const = FALSE;
900 INIT_LINK(e);
901 /* check for compile-time optimization */
902 if (expr1->is_const && expr2->is_const && expr3->is_const) {
903 e->is_const = TRUE;
904 switch (type) {
905 case EXPR_COND:
906 e->cval = expr1->cval ? expr2->cval : expr3->cval;
907 break;
908 default:
909 e->is_const = FALSE;
910 break;
911 }
912 }
913 return e;
914 }
915
916 static type_t *make_type(BYTE type, type_t *ref)
917 {
918 type_t *t = xmalloc(sizeof(type_t));
919 t->name = NULL;
920 t->type = type;
921 t->ref = ref;
922 t->rname = NULL;
923 t->attrs = NULL;
924 t->funcs = NULL;
925 t->fields = NULL;
926 t->ignore = parse_only;
927 t->is_const = FALSE;
928 t->sign = 0;
929 t->defined = FALSE;
930 t->written = FALSE;
931 INIT_LINK(t);
932 return t;
933 }
934
935 static typeref_t *make_tref(char *name, type_t *ref)
936 {
937 typeref_t *t = xmalloc(sizeof(typeref_t));
938 t->name = name;
939 t->ref = ref;
940 t->uniq = ref ? 0 : 1;
941 return t;
942 }
943
944 static typeref_t *uniq_tref(typeref_t *ref)
945 {
946 typeref_t *t = ref;
947 type_t *tp;
948 if (t->uniq) return t;
949 tp = make_type(0, t->ref);
950 tp->name = t->name;
951 t->name = NULL;
952 t->ref = tp;
953 t->uniq = 1;
954 return t;
955 }
956
957 static type_t *type_ref(typeref_t *ref)
958 {
959 type_t *t = ref->ref;
960 if (ref->name) free(ref->name);
961 free(ref);
962 return t;
963 }
964
965 static void set_type(var_t *v, typeref_t *ref, expr_t *arr)
966 {
967 v->type = ref->ref;
968 v->tname = ref->name;
969 ref->name = NULL;
970 free(ref);
971 v->array = arr;
972 }
973
974 static ifref_t *make_ifref(type_t *iface)
975 {
976 ifref_t *l = xmalloc(sizeof(ifref_t));
977 l->iface = iface;
978 l->attrs = NULL;
979 INIT_LINK(l);
980 return l;
981 }
982
983 static var_t *make_var(char *name)
984 {
985 var_t *v = xmalloc(sizeof(var_t));
986 v->name = name;
987 v->ptr_level = 0;
988 v->type = NULL;
989 v->tname = NULL;
990 v->attrs = NULL;
991 v->array = NULL;
992 v->eval = NULL;
993 v->lval = 0;
994 INIT_LINK(v);
995 return v;
996 }
997
998 static func_t *make_func(var_t *def, var_t *args)
999 {
1000 func_t *f = xmalloc(sizeof(func_t));
1001 f->def = def;
1002 f->args = args;
1003 f->ignore = parse_only;
1004 f->idx = -1;
1005 INIT_LINK(f);
1006 return f;
1007 }
1008
1009 static class_t *make_class(char *name)
1010 {
1011 class_t *c = xmalloc(sizeof(class_t));
1012 c->name = name;
1013 c->attrs = NULL;
1014 c->ifaces = NULL;
1015 INIT_LINK(c);
1016 return c;
1017 }
1018
1019 #define HASHMAX 64
1020
1021 static int hash_ident(const char *name)
1022 {
1023 const char *p = name;
1024 int sum = 0;
1025 /* a simple sum hash is probably good enough */
1026 while (*p) {
1027 sum += *p;
1028 p++;
1029 }
1030 return sum & (HASHMAX-1);
1031 }
1032
1033 /***** type repository *****/
1034
1035 struct rtype {
1036 char *name;
1037 type_t *type;
1038 int t;
1039 struct rtype *next;
1040 };
1041
1042 struct rtype *type_hash[HASHMAX];
1043
1044 static type_t *reg_type(type_t *type, char *name, int t)
1045 {
1046 struct rtype *nt;
1047 int hash;
1048 if (!name) {
1049 yyerror("registering named type without name\n");
1050 return type;
1051 }
1052 hash = hash_ident(name);
1053 nt = xmalloc(sizeof(struct rtype));
1054 nt->name = name;
1055 nt->type = type;
1056 nt->t = t;
1057 nt->next = type_hash[hash];
1058 type_hash[hash] = nt;
1059 return type;
1060 }
1061
1062 static type_t *reg_types(type_t *type, var_t *names, int t)
1063 {
1064 type_t *ptr = type;
1065 int ptrc = 0;
1066
1067 while (names) {
1068 var_t *next = NEXT_LINK(names);
1069 if (names->name) {
1070 type_t *cur = ptr;
1071 int cptr = names->ptr_level;
1072 if (cptr > ptrc) {
1073 while (cptr > ptrc) {
1074 cur = ptr = make_type(RPC_FC_FP, cur); /* FIXME: pointer type from attrs? */
1075 ptrc++;
1076 }
1077 } else {
1078 while (cptr < ptrc) {
1079 cur = cur->ref;
1080 cptr++;
1081 }
1082 }
1083 reg_type(cur, names->name, t);
1084 }
1085 free(names);
1086 names = next;
1087 }
1088 return type;
1089 }
1090
1091 static type_t *find_type(char *name, int t)
1092 {
1093 struct rtype *cur = type_hash[hash_ident(name)];
1094 while (cur && (cur->t != t || strcmp(cur->name, name)))
1095 cur = cur->next;
1096 if (!cur) {
1097 yyerror("type %s not found\n", name);
1098 return NULL;
1099 }
1100 return cur->type;
1101 }
1102
1103 static type_t *find_type2(char *name, int t)
1104 {
1105 type_t *tp = find_type(name, t);
1106 free(name);
1107 return tp;
1108 }
1109
1110 int is_type(const char *name)
1111 {
1112 struct rtype *cur = type_hash[hash_ident(name)];
1113 while (cur && (cur->t || strcmp(cur->name, name)))
1114 cur = cur->next;
1115 if (cur) return TRUE;
1116 return FALSE;
1117 }
1118
1119 static type_t *get_type(BYTE type, char *name, int t)
1120 {
1121 struct rtype *cur = NULL;
1122 type_t *tp;
1123 if (name) {
1124 cur = type_hash[hash_ident(name)];
1125 while (cur && (cur->t != t || strcmp(cur->name, name)))
1126 cur = cur->next;
1127 }
1128 if (cur) {
1129 free(name);
1130 return cur->type;
1131 }
1132 tp = make_type(type, NULL);
1133 tp->name = name;
1134 if (!name) return tp;
1135 return reg_type(tp, name, t);
1136 }
1137
1138 static type_t *get_typev(BYTE type, var_t *name, int t)
1139 {
1140 char *sname = NULL;
1141 if (name) {
1142 sname = name->name;
1143 free(name);
1144 }
1145 return get_type(type, sname, t);
1146 }
1147
1148 /***** constant repository *****/
1149
1150 struct rconst {
1151 char *name;
1152 var_t *var;
1153 struct rconst *next;
1154 };
1155
1156 struct rconst *const_hash[HASHMAX];
1157
1158 static var_t *reg_const(var_t *var)
1159 {
1160 struct rconst *nc;
1161 int hash;
1162 if (!var->name) {
1163 yyerror("registering constant without name\n");
1164 return var;
1165 }
1166 hash = hash_ident(var->name);
1167 nc = xmalloc(sizeof(struct rconst));
1168 nc->name = var->name;
1169 nc->var = var;
1170 nc->next = const_hash[hash];
1171 const_hash[hash] = nc;
1172 return var;
1173 }
1174
1175 static var_t *find_const(char *name, int f)
1176 {
1177 struct rconst *cur = const_hash[hash_ident(name)];
1178 while (cur && strcmp(cur->name, name))
1179 cur = cur->next;
1180 if (!cur) {
1181 if (f) yyerror("constant %s not found\n", name);
1182 return NULL;
1183 }
1184 return cur->var;
1185 }
Windows API implementation