2 * Wrc preprocessor syntax analysis
4 * Copyright 1999-2000 Bertho A. Stultiens (BS)
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 * 24-Apr-2000 BS Restructured the lot to fit the new scanner
23 * and reintegrate into the wine-tree.
24 * 01-Jan-2000 BS FIXME: win16 preprocessor calculates with
25 * 16 bit ints and overflows...?
26 * 26-Dec-1999 BS Started this file
46 #define UNARY_OP(r, v, OP) \
49 case cv_sint
: r.val.si
= OP v.val.si
; break
; \
50 case cv_uint
: r.val.ui
= OP v.val.ui
; break
; \
51 case cv_slong
: r.val.sl
= OP v.val.sl
; break
; \
52 case cv_ulong
: r.val.ul
= OP v.val.ul
; break
; \
53 case cv_sll
: r.val.sll
= OP v.val.sll
; break
; \
54 case cv_ull
: r.val.ull
= OP v.val.ull
; break
; \
57 #define cv_signed(v) ((v.type & FLAG_SIGNED) != 0)
59 #define BIN_OP_INT(r, v1, v2, OP) \
61 if
(cv_signed
(v1
) && cv_signed
(v2
)) \
62 r.val.si
= v1.val.si OP v2.val.si
; \
63 else if
(cv_signed
(v1
) && !cv_signed
(v2
)) \
64 r.val.si
= v1.val.si OP v2.val.ui
; \
65 else if
(!cv_signed
(v1
) && cv_signed
(v2
)) \
66 r.val.ui
= v1.val.ui OP v2.val.si
; \
68 r.val.ui
= v1.val.ui OP v2.val.ui
;
70 #define BIN_OP_LONG(r, v1, v2, OP) \
72 if
(cv_signed
(v1
) && cv_signed
(v2
)) \
73 r.val.sl
= v1.val.sl OP v2.val.sl
; \
74 else if
(cv_signed
(v1
) && !cv_signed
(v2
)) \
75 r.val.sl
= v1.val.sl OP v2.val.ul
; \
76 else if
(!cv_signed
(v1
) && cv_signed
(v2
)) \
77 r.val.ul
= v1.val.ul OP v2.val.sl
; \
79 r.val.ul
= v1.val.ul OP v2.val.ul
;
81 #define BIN_OP_LONGLONG(r, v1, v2, OP) \
83 if
(cv_signed
(v1
) && cv_signed
(v2
)) \
84 r.val.sll
= v1.val.sll OP v2.val.sll
; \
85 else if
(cv_signed
(v1
) && !cv_signed
(v2
)) \
86 r.val.sll
= v1.val.sll OP v2.val.ull
; \
87 else if
(!cv_signed
(v1
) && cv_signed
(v2
)) \
88 r.val.ull
= v1.val.ull OP v2.val.sll
; \
90 r.val.ull
= v1.val.ull OP v2.val.ull
;
92 #define BIN_OP(r, v1, v2, OP) \
93 switch
(v1.type
& SIZE_MASK
) \
95 case SIZE_INT
: BIN_OP_INT
(r
, v1
, v2
, OP
); break
; \
96 case SIZE_LONG
: BIN_OP_LONG
(r
, v1
, v2
, OP
); break
; \
97 case SIZE_LONGLONG
: BIN_OP_LONGLONG
(r
, v1
, v2
, OP
); break
; \
98 default
: internal_error
(__FILE__
, __LINE__
, "Invalid type indicator (0x%04x)", v1.type
); \
105 static int boolean
(cval_t
*v
);
106 static void promote_equal_size
(cval_t
*v1
, cval_t
*v2
);
107 static void cast_to_sint
(cval_t
*v
);
108 static void cast_to_uint
(cval_t
*v
);
109 static void cast_to_slong
(cval_t
*v
);
110 static void cast_to_ulong
(cval_t
*v
);
111 static void cast_to_sll
(cval_t
*v
);
112 static void cast_to_ull
(cval_t
*v
);
113 static marg_t
*new_marg
(char *str
, def_arg_t type
);
114 static marg_t
*add_new_marg
(char *str
, def_arg_t type
);
115 static int marg_index
(char *id
);
116 static mtext_t
*new_mtext
(char *str
, int idx
, def_exp_t type
);
117 static mtext_t
*combine_mtext
(mtext_t
*tail
, mtext_t
*mtp
);
118 static char *merge_text
(char *s1
, char *s2
);
123 static marg_t
**macro_args
; /* Macro parameters array while parsing */
124 static int nmacro_args
;
143 %token tIF tIFDEF tIFNDEF tELSE tELIF tENDIF tDEFINED tNL
144 %token tINCLUDE tLINE tGCCLINE tERROR tWARNING tPRAGMA tPPIDENT
145 %token tUNDEF tMACROEND tCONCAT tELIPSIS tSTRINGIZE
146 %token
<cptr
> tIDENT tLITERAL tMACRO tDEFINE
147 %token
<cptr
> tDQSTRING tSQSTRING tIQSTRING
150 %token
<ulong
> tULONG
151 %token
<slong
> tSLONG
152 %token
<ull
> tULONGLONG
153 %token
<sll
> tSLONGLONG
154 %token
<cptr
> tRCINCLUDEPATH
163 %left
'<' tLTE
'>' tGTE
164 %left tLSHIFT tRSHIFT
170 %type
<marg
> emargs margs
171 %type
<mtext
> opt_mtexts mtexts mtext
172 %type
<sint
> allmargs
173 %type
<cptr
> opt_text text
176 **************************************************************************
177 * The parser starts here
178 **************************************************************************
183 pp_file
: /* Empty */
184 | pp_file preprocessor
188 : tINCLUDE tDQSTRING tNL
{ do_include
($2, 1); }
189 | tINCLUDE tIQSTRING tNL
{ do_include
($2, 0); }
190 | tIF pp_expr tNL
{ next_if_state
(boolean
(&$2)); }
191 | tIFDEF tIDENT tNL
{ next_if_state
(pplookup
($2) != NULL
); free
($2); }
192 | tIFNDEF tIDENT tNL
{
193 int t
= pplookup
($2) == NULL
;
194 if
(include_state
== 0 && t
&& !seen_junk
)
198 include_ifdepth
= get_if_depth
();
200 else if
(include_state
!= 1)
208 if
(debuglevel
& DEBUGLEVEL_PPMSG
)
209 fprintf
(stderr
, "tIFNDEF: %s:%d: include_state=%d, include_ppp='%s', include_ifdepth=%d\n", input_name
, line_number
, include_state
, include_ppp
, include_ifdepth
);
211 | tELIF pp_expr tNL
{
212 if_state_t s
= pop_if
();
220 push_if
(boolean
(&$2) ? if_true
: if_false
);
227 pperror
("#elif cannot follow #else");
229 internal_error
(__FILE__
, __LINE__
, "Invalid if_state (%d) in #elif directive", s
);
233 if_state_t s
= pop_if
();
237 push_if
(if_elsefalse
);
243 push_if
(if_elsetrue
);
250 pperror
("#else clause already defined");
252 internal_error
(__FILE__
, __LINE__
, "Invalid if_state (%d) in #else directive", s
);
257 if
(include_ifdepth
== get_if_depth
() && include_state
== 1)
262 else if
(include_state
!= 1)
266 if
(debuglevel
& DEBUGLEVEL_PPMSG
)
267 fprintf
(stderr
, "tENDIF: %s:%d: include_state=%d, include_ppp='%s', include_ifdepth=%d\n", input_name
, line_number
, include_state
, include_ppp
, include_ifdepth
);
269 | tUNDEF tIDENT tNL
{ del_define
($2); free
($2); }
270 | tDEFINE opt_text tNL
{ add_define
($1, $2); }
271 | tMACRO res_arg allmargs tMACROEND opt_mtexts tNL
{
272 add_macro
($1, macro_args
, nmacro_args
, $5);
274 | tLINE tSINT tDQSTRING tNL
{ fprintf
(ppout
, "# %d %s\n", $2 , $3); free
($3); }
275 | tGCCLINE tSINT tDQSTRING tNL
{ fprintf
(ppout
, "# %d %s\n", $2 , $3); free
($3); }
276 | tGCCLINE tSINT tDQSTRING tSINT tNL
277 { fprintf
(ppout
, "# %d %s %d\n", $2, $3, $4); free
($3); }
278 | tGCCLINE tSINT tDQSTRING tSINT tSINT tNL
279 { fprintf
(ppout
, "# %d %s %d %d\n", $2 ,$3, $4, $5); free
($3); }
280 | tGCCLINE tSINT tDQSTRING tSINT tSINT tSINT tNL
281 { fprintf
(ppout
, "# %d %s %d %d %d\n", $2 ,$3 ,$4 ,$5, $6); free
($3); }
282 | tGCCLINE tSINT tDQSTRING tSINT tSINT tSINT tSINT tNL
283 { fprintf
(ppout
, "# %d %s %d %d %d %d\n", $2 ,$3 ,$4 ,$5, $6, $7); free
($3); }
284 | tGCCLINE tNL
/* The null-token */
285 | tERROR opt_text tNL
{ pperror
("#error directive: '%s'", $2); if
($2) free
($2); }
286 | tWARNING opt_text tNL
{ ppwarning
("#warning directive: '%s'", $2); if
($2) free
($2); }
287 | tPRAGMA opt_text tNL
{ if
(pedantic
) ppwarning
("#pragma ignored (arg: '%s')", $2); if
($2) free
($2); }
288 | tPPIDENT opt_text tNL
{ if
(pedantic
) ppwarning
("#ident ignored (arg: '%s')", $2); if
($2) free
($2); }
289 | tRCINCLUDE tRCINCLUDEPATH
{
290 int nl
=strlen
($2) +3;
291 char *fn
=xmalloc
(nl
);
292 snprintf
(fn
,nl
,"\"%s\"",$2);
296 | tRCINCLUDE tDQSTRING
{
302 opt_text: /* Empty */ { $$
= NULL
; }
306 text
: tLITERAL
{ $$
= $1; }
307 | tDQSTRING
{ $$
= $1; }
308 | tSQSTRING
{ $$
= $1; }
309 | text tLITERAL
{ $$
= merge_text
($1, $2); }
310 | text tDQSTRING
{ $$
= merge_text
($1, $2); }
311 | text tSQSTRING
{ $$
= merge_text
($1, $2); }
314 res_arg
: /* Empty */ { macro_args
= NULL
; nmacro_args
= 0; }
317 allmargs: /* Empty */ { $$
= 0; macro_args
= NULL
; nmacro_args
= 0; }
318 | emargs
{ $$
= nmacro_args
; }
321 emargs
: margs
{ $$
= $1; }
322 | margs
',' tELIPSIS
{ $$
= add_new_marg
(NULL
, arg_list
); nmacro_args
*= -1; }
325 margs
: margs
',' tIDENT
{ $$
= add_new_marg
($3, arg_single
); }
326 | tIDENT
{ $$
= add_new_marg
($1, arg_single
); }
330 : /* Empty */ { $$
= NULL
; }
332 for
($$
= $1; $$
&& $$
->prev
; $$
= $$
->prev
)
337 mtexts
: mtext
{ $$
= $1; }
338 | mtexts mtext
{ $$
= combine_mtext
($1, $2); }
341 mtext
: tLITERAL
{ $$
= new_mtext
($1, 0, exp_text
); }
342 | tDQSTRING
{ $$
= new_mtext
($1, 0, exp_text
); }
343 | tSQSTRING
{ $$
= new_mtext
($1, 0, exp_text
); }
344 | tCONCAT
{ $$
= new_mtext
(NULL
, 0, exp_concat
); }
345 | tSTRINGIZE tIDENT
{
346 int mat
= marg_index
($2);
348 pperror
("Stringification identifier must be an argument parameter");
349 $$
= new_mtext
(NULL
, mat
, exp_stringize
);
352 int mat
= marg_index
($1);
354 $$
= new_mtext
(NULL
, mat
, exp_subst
);
356 $$
= new_mtext
($1, 0, exp_text
);
360 pp_expr
: tSINT
{ $$.type
= cv_sint
; $$.val.si
= $1; }
361 | tUINT
{ $$.type
= cv_uint
; $$.val.ui
= $1; }
362 | tSLONG
{ $$.type
= cv_slong
; $$.val.sl
= $1; }
363 | tULONG
{ $$.type
= cv_ulong
; $$.val.ul
= $1; }
364 | tSLONGLONG
{ $$.type
= cv_sll
; $$.val.sl
= $1; }
365 | tULONGLONG
{ $$.type
= cv_ull
; $$.val.ul
= $1; }
366 | tDEFINED tIDENT
{ $$.type
= cv_sint
; $$.val.si
= pplookup
($2) != NULL
; }
367 | tDEFINED
'(' tIDENT
')' { $$.type
= cv_sint
; $$.val.si
= pplookup
($3) != NULL
; }
368 | tIDENT
{ $$.type
= cv_sint
; $$.val.si
= 0; }
369 | pp_expr tLOGOR pp_expr
{ $$.type
= cv_sint
; $$.val.si
= boolean
(&$1) || boolean
(&$3); }
370 | pp_expr tLOGAND pp_expr
{ $$.type
= cv_sint
; $$.val.si
= boolean
(&$1) && boolean
(&$3); }
371 | pp_expr tEQ pp_expr
{ promote_equal_size
(&$1, &$3); BIN_OP
($$
, $1, $3, ==) }
372 | pp_expr tNE pp_expr
{ promote_equal_size
(&$1, &$3); BIN_OP
($$
, $1, $3, !=) }
373 | pp_expr
'<' pp_expr
{ promote_equal_size
(&$1, &$3); BIN_OP
($$
, $1, $3, <) }
374 | pp_expr
'>' pp_expr
{ promote_equal_size
(&$1, &$3); BIN_OP
($$
, $1, $3, >) }
375 | pp_expr tLTE pp_expr
{ promote_equal_size
(&$1, &$3); BIN_OP
($$
, $1, $3, <=) }
376 | pp_expr tGTE pp_expr
{ promote_equal_size
(&$1, &$3); BIN_OP
($$
, $1, $3, >=) }
377 | pp_expr
'+' pp_expr
{ promote_equal_size
(&$1, &$3); BIN_OP
($$
, $1, $3, +) }
378 | pp_expr
'-' pp_expr
{ promote_equal_size
(&$1, &$3); BIN_OP
($$
, $1, $3, -) }
379 | pp_expr
'^' pp_expr
{ promote_equal_size
(&$1, &$3); BIN_OP
($$
, $1, $3, ^
) }
380 | pp_expr
'&' pp_expr
{ promote_equal_size
(&$1, &$3); BIN_OP
($$
, $1, $3, &) }
381 | pp_expr
'|' pp_expr
{ promote_equal_size
(&$1, &$3); BIN_OP
($$
, $1, $3, |
) }
382 | pp_expr
'*' pp_expr
{ promote_equal_size
(&$1, &$3); BIN_OP
($$
, $1, $3, *) }
383 | pp_expr
'/' pp_expr
{ promote_equal_size
(&$1, &$3); BIN_OP
($$
, $1, $3, /) }
384 | pp_expr tLSHIFT pp_expr
{ promote_equal_size
(&$1, &$3); BIN_OP
($$
, $1, $3, <<) }
385 | pp_expr tRSHIFT pp_expr
{ promote_equal_size
(&$1, &$3); BIN_OP
($$
, $1, $3, >>) }
386 |
'+' pp_expr
{ $$
= $2; }
387 |
'-' pp_expr
{ UNARY_OP
($$
, $2, -) }
388 |
'~' pp_expr
{ UNARY_OP
($$
, $2, ~
) }
389 |
'!' pp_expr
{ $$.type
= cv_sint
; $$.val.si
= !boolean
(&$2); }
390 |
'(' pp_expr
')' { $$
= $2; }
391 | pp_expr
'?' pp_expr
':' pp_expr
{ $$
= boolean
(&$1) ?
$3 : $5; }
397 **************************************************************************
399 **************************************************************************
402 static void cast_to_sint
(cval_t
*v
)
408 case cv_slong
: v
->val.si
= v
->val.sl
; break
;
409 case cv_ulong
: v
->val.si
= v
->val.ul
; break
;
410 case cv_sll
: v
->val.si
= v
->val.sll
; break
;
411 case cv_ull
: v
->val.si
= v
->val.ull
; break
;
416 static void cast_to_uint
(cval_t
*v
)
422 case cv_slong
: v
->val.ui
= v
->val.sl
; break
;
423 case cv_ulong
: v
->val.ui
= v
->val.ul
; break
;
424 case cv_sll
: v
->val.ui
= v
->val.sll
; break
;
425 case cv_ull
: v
->val.ui
= v
->val.ull
; break
;
430 static void cast_to_slong
(cval_t
*v
)
434 case cv_sint
: v
->val.sl
= v
->val.si
; break
;
435 case cv_uint
: v
->val.sl
= v
->val.ui
; break
;
436 case cv_slong
: break
;
437 case cv_ulong
: break
;
438 case cv_sll
: v
->val.sl
= v
->val.sll
; break
;
439 case cv_ull
: v
->val.sl
= v
->val.ull
; break
;
444 static void cast_to_ulong
(cval_t
*v
)
448 case cv_sint
: v
->val.ul
= v
->val.si
; break
;
449 case cv_uint
: v
->val.ul
= v
->val.ui
; break
;
450 case cv_slong
: break
;
451 case cv_ulong
: break
;
452 case cv_sll
: v
->val.ul
= v
->val.sll
; break
;
453 case cv_ull
: v
->val.ul
= v
->val.ull
; break
;
458 static void cast_to_sll
(cval_t
*v
)
462 case cv_sint
: v
->val.sll
= v
->val.si
; break
;
463 case cv_uint
: v
->val.sll
= v
->val.ui
; break
;
464 case cv_slong
: v
->val.sll
= v
->val.sl
; break
;
465 case cv_ulong
: v
->val.sll
= v
->val.ul
; break
;
472 static void cast_to_ull
(cval_t
*v
)
476 case cv_sint
: v
->val.ull
= v
->val.si
; break
;
477 case cv_uint
: v
->val.ull
= v
->val.ui
; break
;
478 case cv_slong
: v
->val.ull
= v
->val.sl
; break
;
479 case cv_ulong
: v
->val.ull
= v
->val.ul
; break
;
487 static void promote_equal_size
(cval_t
*v1
, cval_t
*v2
)
489 #define cv_sizeof(v) ((int)(v->type & SIZE_MASK))
490 int s1
= cv_sizeof
(v1
);
491 int s2
= cv_sizeof
(v2
);
500 case cv_sint
: cast_to_sint
(v2
); break
;
501 case cv_uint
: cast_to_uint
(v2
); break
;
502 case cv_slong
: cast_to_slong
(v2
); break
;
503 case cv_ulong
: cast_to_ulong
(v2
); break
;
504 case cv_sll
: cast_to_sll
(v2
); break
;
505 case cv_ull
: cast_to_ull
(v2
); break
;
512 case cv_sint
: cast_to_sint
(v1
); break
;
513 case cv_uint
: cast_to_uint
(v1
); break
;
514 case cv_slong
: cast_to_slong
(v1
); break
;
515 case cv_ulong
: cast_to_ulong
(v1
); break
;
516 case cv_sll
: cast_to_sll
(v1
); break
;
517 case cv_ull
: cast_to_ull
(v1
); break
;
523 static int boolean
(cval_t
*v
)
527 case cv_sint
: return v
->val.si
!= (int)0;
528 case cv_uint
: return v
->val.ui
!= (unsigned int)0;
529 case cv_slong
: return v
->val.sl
!= (long)0;
530 case cv_ulong
: return v
->val.ul
!= (unsigned long)0;
531 case cv_sll
: return v
->val.sll
!= (wrc_sll_t
)0;
532 case cv_ull
: return v
->val.ull
!= (wrc_ull_t
)0;
537 static marg_t
*new_marg
(char *str
, def_arg_t type
)
539 marg_t
*ma
= (marg_t
*)xmalloc
(sizeof
(marg_t
));
545 static marg_t
*add_new_marg
(char *str
, def_arg_t type
)
547 marg_t
*ma
= new_marg
(str
, type
);
549 macro_args
= (marg_t
**)xrealloc
(macro_args
, nmacro_args
* sizeof
(macro_args
[0]));
550 macro_args
[nmacro_args
-1] = ma
;
554 static int marg_index
(char *id
)
557 for
(t
= 0; t
< nmacro_args
; t
++)
559 if
(!strcmp
(id
, macro_args
[t
]->arg
))
562 return t
< nmacro_args ? t
: -1;
565 static mtext_t
*new_mtext
(char *str
, int idx
, def_exp_t type
)
567 mtext_t
*mt
= (mtext_t
*)xmalloc
(sizeof
(mtext_t
));
569 mt
->subst.argidx
= idx
;
571 mt
->subst.text
= str
;
576 static mtext_t
*combine_mtext
(mtext_t
*tail
, mtext_t
*mtp
)
584 if
(tail
->type
== exp_text
&& mtp
->type
== exp_text
)
586 tail
->subst.text
= xrealloc
(tail
->subst.text
, strlen
(tail
->subst.text
)+strlen
(mtp
->subst.text
)+1);
587 strcat
(tail
->subst.text
, mtp
->subst.text
);
588 free
(mtp
->subst.text
);
593 if
(tail
->type
== exp_concat
&& mtp
->type
== exp_concat
)
599 if
(tail
->type
== exp_concat
&& mtp
->type
== exp_text
)
601 int len
= strlen
(mtp
->subst.text
);
604 /* FIXME: should delete space from head of string */
605 if
(isspace
(mtp
->subst.text
[len
-1] & 0xff))
606 mtp
->subst.text
[--len
] = '\0';
613 free
(mtp
->subst.text
);
619 if
(tail
->type
== exp_text
&& mtp
->type
== exp_concat
)
621 int len
= strlen
(tail
->subst.text
);
624 if
(isspace
(tail
->subst.text
[len
-1] & 0xff))
625 tail
->subst.text
[--len
] = '\0';
632 mtp
->prev
= tail
->prev
;
633 mtp
->next
= tail
->next
;
635 tail
->prev
->next
= mtp
;
636 free
(tail
->subst.text
);
648 static char *merge_text
(char *s1
, char *s2
)
652 s1
= xrealloc
(s1
, l1
+l2
+1);
653 memcpy
(s1
+l1
, s2
, l2
+1);