|
1 /****************************************************************************** |
|
2 * |
|
3 * |
|
4 * |
|
5 * |
|
6 * Copyright (C) 1997-2007 by Dimitri van Heesch. |
|
7 * |
|
8 * Permission to use, copy, modify, and distribute this software and its |
|
9 * documentation under the terms of the GNU General Public License is hereby |
|
10 * granted. No representations are made about the suitability of this software |
|
11 * for any purpose. It is provided "as is" without express or implied warranty. |
|
12 * See the GNU General Public License for more details. |
|
13 * |
|
14 * Documents produced by Doxygen are derivative works derived from the |
|
15 * input used in their production; they are not affected by this license. |
|
16 * |
|
17 */ |
|
18 |
|
19 %{ |
|
20 |
|
21 #include "cppvalue.h" |
|
22 #include "constexp.h" |
|
23 #include "message.h" |
|
24 |
|
25 #if defined(_MSC_VER) |
|
26 #define MSDOS |
|
27 #endif |
|
28 |
|
29 #define YYSTYPE CPPValue |
|
30 |
|
31 #include <stdio.h> |
|
32 #include <stdlib.h> |
|
33 |
|
34 int cppExpYYerror(const char *s) |
|
35 { |
|
36 warn(g_constExpFileName,g_constExpLineNr, |
|
37 "Problem during constant expression evaluation: %s",s); |
|
38 return 0; |
|
39 } |
|
40 |
|
41 int cppExpYYlex(); |
|
42 |
|
43 %} |
|
44 |
|
45 %token TOK_QUESTIONMARK |
|
46 %token TOK_COLON |
|
47 %token TOK_OR |
|
48 %token TOK_AND |
|
49 %token TOK_BITWISEOR |
|
50 %token TOK_BITWISEXOR |
|
51 %token TOK_AMPERSAND |
|
52 %token TOK_NOTEQUAL |
|
53 %token TOK_EQUAL |
|
54 %token TOK_LESSTHAN |
|
55 %token TOK_GREATERTHAN |
|
56 %token TOK_LESSTHANOREQUALTO |
|
57 %token TOK_GREATERTHANOREQUALTO |
|
58 %token TOK_SHIFTLEFT |
|
59 %token TOK_SHIFTRIGHT |
|
60 %token TOK_PLUS |
|
61 %token TOK_MINUS |
|
62 %token TOK_STAR |
|
63 %token TOK_DIVIDE |
|
64 %token TOK_MOD |
|
65 %token TOK_TILDE |
|
66 %token TOK_NOT |
|
67 %token TOK_LPAREN |
|
68 %token TOK_RPAREN |
|
69 %token TOK_OCTALINT |
|
70 %token TOK_DECIMALINT |
|
71 %token TOK_HEXADECIMALINT |
|
72 %token TOK_CHARACTER |
|
73 %token TOK_FLOAT |
|
74 |
|
75 %% |
|
76 |
|
77 start: constant_expression |
|
78 { g_resultValue = $1; return 0; } |
|
79 ; |
|
80 |
|
81 constant_expression: logical_or_expression |
|
82 { $$ = $1; } |
|
83 | logical_or_expression |
|
84 TOK_QUESTIONMARK logical_or_expression |
|
85 TOK_COLON logical_or_expression |
|
86 { |
|
87 bool c = ($1.isInt() ? ((long)$1 != 0) : ((double)$1 != 0.0)); |
|
88 $$ = c ? $3 : $5; |
|
89 } |
|
90 ; |
|
91 |
|
92 logical_or_expression: logical_and_expression |
|
93 { $$ = $1; } |
|
94 | logical_or_expression TOK_OR logical_and_expression |
|
95 { |
|
96 $$ = CPPValue( (long)((long)$1 || (long)$3) ); |
|
97 } |
|
98 ; |
|
99 |
|
100 logical_and_expression: inclusive_or_expression |
|
101 { $$ = $1; } |
|
102 | logical_and_expression TOK_AND inclusive_or_expression |
|
103 { |
|
104 $$ = CPPValue( (long)((long)$1 && (long)$3) ); |
|
105 } |
|
106 ; |
|
107 |
|
108 inclusive_or_expression: exclusive_or_expression |
|
109 { $$ = $1; } |
|
110 | inclusive_or_expression TOK_BITWISEOR |
|
111 exclusive_or_expression |
|
112 { |
|
113 $$ = CPPValue( (long)$1 | (long)$3 ); |
|
114 } |
|
115 ; |
|
116 |
|
117 exclusive_or_expression: and_expression |
|
118 { $$ = $1; } |
|
119 | exclusive_or_expression TOK_BITWISEXOR and_expression |
|
120 { |
|
121 $$ = CPPValue( (long)$1 ^ (long)$3 ); |
|
122 } |
|
123 ; |
|
124 |
|
125 and_expression: equality_expression |
|
126 { $$ = $1; } |
|
127 | and_expression TOK_AMPERSAND equality_expression |
|
128 { |
|
129 $$ = CPPValue( (long)$1 & (long)$3 ); |
|
130 } |
|
131 ; |
|
132 |
|
133 equality_expression: relational_expression |
|
134 { $$ = $1; } |
|
135 | equality_expression TOK_EQUAL relational_expression |
|
136 { |
|
137 $$ = CPPValue( (long)((double)$1 == (double)$3) ); |
|
138 } |
|
139 | equality_expression TOK_NOTEQUAL relational_expression |
|
140 { |
|
141 $$ = CPPValue( (long)((double)$1 != (double)$3) ); |
|
142 } |
|
143 ; |
|
144 |
|
145 relational_expression: shift_expression |
|
146 { $$ = $1; } |
|
147 | relational_expression TOK_LESSTHAN shift_expression |
|
148 { |
|
149 $$ = CPPValue( (long)((double)$1 < (double)$3) ); |
|
150 } |
|
151 | relational_expression TOK_GREATERTHAN shift_expression |
|
152 { |
|
153 $$ = CPPValue( (long)((double)$1 > (double)$3) ); |
|
154 } |
|
155 | relational_expression TOK_LESSTHANOREQUALTO |
|
156 shift_expression |
|
157 { |
|
158 $$ = CPPValue( (long)((double)$1 <= (double)$3) ); |
|
159 } |
|
160 | relational_expression TOK_GREATERTHANOREQUALTO |
|
161 shift_expression |
|
162 { |
|
163 $$ = CPPValue( (long)((double)$1 >= (double)$3) ); |
|
164 } |
|
165 ; |
|
166 |
|
167 shift_expression: additive_expression |
|
168 { $$ = $1; } |
|
169 | shift_expression TOK_SHIFTLEFT additive_expression |
|
170 { |
|
171 $$ = CPPValue( (long)$1 << (long)$3 ); |
|
172 } |
|
173 | shift_expression TOK_SHIFTRIGHT additive_expression |
|
174 { |
|
175 $$ = CPPValue( (long)$1 >> (long)$3 ); |
|
176 } |
|
177 ; |
|
178 |
|
179 additive_expression: multiplicative_expression |
|
180 { $$ = $1; } |
|
181 | additive_expression TOK_PLUS multiplicative_expression |
|
182 { |
|
183 if (!$1.isInt() || !$3.isInt()) |
|
184 { |
|
185 $$ = CPPValue( (double)$1 + (double)$3 ); |
|
186 } |
|
187 else |
|
188 { |
|
189 $$ = CPPValue( (long)$1 + (long)$3 ); |
|
190 } |
|
191 } |
|
192 | additive_expression TOK_MINUS multiplicative_expression |
|
193 { |
|
194 if (!$1.isInt() || !$3.isInt()) |
|
195 { |
|
196 $$ = CPPValue( (double)$1 - (double)$3 ); |
|
197 } |
|
198 else |
|
199 { |
|
200 $$ = CPPValue( (long)$1 - (long)$3 ); |
|
201 } |
|
202 } |
|
203 ; |
|
204 |
|
205 multiplicative_expression: unary_expression |
|
206 { $$ = $1; } |
|
207 | multiplicative_expression TOK_STAR unary_expression |
|
208 { |
|
209 if (!$1.isInt() || !$3.isInt()) |
|
210 { |
|
211 $$ = CPPValue( (double)$1 * (double)$3 ); |
|
212 } |
|
213 else |
|
214 { |
|
215 $$ = CPPValue( (long)$1 * (long)$3 ); |
|
216 } |
|
217 } |
|
218 | multiplicative_expression TOK_DIVIDE unary_expression |
|
219 { |
|
220 if (!$1.isInt() || !$3.isInt()) |
|
221 { |
|
222 $$ = CPPValue( (double)$1 / (double)$3 ); |
|
223 } |
|
224 else |
|
225 { |
|
226 long value = $3; |
|
227 if (value==0) value=1; |
|
228 $$ = CPPValue( (long)$1 / value ); |
|
229 } |
|
230 } |
|
231 | multiplicative_expression TOK_MOD unary_expression |
|
232 { |
|
233 long value = $3; |
|
234 if (value==0) value=1; |
|
235 $$ = CPPValue( (long)$1 % value ); |
|
236 } |
|
237 ; |
|
238 |
|
239 unary_expression: primary_expression |
|
240 { $$ = $1; } |
|
241 | TOK_PLUS unary_expression |
|
242 { $$ = $1; } |
|
243 | TOK_MINUS unary_expression |
|
244 { |
|
245 if ($2.isInt()) |
|
246 $$ = CPPValue(-(long)$2); |
|
247 else |
|
248 $$ = CPPValue(-(double)$2); |
|
249 } |
|
250 | TOK_TILDE unary_expression |
|
251 { |
|
252 $$ = CPPValue(~(long)$2); |
|
253 } |
|
254 | TOK_NOT unary_expression |
|
255 { |
|
256 $$ = CPPValue((long)!(long)$2); |
|
257 } |
|
258 ; |
|
259 |
|
260 primary_expression: constant |
|
261 { $$ = $1; } |
|
262 | TOK_LPAREN constant_expression TOK_RPAREN |
|
263 { $$ = $2; } |
|
264 ; |
|
265 |
|
266 constant: TOK_OCTALINT |
|
267 { $$ = parseOctal(); } |
|
268 | TOK_DECIMALINT |
|
269 { $$ = parseDecimal(); } |
|
270 | TOK_HEXADECIMALINT |
|
271 { $$ = parseHexadecimal(); } |
|
272 | TOK_CHARACTER |
|
273 { $$ = parseCharacter(); } |
|
274 | TOK_FLOAT |
|
275 { $$ = parseFloat(); } |
|
276 ; |
|
277 |
|
278 %% |