Branch data Line data Source code
1 : : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : : /*
3 : : * This file is part of the LibreOffice project.
4 : : *
5 : : * This Source Code Form is subject to the terms of the Mozilla Public
6 : : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : : *
9 : : * This file incorporates work covered by the following license notice:
10 : : *
11 : : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : : * contributor license agreements. See the NOTICE file distributed
13 : : * with this work for additional information regarding copyright
14 : : * ownership. The ASF licenses this file to you under the Apache
15 : : * License, Version 2.0 (the "License"); you may not use this file
16 : : * except in compliance with the License. You may obtain a copy of
17 : : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : : */
19 : :
20 : :
21 : : #include <idlc/astexpression.hxx>
22 : : #include <idlc/astconstant.hxx>
23 : : #include <idlc/astscope.hxx>
24 : : #include <idlc/errorhandler.hxx>
25 : :
26 : : #include <limits.h>
27 : : #include <float.h>
28 : : #include <memory> // auto_ptr<>
29 : :
30 : : #undef MAXCHAR
31 : : #define MAXCHAR 127
32 : : #undef MINCHAR
33 : : #define MINCHAR -128
34 : :
35 : : using namespace ::rtl;
36 : :
37 : 132 : AstExpression::AstExpression(ExprComb c, AstExpression *pExpr1, AstExpression *pExpr2)
38 : : : m_combOperator(c)
39 : : , m_subExpr1(pExpr1)
40 : : , m_subExpr2(pExpr2)
41 : : , m_exprValue(NULL)
42 : 132 : , m_pSymbolicName(NULL)
43 : : {
44 [ + - ]: 132 : fillDefinitionDetails();
45 : :
46 : 132 : }
47 : :
48 : 77704 : AstExpression::AstExpression(sal_Int32 l)
49 : : : m_combOperator(EC_none)
50 : : , m_subExpr1(NULL)
51 : : , m_subExpr2(NULL)
52 : : , m_exprValue(NULL)
53 : 77704 : , m_pSymbolicName(NULL)
54 : : {
55 [ + - ]: 77704 : fillDefinitionDetails();
56 : :
57 [ + - ]: 77704 : m_exprValue = new AstExprValue();
58 : 77704 : m_exprValue->et = ET_long;
59 : 77704 : m_exprValue->u.lval = l;
60 : 77704 : }
61 : :
62 : 0 : AstExpression::AstExpression(sal_Int32 l, ExprType et)
63 : : : m_combOperator(EC_none)
64 : : , m_subExpr1(NULL)
65 : : , m_subExpr2(NULL)
66 : : , m_exprValue(NULL)
67 : 0 : , m_pSymbolicName(NULL)
68 : : {
69 [ # # ]: 0 : fillDefinitionDetails();
70 : :
71 [ # # ]: 0 : m_exprValue = new AstExprValue();
72 : 0 : m_exprValue->et = et;
73 : 0 : m_exprValue->u.lval = l;
74 : 0 : }
75 : :
76 : 15535 : AstExpression::AstExpression(sal_Int64 h)
77 : : : m_combOperator(EC_none)
78 : : , m_subExpr1(NULL)
79 : : , m_subExpr2(NULL)
80 : : , m_exprValue(NULL)
81 : 15535 : , m_pSymbolicName(NULL)
82 : : {
83 [ + - ]: 15535 : fillDefinitionDetails();
84 : :
85 [ + - ]: 15535 : m_exprValue = new AstExprValue();
86 : 15535 : m_exprValue->et = ET_hyper;
87 : 15535 : m_exprValue->u.hval = h;
88 : 15535 : }
89 : :
90 : 1 : AstExpression::AstExpression(sal_uInt64 uh)
91 : : : m_combOperator(EC_none)
92 : : , m_subExpr1(NULL)
93 : : , m_subExpr2(NULL)
94 : : , m_exprValue(NULL)
95 : 1 : , m_pSymbolicName(NULL)
96 : : {
97 [ + - ]: 1 : fillDefinitionDetails();
98 : :
99 [ + - ]: 1 : m_exprValue = new AstExprValue();
100 : 1 : m_exprValue->et = ET_uhyper;
101 : 1 : m_exprValue->u.uhval = uh;
102 : 1 : }
103 : :
104 : 20 : AstExpression::AstExpression(double d)
105 : : : m_combOperator(EC_none)
106 : : , m_subExpr1(NULL)
107 : : , m_subExpr2(NULL)
108 : : , m_exprValue(NULL)
109 : 20 : , m_pSymbolicName(NULL)
110 : : {
111 [ + - ]: 20 : fillDefinitionDetails();
112 : :
113 [ + - ]: 20 : m_exprValue = new AstExprValue();
114 : 20 : m_exprValue->et = ET_double;
115 : 20 : m_exprValue->u.dval = d;
116 : 20 : }
117 : :
118 : 193 : AstExpression::AstExpression(::rtl::OString* scopedName)
119 : : : m_combOperator(EC_symbol)
120 : : , m_subExpr1(NULL)
121 : : , m_subExpr2(NULL)
122 : : , m_exprValue(NULL)
123 : 193 : , m_pSymbolicName(scopedName)
124 : : {
125 [ + - ]: 193 : fillDefinitionDetails();
126 : 193 : }
127 : :
128 : 0 : AstExpression::~AstExpression()
129 : : {
130 [ # # ]: 0 : if ( m_exprValue )
131 : 0 : delete m_exprValue;
132 [ # # ]: 0 : if ( m_subExpr1 )
133 [ # # ][ # # ]: 0 : delete m_subExpr1;
134 [ # # ]: 0 : if ( m_subExpr2 )
135 [ # # ][ # # ]: 0 : delete m_subExpr2;
136 [ # # ]: 0 : if ( m_pSymbolicName )
137 [ # # ]: 0 : delete m_pSymbolicName;
138 [ # # ]: 0 : }
139 : :
140 : : /*
141 : : * Perform the coercion from the given AstExprValue to the requested
142 : : * ExprType. Return an AstExprValue if successful, NULL if failed.
143 : : * must be done for hyper, uhyper
144 : : */
145 : : static AstExprValue *
146 : 15785 : coerce_value(AstExprValue *ev, ExprType t)
147 : : {
148 [ - + ]: 15785 : if (ev == NULL)
149 : 0 : return NULL;
150 : :
151 [ + + + + : 15785 : switch (t)
- + - + +
+ - ]
152 : : {
153 : : case ET_short:
154 [ + - - - : 3629 : switch (ev->et)
+ - - - +
- - ]
155 : : {
156 : : case ET_short:
157 : 33 : return ev;
158 : : case ET_ushort:
159 [ # # ]: 0 : if (ev->u.usval > SAL_MAX_INT16)
160 : 0 : return NULL;
161 : 0 : ev->u.sval = (sal_Int16)ev->u.usval;
162 : 0 : ev->et = ET_short;
163 : 0 : return ev;
164 : : case ET_long:
165 [ # # ][ # # ]: 0 : if (ev->u.lval < SAL_MIN_INT16 || ev->u.lval > SAL_MAX_INT16)
166 : 0 : return NULL;
167 : 0 : ev->u.sval = (sal_Int16)ev->u.lval;
168 : 0 : ev->et = ET_short;
169 : 0 : return ev;
170 : : case ET_ulong:
171 [ # # ]: 0 : if (ev->u.ulval > SAL_MAX_INT16)
172 : 0 : return NULL;
173 : 0 : ev->u.sval = (sal_Int16)ev->u.ulval;
174 : 0 : ev->et = ET_short;
175 : 0 : return ev;
176 : : case ET_hyper:
177 [ + - ][ - + ]: 3496 : if (ev->u.hval < SAL_MIN_INT16 || ev->u.hval > SAL_MAX_INT16)
178 : 0 : return NULL;
179 : 3496 : ev->u.sval = (sal_Int16)ev->u.hval;
180 : 3496 : ev->et = ET_short;
181 : 3496 : return ev;
182 : : case ET_uhyper:
183 [ # # ]: 0 : if (ev->u.uhval > SAL_MAX_INT16)
184 : 0 : return NULL;
185 : 0 : ev->u.sval = (sal_Int16)ev->u.uhval;
186 : 0 : ev->et = ET_short;
187 : 0 : return ev;
188 : : case ET_boolean:
189 : 0 : ev->u.sval = (sal_Int16)ev->u.bval;
190 : 0 : ev->et = ET_short;
191 : 0 : return ev;
192 : : case ET_float:
193 [ # # ][ # # ]: 0 : if (ev->u.fval < SAL_MIN_INT16 || ev->u.fval > SAL_MAX_INT16)
194 : 0 : return NULL;
195 : 0 : ev->u.sval = (sal_Int16)ev->u.fval;
196 : 0 : ev->et = ET_short;
197 : 0 : return ev;
198 : : case ET_double:
199 [ + - ][ - + ]: 100 : if (ev->u.dval < SAL_MIN_INT16 || ev->u.dval > SAL_MAX_INT16)
200 : 0 : return NULL;
201 : 100 : ev->u.sval = (sal_Int16)ev->u.dval;
202 : 100 : ev->et = ET_short;
203 : 100 : return ev;
204 : : case ET_byte:
205 : 0 : ev->u.sval = (sal_Int16)ev->u.byval;
206 : 0 : ev->et = ET_short;
207 : 0 : return ev;
208 : : default:
209 : : OSL_ASSERT(false);
210 : 0 : return NULL;
211 : : }
212 : : case ET_ushort:
213 [ - - - - : 2 : switch (ev->et)
+ - - - -
- - ]
214 : : {
215 : : case ET_short:
216 [ # # ]: 0 : if (ev->u.sval < 0)
217 : 0 : return NULL;
218 : 0 : ev->u.usval = (sal_uInt16)ev->u.sval;
219 : 0 : ev->et = ET_ushort;
220 : 0 : return ev;
221 : : case ET_ushort:
222 : 0 : return ev;
223 : : case ET_long:
224 [ # # ][ # # ]: 0 : if (ev->u.lval < 0 || ev->u.lval > SAL_MAX_UINT16)
225 : 0 : return NULL;
226 : 0 : ev->u.usval = (sal_uInt16)ev->u.lval;
227 : 0 : ev->et = ET_ushort;
228 : 0 : return ev;
229 : : case ET_ulong:
230 [ # # ]: 0 : if (ev->u.ulval > SAL_MAX_UINT16)
231 : 0 : return NULL;
232 : 0 : ev->u.usval = (sal_uInt16)ev->u.ulval;
233 : 0 : ev->et = ET_ushort;
234 : 0 : return ev;
235 : : case ET_hyper:
236 [ + - ][ - + ]: 2 : if (ev->u.hval < 0 || ev->u.hval > SAL_MAX_UINT16)
237 : 0 : return NULL;
238 : 2 : ev->u.usval = (sal_uInt16)ev->u.hval;
239 : 2 : ev->et = ET_ushort;
240 : 2 : return ev;
241 : : case ET_uhyper:
242 [ # # ]: 0 : if (ev->u.uhval > SAL_MAX_UINT16)
243 : 0 : return NULL;
244 : 0 : ev->u.usval = (sal_uInt16)ev->u.uhval;
245 : 0 : ev->et = ET_ushort;
246 : 0 : return ev;
247 : : case ET_boolean:
248 : 0 : ev->u.usval = (sal_uInt16)ev->u.bval;
249 : 0 : ev->et = ET_short;
250 : 0 : return ev;
251 : : case ET_float:
252 [ # # ][ # # ]: 0 : if (ev->u.fval < 0.0 || ev->u.fval > SAL_MAX_UINT16)
253 : 0 : return NULL;
254 : 0 : ev->u.usval = (sal_uInt16)ev->u.fval;
255 : 0 : ev->et = ET_short;
256 : 0 : return ev;
257 : : case ET_double:
258 [ # # ][ # # ]: 0 : if (ev->u.dval < 0.0 || ev->u.dval > SAL_MAX_UINT16)
259 : 0 : return NULL;
260 : 0 : ev->u.usval = (sal_uInt16)ev->u.dval;
261 : 0 : ev->et = ET_short;
262 : 0 : return ev;
263 : : case ET_byte:
264 : 0 : ev->u.usval = (sal_uInt16)ev->u.byval;
265 : 0 : ev->et = ET_ushort;
266 : 0 : return ev;
267 : : default:
268 : : OSL_ASSERT(false);
269 : 0 : return NULL;
270 : : }
271 : : case ET_long:
272 [ - - + - : 11360 : switch (ev->et)
+ - - - -
- - ]
273 : : {
274 : : case ET_short:
275 : 0 : ev->u.lval = (sal_Int32)ev->u.sval;
276 : 0 : ev->et = ET_long;
277 : 0 : return ev;
278 : : case ET_ushort:
279 : 0 : ev->u.lval = (sal_Int32)ev->u.usval;
280 : 0 : ev->et = ET_long;
281 : 0 : return ev;
282 : : case ET_long:
283 : 28 : return ev;
284 : : case ET_ulong:
285 [ # # ]: 0 : if (ev->u.ulval > SAL_MAX_INT32)
286 : 0 : return NULL;
287 : 0 : ev->u.lval = (sal_Int32)ev->u.ulval;
288 : 0 : ev->et = ET_long;
289 : 0 : return ev;
290 : : case ET_hyper:
291 [ + - ][ - + ]: 11332 : if (ev->u.hval < SAL_MIN_INT32 || ev->u.hval > SAL_MAX_INT32)
292 : 0 : return NULL;
293 : 11332 : ev->u.lval = (sal_Int32)ev->u.hval;
294 : 11332 : ev->et = ET_long;
295 : 11332 : return ev;
296 : : case ET_uhyper:
297 [ # # ]: 0 : if (ev->u.uhval > SAL_MAX_INT32)
298 : 0 : return NULL;
299 : 0 : ev->u.lval = (sal_Int32)ev->u.uhval;
300 : 0 : ev->et = ET_long;
301 : 0 : return ev;
302 : : case ET_boolean:
303 : 0 : ev->u.lval = (sal_Int32)ev->u.bval;
304 : 0 : ev->et = ET_long;
305 : 0 : return ev;
306 : : case ET_float:
307 [ # # ][ # # ]: 0 : if (ev->u.fval < SAL_MIN_INT32 || ev->u.fval > SAL_MAX_INT32)
308 : 0 : return NULL;
309 : 0 : ev->u.lval = (sal_Int32)ev->u.fval;
310 : 0 : ev->et = ET_long;
311 : 0 : return ev;
312 : : case ET_double:
313 [ # # ][ # # ]: 0 : if (ev->u.dval < SAL_MIN_INT32 || ev->u.dval > SAL_MAX_INT32)
314 : 0 : return NULL;
315 : 0 : ev->u.lval = (sal_Int32)ev->u.dval;
316 : 0 : ev->et = ET_long;
317 : 0 : return ev;
318 : : case ET_byte:
319 : 0 : ev->u.lval = (sal_Int32) ev->u.byval;
320 : 0 : ev->et = ET_long;
321 : 0 : return ev;
322 : : default:
323 : : OSL_ASSERT(false);
324 : 0 : return NULL;
325 : : }
326 : : case ET_ulong:
327 [ - - - - : 65 : switch (ev->et)
+ - - - -
- - ]
328 : : {
329 : : case ET_short:
330 [ # # ]: 0 : if (ev->u.sval < 0)
331 : 0 : return NULL;
332 : 0 : ev->u.ulval = (sal_uInt32)ev->u.sval;
333 : 0 : ev->et = ET_ulong;
334 : 0 : return ev;
335 : : case ET_ushort:
336 : 0 : ev->u.ulval = (sal_uInt32)ev->u.usval;
337 : 0 : ev->et = ET_ulong;
338 : 0 : return ev;
339 : : case ET_long:
340 [ # # ]: 0 : if (ev->u.lval < 0)
341 : 0 : return NULL;
342 : 0 : ev->u.ulval = (sal_uInt32)ev->u.lval;
343 : 0 : ev->et = ET_ulong;
344 : 0 : return ev;
345 : : case ET_ulong:
346 : 0 : return ev;
347 : : case ET_hyper:
348 [ + - ][ - + ]: 65 : if (ev->u.hval < 0 || ev->u.hval > SAL_MAX_UINT32)
349 : 0 : return NULL;
350 : 65 : ev->u.lval = (sal_uInt32)ev->u.hval;
351 : 65 : ev->et = ET_ulong;
352 : 65 : return ev;
353 : : case ET_uhyper:
354 [ # # ]: 0 : if (ev->u.uhval > SAL_MAX_UINT32)
355 : 0 : return NULL;
356 : 0 : ev->u.ulval = (sal_uInt32)ev->u.uhval;
357 : 0 : ev->et = ET_ulong;
358 : 0 : return ev;
359 : : case ET_boolean:
360 : 0 : ev->u.ulval = (sal_uInt32)ev->u.bval;
361 : 0 : ev->et = ET_ulong;
362 : 0 : return ev;
363 : : case ET_float:
364 [ # # ][ # # ]: 0 : if (ev->u.fval < 0.0 || ev->u.fval > SAL_MAX_UINT32)
365 : 0 : return NULL;
366 : 0 : ev->u.ulval = (sal_uInt32)ev->u.fval;
367 : 0 : ev->et = ET_ulong;
368 : 0 : return ev;
369 : : case ET_double:
370 [ # # ][ # # ]: 0 : if (ev->u.dval < 0.0 || ev->u.dval > SAL_MAX_UINT32)
371 : 0 : return NULL;
372 : 0 : ev->u.ulval = (sal_uInt32)ev->u.dval;
373 : 0 : ev->et = ET_ulong;
374 : 0 : return ev;
375 : : case ET_byte:
376 : 0 : ev->u.ulval = (sal_uInt32)ev->u.byval;
377 : 0 : ev->et = ET_ulong;
378 : 0 : return ev;
379 : : default:
380 : : OSL_ASSERT(false);
381 : 0 : return NULL;
382 : : }
383 : : case ET_hyper:
384 [ # # # # : 0 : switch (ev->et)
# # # # #
# # ]
385 : : {
386 : : case ET_short:
387 : 0 : ev->u.hval = (sal_Int64)ev->u.sval;
388 : 0 : ev->et = ET_hyper;
389 : 0 : return ev;
390 : : case ET_ushort:
391 : 0 : ev->u.hval = (sal_Int64)ev->u.usval;
392 : 0 : ev->et = ET_hyper;
393 : 0 : return ev;
394 : : case ET_long:
395 : 0 : ev->u.hval = (sal_Int64)ev->u.lval;
396 : 0 : ev->et = ET_hyper;
397 : 0 : return ev;
398 : : case ET_ulong:
399 : 0 : ev->u.hval = (sal_Int64)ev->u.ulval;
400 : 0 : ev->et = ET_hyper;
401 : 0 : return ev;
402 : : case ET_hyper:
403 : 0 : return ev;
404 : : case ET_uhyper:
405 [ # # ]: 0 : if (ev->u.uhval > SAL_MAX_INT64)
406 : 0 : return NULL;
407 : 0 : ev->u.hval = (sal_Int64)ev->u.uhval;
408 : 0 : ev->et = ET_long;
409 : 0 : return ev;
410 : : case ET_boolean:
411 : 0 : ev->u.hval = (sal_Int64)ev->u.bval;
412 : 0 : ev->et = ET_hyper;
413 : 0 : return ev;
414 : : case ET_float:
415 [ # # ][ # # ]: 0 : if (ev->u.fval < SAL_MIN_INT64 || ev->u.fval > SAL_MAX_INT64)
416 : 0 : return NULL;
417 : 0 : ev->u.hval = (sal_Int64)ev->u.fval;
418 : 0 : ev->et = ET_hyper;
419 : 0 : return ev;
420 : : case ET_double:
421 [ # # ][ # # ]: 0 : if (ev->u.dval < SAL_MIN_INT64 || ev->u.dval > SAL_MAX_INT64)
422 : 0 : return NULL;
423 : 0 : ev->u.hval = (sal_Int64)ev->u.dval;
424 : 0 : ev->et = ET_hyper;
425 : 0 : return ev;
426 : : case ET_byte:
427 : 0 : ev->u.hval = (sal_Int64)ev->u.byval;
428 : 0 : ev->et = ET_hyper;
429 : 0 : return ev;
430 : : default:
431 : : OSL_ASSERT(false);
432 : 0 : return NULL;
433 : : }
434 : : case ET_uhyper:
435 [ - - - - : 1 : switch (ev->et)
+ - - - -
- - ]
436 : : {
437 : : case ET_short:
438 [ # # ]: 0 : if (ev->u.sval < 0)
439 : 0 : return NULL;
440 : 0 : ev->u.uhval = (sal_uInt64)ev->u.sval;
441 : 0 : ev->et = ET_uhyper;
442 : 0 : return ev;
443 : : case ET_ushort:
444 : 0 : ev->u.uhval = (sal_uInt64)ev->u.usval;
445 : 0 : ev->et = ET_uhyper;
446 : 0 : return ev;
447 : : case ET_long:
448 [ # # ]: 0 : if (ev->u.lval < 0)
449 : 0 : return NULL;
450 : 0 : ev->u.uhval = (sal_uInt64)ev->u.lval;
451 : 0 : ev->et = ET_uhyper;
452 : 0 : return ev;
453 : : case ET_ulong:
454 : 0 : ev->u.uhval = (sal_uInt64)ev->u.ulval;
455 : 0 : ev->et = ET_uhyper;
456 : 0 : return ev;
457 : : case ET_hyper:
458 [ - + ]: 1 : if (ev->u.hval < 0)
459 : 0 : return NULL;
460 : 1 : ev->u.uhval = (sal_uInt64)ev->u.hval;
461 : 1 : ev->et = ET_uhyper;
462 : 1 : return ev;
463 : : case ET_uhyper:
464 : 0 : return ev;
465 : : case ET_boolean:
466 : 0 : ev->u.uhval = (sal_uInt64)ev->u.bval;
467 : 0 : ev->et = ET_uhyper;
468 : 0 : return ev;
469 : : case ET_float:
470 [ # # ][ # # ]: 0 : if (ev->u.fval < 0.0 || ev->u.fval > SAL_MAX_UINT64)
471 : 0 : return NULL;
472 : 0 : ev->u.uhval = (sal_uInt64)ev->u.fval;
473 : 0 : ev->et = ET_uhyper;
474 : 0 : return ev;
475 : : case ET_double:
476 [ # # ][ # # ]: 0 : if (ev->u.dval < 0.0 || ev->u.dval > SAL_MAX_UINT64)
477 : 0 : return NULL;
478 : 0 : ev->u.uhval = (sal_uInt64)ev->u.dval;
479 : 0 : ev->et = ET_uhyper;
480 : 0 : return ev;
481 : : case ET_byte:
482 : 0 : ev->u.uhval = (sal_uInt64)ev->u.byval;
483 : 0 : ev->et = ET_uhyper;
484 : 0 : return ev;
485 : : default:
486 : : OSL_ASSERT(false);
487 : 0 : return NULL;
488 : : }
489 : : case ET_boolean:
490 [ # # # # : 0 : switch (ev->et)
# # # # #
# # ]
491 : : {
492 : : case ET_short:
493 : 0 : ev->u.bval = (ev->u.sval == 0) ? sal_False : sal_True;
494 : 0 : ev->et = ET_boolean;
495 : 0 : return ev;
496 : : case ET_ushort:
497 : 0 : ev->u.bval = (ev->u.usval == 0) ? sal_False : sal_True;
498 : 0 : ev->et = ET_boolean;
499 : 0 : return ev;
500 : : case ET_long:
501 : 0 : ev->u.bval = (ev->u.lval == 0) ? sal_False : sal_True;
502 : 0 : ev->et = ET_boolean;
503 : 0 : return ev;
504 : : case ET_ulong:
505 : 0 : ev->u.bval = (ev->u.ulval == 0) ? sal_False : sal_True;
506 : 0 : ev->et = ET_boolean;
507 : 0 : return ev;
508 : : case ET_hyper:
509 : 0 : ev->u.bval = (ev->u.hval == 0) ? sal_False : sal_True;
510 : 0 : ev->et = ET_boolean;
511 : 0 : return ev;
512 : : case ET_uhyper:
513 : 0 : ev->u.bval = (ev->u.uhval == 0) ? sal_False : sal_True;
514 : 0 : ev->et = ET_boolean;
515 : 0 : return ev;
516 : : case ET_boolean:
517 : 0 : return ev;
518 : : case ET_float:
519 : 0 : ev->u.bval = (ev->u.fval == 0.0) ? sal_False : sal_True;
520 : 0 : ev->et = ET_boolean;
521 : 0 : return ev;
522 : : case ET_double:
523 : 0 : ev->u.bval = (ev->u.dval == 0.0) ? sal_False : sal_True;
524 : 0 : ev->et = ET_boolean;
525 : 0 : return ev;
526 : : case ET_byte:
527 : 0 : ev->u.bval = (ev->u.byval == 0) ? sal_False : sal_True;
528 : 0 : ev->et = ET_boolean;
529 : 0 : return ev;
530 : : default:
531 : : OSL_ASSERT(false);
532 : 0 : return NULL;
533 : : }
534 : : case ET_float:
535 [ - - - - : 20 : switch (ev->et)
- - - - +
- - ]
536 : : {
537 : : case ET_short:
538 : 0 : ev->u.fval = (float)ev->u.sval;
539 : 0 : ev->et = ET_float;
540 : 0 : return ev;
541 : : case ET_ushort:
542 : 0 : ev->u.fval = (float)ev->u.usval;
543 : 0 : ev->et = ET_float;
544 : 0 : return ev;
545 : : case ET_long:
546 : 0 : ev->u.fval = (float)ev->u.lval;
547 : 0 : ev->et = ET_float;
548 : 0 : return ev;
549 : : case ET_ulong:
550 : 0 : ev->u.fval = (float)ev->u.ulval;
551 : 0 : ev->et = ET_float;
552 : 0 : return ev;
553 : : case ET_hyper:
554 : 0 : ev->u.fval = (float)ev->u.hval;
555 : 0 : ev->et = ET_float;
556 : 0 : return ev;
557 : : case ET_uhyper:
558 [ # # ]: 0 : if ((float)ev->u.ulval > FLT_MAX)
559 : 0 : return NULL;
560 : 0 : ev->u.fval = (float)ev->u.ulval;
561 : 0 : ev->et = ET_float;
562 : 0 : return ev;
563 : : case ET_boolean:
564 [ # # ]: 0 : ev->u.fval = (ev->u.bval == sal_True) ? 1.0f : 0.0f;
565 : 0 : ev->et = ET_float;
566 : 0 : return ev;
567 : : case ET_float:
568 : 0 : return ev;
569 : : case ET_double:
570 [ + - ][ - + ]: 20 : if ((float)ev->u.dval > FLT_MAX || (float)ev->u.dval < -FLT_MAX)
571 : 0 : return NULL;
572 : 20 : ev->u.fval = (float)ev->u.dval;
573 : 20 : ev->et = ET_float;
574 : 20 : return ev;
575 : : case ET_byte:
576 : 0 : ev->u.fval = (float)ev->u.byval;
577 : 0 : ev->et = ET_float;
578 : 0 : return ev;
579 : : default:
580 : : OSL_ASSERT(false);
581 : 0 : return NULL;
582 : : }
583 : : case ET_double:
584 [ + - - - : 200 : switch (ev->et)
+ - - - -
- - ]
585 : : {
586 : : case ET_short:
587 : 100 : ev->u.dval = (double)ev->u.sval;
588 : 100 : ev->et = ET_double;
589 : 100 : return ev;
590 : : case ET_ushort:
591 : 0 : ev->u.dval = (double)ev->u.usval;
592 : 0 : ev->et = ET_double;
593 : 0 : return ev;
594 : : case ET_long:
595 : 0 : ev->u.dval = (double)ev->u.lval;
596 : 0 : ev->et = ET_double;
597 : 0 : return ev;
598 : : case ET_ulong:
599 : 0 : ev->u.dval = (double)ev->u.ulval;
600 : 0 : ev->et = ET_double;
601 : 0 : return ev;
602 : : case ET_hyper:
603 : 100 : ev->u.dval = (double)ev->u.hval;
604 : 100 : ev->et = ET_double;
605 : 100 : return ev;
606 : : case ET_uhyper:
607 [ # # ][ # # ]: 0 : if ((double)ev->u.dval > FLT_MAX || (double)ev->u.dval < -FLT_MAX)
608 : 0 : return NULL;
609 : 0 : ev->u.dval = (double)ev->u.ulval;
610 : 0 : ev->et = ET_double;
611 : 0 : return ev;
612 : : case ET_boolean:
613 [ # # ]: 0 : ev->u.dval = (ev->u.bval == sal_True) ? 1.0 : 0.0;
614 : 0 : ev->et = ET_double;
615 : 0 : return ev;
616 : : case ET_float:
617 : 0 : ev->u.dval = (double)ev->u.fval;
618 : 0 : ev->et = ET_double;
619 : 0 : return ev;
620 : : case ET_double:
621 : 0 : return ev;
622 : : case ET_byte:
623 : 0 : ev->u.dval = (double)ev->u.byval;
624 : 0 : ev->et = ET_double;
625 : 0 : return ev;
626 : : default:
627 : : OSL_ASSERT(false);
628 : 0 : return NULL;
629 : : }
630 : : case ET_byte:
631 [ - - - - : 508 : switch (ev->et)
+ - - - -
- - ]
632 : : {
633 : : case ET_short:
634 [ # # ][ # # ]: 0 : if (ev->u.sval < SAL_MIN_INT8 || ev->u.sval > SAL_MAX_UINT8)
635 : 0 : return NULL;
636 : 0 : ev->u.byval = (sal_uChar)ev->u.sval;
637 : 0 : ev->et = ET_byte;
638 : 0 : return ev;
639 : : case ET_ushort:
640 [ # # ]: 0 : if (ev->u.usval > SAL_MAX_UINT8)
641 : 0 : return NULL;
642 : 0 : ev->u.byval = (sal_uChar)ev->u.usval;
643 : 0 : ev->et = ET_byte;
644 : 0 : return ev;
645 : : case ET_long:
646 [ # # ][ # # ]: 0 : if (ev->u.lval < SAL_MIN_INT8 || ev->u.lval > SAL_MAX_UINT8)
647 : 0 : return NULL;
648 : 0 : ev->u.byval = (sal_uChar) ev->u.lval;
649 : 0 : ev->et = ET_byte;
650 : 0 : return ev;
651 : : case ET_ulong:
652 [ # # ]: 0 : if (ev->u.ulval > SAL_MAX_UINT8)
653 : 0 : return NULL;
654 : 0 : ev->u.byval = (sal_uChar) ev->u.ulval;
655 : 0 : ev->et = ET_byte;
656 : 0 : return ev;
657 : : case ET_hyper:
658 [ + - ][ - + ]: 508 : if (ev->u.hval < SAL_MIN_INT8 || ev->u.hval > SAL_MAX_UINT8)
659 : 0 : return NULL;
660 : 508 : ev->u.byval = (sal_uChar) ev->u.hval;
661 : 508 : ev->et = ET_byte;
662 : 508 : return ev;
663 : : case ET_uhyper:
664 [ # # ]: 0 : if (ev->u.uhval > SAL_MAX_UINT8)
665 : 0 : return NULL;
666 : 0 : ev->u.byval = (sal_uChar) ev->u.uhval;
667 : 0 : ev->et = ET_byte;
668 : 0 : return ev;
669 : : case ET_boolean:
670 [ # # ]: 0 : ev->u.byval = (ev->u.bval == sal_False) ? 1 : 0;
671 : 0 : ev->et = ET_byte;
672 : 0 : return ev;
673 : : case ET_float:
674 [ # # ][ # # ]: 0 : if (ev->u.fval < SAL_MIN_INT8 || ev->u.fval > SAL_MAX_UINT8)
675 : 0 : return NULL;
676 : 0 : ev->u.byval = (sal_uChar) ev->u.fval;
677 : 0 : ev->et = ET_byte;
678 : 0 : return ev;
679 : : case ET_double:
680 [ # # ][ # # ]: 0 : if (ev->u.dval < SAL_MIN_INT8 || ev->u.dval > SAL_MAX_UINT8)
681 : 0 : return NULL;
682 : 0 : ev->u.byval = (sal_uChar) ev->u.dval;
683 : 0 : ev->et = ET_byte;
684 : 0 : return ev;
685 : : case ET_byte:
686 : 0 : return ev;
687 : : default:
688 : : OSL_ASSERT(false);
689 : 0 : return NULL;
690 : : }
691 : : default:
692 : : OSL_ASSERT(false);
693 : 15785 : return NULL;
694 : : }
695 : : }
696 : :
697 : : /*
698 : : * Evaluate the expression with the evaluation kind requested. Supported
699 : : * evaluation kinds are
700 : : * - EK_const: The expression must evaluate to a constant
701 : : * - EK_positive_int: The expression must further evaluate to a
702 : : * positive integer
703 : : */
704 : : static AstExprValue *
705 : 4482098 : eval_kind(AstExprValue *ev, EvalKind ek)
706 : : {
707 [ + - ]: 4482098 : if (ek == EK_const)
708 : 4482098 : return ev;
709 [ # # ]: 0 : if (ek == EK_positive_int)
710 : 0 : return coerce_value(ev, ET_ulong);
711 : :
712 : 4482098 : return NULL;
713 : : }
714 : :
715 : 15881 : AstExprValue* AstExpression::coerce(ExprType t, sal_Bool bAssign)
716 : : {
717 : : AstExprValue *copy;
718 : :
719 : : /*
720 : : * Is it already of the right type?
721 : : */
722 [ + + ][ + + ]: 15881 : if (m_exprValue != NULL && m_exprValue->et == t)
723 : 96 : return m_exprValue;
724 : : /*
725 : : * OK, must coerce
726 : : *
727 : : * First, evaluate it, then try to coerce result type
728 : : * If already evaluated, return the result
729 : : */
730 : 15785 : m_exprValue = eval_internal(EK_const);
731 [ - + ]: 15785 : if (m_exprValue == NULL)
732 : 0 : return NULL;
733 : :
734 : : /*
735 : : * Create a copy to contain coercion result
736 : : */
737 : 15785 : copy = new AstExprValue;
738 : :
739 : 15785 : copy->et = m_exprValue->et;
740 [ + - + - : 15785 : switch (m_exprValue->et)
+ - - - +
- - ]
741 : : {
742 : : case ET_short:
743 : 133 : copy->u.sval = m_exprValue->u.sval;
744 : 133 : break;
745 : : case ET_ushort:
746 : 0 : copy->u.usval = m_exprValue->u.usval;
747 : 0 : break;
748 : : case ET_long:
749 : 28 : copy->u.lval = m_exprValue->u.lval;
750 : 28 : break;
751 : : case ET_ulong:
752 : 0 : copy->u.ulval = m_exprValue->u.ulval;
753 : 0 : break;
754 : : case ET_hyper:
755 : 15504 : copy->u.hval = m_exprValue->u.hval;
756 : 15504 : break;
757 : : case ET_uhyper:
758 : 0 : copy->u.uhval = m_exprValue->u.uhval;
759 : 0 : break;
760 : : case ET_boolean:
761 : 0 : copy->u.bval = m_exprValue->u.bval;
762 : 0 : break;
763 : : case ET_float:
764 : 0 : copy->u.fval = m_exprValue->u.fval;
765 : 0 : break;
766 : : case ET_double:
767 : 120 : copy->u.dval = m_exprValue->u.dval;
768 : 120 : break;
769 : : case ET_byte:
770 : 0 : copy->u.byval = m_exprValue->u.byval;
771 : 0 : break;
772 : : default:
773 : : OSL_ASSERT(false);
774 : 0 : break;
775 : : }
776 : :
777 : 15785 : AstExprValue* const coerced(coerce_value(copy, t));
778 [ - + ]: 15785 : if (!coerced)
779 : 0 : delete copy;
780 : :
781 [ + - ]: 15785 : if (bAssign)
782 : 15785 : m_exprValue = coerced;
783 : :
784 : 15881 : return coerced;
785 : : }
786 : :
787 : 2232928 : void AstExpression::evaluate(EvalKind ek)
788 : : {
789 : 2232928 : m_exprValue = eval_internal(ek);
790 : 2232928 : m_exprValue = eval_kind(m_exprValue, ek);
791 : 2232928 : }
792 : :
793 : 0 : sal_Bool AstExpression::operator==(AstExpression *pExpr)
794 : : {
795 : 0 : sal_Bool bRet = sal_False;
796 [ # # ]: 0 : if (m_combOperator != pExpr->getCombOperator())
797 : 0 : return bRet;
798 : 0 : evaluate(EK_const);
799 : 0 : pExpr->evaluate(EK_const);
800 [ # # ][ # # ]: 0 : if (m_exprValue == NULL || pExpr->getExprValue() == NULL)
[ # # ]
801 : 0 : return bRet;
802 [ # # ]: 0 : if (m_exprValue->et != pExpr->getExprValue()->et)
803 : 0 : return bRet;
804 [ # # # # : 0 : switch (m_exprValue->et)
# # # # #
# # ]
805 : : {
806 : : case ET_short:
807 [ # # ]: 0 : bRet = (m_exprValue->u.sval == pExpr->getExprValue()->u.sval) ? sal_True : sal_False;
808 : 0 : break;
809 : : case ET_ushort:
810 [ # # ]: 0 : bRet = (m_exprValue->u.usval == pExpr->getExprValue()->u.usval) ? sal_True : sal_False;
811 : 0 : break;
812 : : case ET_long:
813 [ # # ]: 0 : bRet = (m_exprValue->u.lval == pExpr->getExprValue()->u.lval) ? sal_True : sal_False;
814 : 0 : break;
815 : : case ET_ulong:
816 [ # # ]: 0 : bRet = (m_exprValue->u.ulval == pExpr->getExprValue()->u.ulval) ? sal_True : sal_False;
817 : 0 : break;
818 : : case ET_hyper:
819 [ # # ]: 0 : bRet = (m_exprValue->u.hval == pExpr->getExprValue()->u.hval) ? sal_True : sal_False;
820 : 0 : break;
821 : : case ET_uhyper:
822 [ # # ]: 0 : bRet = (m_exprValue->u.uhval == pExpr->getExprValue()->u.uhval) ? sal_True : sal_False;
823 : 0 : break;
824 : : case ET_float:
825 [ # # ]: 0 : bRet = (m_exprValue->u.fval == pExpr->getExprValue()->u.fval) ? sal_True : sal_False;
826 : 0 : break;
827 : : case ET_double:
828 [ # # ]: 0 : bRet = (m_exprValue->u.dval == pExpr->getExprValue()->u.dval) ? sal_True : sal_False;
829 : 0 : break;
830 : : case ET_byte:
831 [ # # ]: 0 : bRet = (m_exprValue->u.byval == pExpr->getExprValue()->u.byval) ? sal_True : sal_False;
832 : 0 : break;
833 : : case ET_boolean:
834 [ # # ]: 0 : bRet = (m_exprValue->u.lval == pExpr->getExprValue()->u.lval) ? sal_True : sal_False;
835 : 0 : break;
836 : : default:
837 : : OSL_ASSERT(false);
838 : 0 : bRet = sal_False;
839 : 0 : break;
840 : : }
841 : :
842 : 0 : return bRet;
843 : : }
844 : :
845 : 1116015 : sal_Bool AstExpression::compare(AstExpression *pExpr)
846 : : {
847 : 1116015 : bool bRet = sal_False;
848 [ - + ]: 1116015 : if (m_combOperator != pExpr->getCombOperator())
849 : 0 : return bRet;
850 : 1116015 : evaluate(EK_const);
851 : 1116015 : pExpr->evaluate(EK_const);
852 [ - + ][ - + ]: 1116015 : if (m_exprValue == NULL || pExpr->getExprValue() == NULL)
[ + - ]
853 : 0 : return bRet;
854 [ - + ]: 1116015 : if (m_exprValue->et != pExpr->getExprValue()->et)
855 : 0 : return bRet;
856 [ - - + - : 1116015 : switch (m_exprValue->et)
- - - - -
- - ]
857 : : {
858 : : case ET_short:
859 : 0 : bRet = (m_exprValue->u.sval == pExpr->getExprValue()->u.sval) ? sal_True : sal_False;
860 : 0 : break;
861 : : case ET_ushort:
862 : 0 : bRet = (m_exprValue->u.usval == pExpr->getExprValue()->u.usval) ? sal_True : sal_False;
863 : 0 : break;
864 : : case ET_long:
865 : 1116015 : bRet = (m_exprValue->u.lval == pExpr->getExprValue()->u.lval) ? sal_True : sal_False;
866 : 1116015 : break;
867 : : case ET_ulong:
868 : 0 : bRet = (m_exprValue->u.ulval == pExpr->getExprValue()->u.ulval) ? sal_True : sal_False;
869 : 0 : break;
870 : : case ET_hyper:
871 : 0 : bRet = (m_exprValue->u.hval == pExpr->getExprValue()->u.hval) ? sal_True : sal_False;
872 : 0 : break;
873 : : case ET_uhyper:
874 : 0 : bRet = (m_exprValue->u.uhval == pExpr->getExprValue()->u.uhval) ? sal_True : sal_False;
875 : 0 : break;
876 : : case ET_float:
877 : 0 : bRet = (m_exprValue->u.fval == pExpr->getExprValue()->u.fval) ? sal_True : sal_False;
878 : 0 : break;
879 : : case ET_double:
880 : 0 : bRet = (m_exprValue->u.dval == pExpr->getExprValue()->u.dval) ? sal_True : sal_False;
881 : 0 : break;
882 : : case ET_byte:
883 : 0 : bRet = (m_exprValue->u.byval == pExpr->getExprValue()->u.byval) ? sal_True : sal_False;
884 : 0 : break;
885 : : case ET_boolean:
886 : 0 : bRet = (m_exprValue->u.lval == pExpr->getExprValue()->u.lval) ? sal_True : sal_False;
887 : 0 : break;
888 : : default:
889 : : OSL_ASSERT(false);
890 : 0 : bRet = sal_False;
891 : 0 : break;
892 : : }
893 : 1116015 : return bRet;
894 : : }
895 : :
896 : 93585 : void AstExpression::fillDefinitionDetails()
897 : : {
898 [ + - ]: 93585 : m_pScope = idlc()->scopes()->depth() > 0 ? idlc()->scopes()->top() : NULL;
899 : 93585 : m_lineNo = idlc()->getLineNumber();
900 : 93585 : m_fileName = idlc()->getFileName();
901 : 93585 : }
902 : :
903 : 2249170 : AstExprValue* AstExpression::eval_internal(EvalKind ek)
904 : : {
905 : : /*
906 : : * Already evaluated?
907 : : */
908 [ + + ]: 2249170 : if ( m_exprValue != NULL )
909 : 2248845 : return eval_kind(m_exprValue, ek);
910 : : /*
911 : : * OK, must evaluate operator
912 : : */
913 [ + + - + : 325 : switch (m_combOperator)
- - ]
914 : : {
915 : : case EC_add:
916 : : case EC_minus:
917 : : case EC_mul:
918 : : case EC_div:
919 : : case EC_mod:
920 : 100 : m_exprValue = eval_bin_op(ek);
921 : 100 : return eval_kind(m_exprValue, ek);
922 : : case EC_or:
923 : : case EC_xor:
924 : : case EC_and:
925 : : case EC_left:
926 : : case EC_right:
927 : 32 : m_exprValue = eval_bit_op(ek);
928 : 32 : return eval_kind(m_exprValue, ek);
929 : : case EC_u_plus:
930 : : case EC_u_minus:
931 : : case EC_bit_neg:
932 : 0 : m_exprValue = eval_un_op(ek);
933 : 0 : return eval_kind(m_exprValue, ek);
934 : : case EC_symbol:
935 : 193 : m_exprValue = eval_symbol(ek);
936 : 193 : return eval_kind(m_exprValue, ek);
937 : : case EC_none:
938 : 0 : return NULL;
939 : : }
940 : :
941 : 2249170 : return NULL;
942 : : }
943 : :
944 : 100 : AstExprValue* AstExpression::eval_bin_op(EvalKind ek)
945 : : {
946 : 100 : ExprType eType = ET_double;
947 : :
948 [ - + ]: 100 : if ( m_combOperator == EC_mod )
949 : 0 : eType = ET_hyper;
950 : :
951 [ - + ][ # # ]: 100 : if (ek != EK_const && ek != EK_positive_int)
952 : 0 : return NULL;
953 [ + - ][ - + ]: 100 : if (m_subExpr1 == NULL || m_subExpr2 == NULL)
954 : 0 : return NULL;
955 [ + - ]: 100 : m_subExpr1->setExprValue(m_subExpr1->eval_internal(ek));
956 [ - + ]: 100 : if (m_subExpr1->getExprValue() == NULL)
957 : 0 : return NULL;
958 [ + - ]: 100 : m_subExpr1->setExprValue(m_subExpr1->coerce(eType));
959 [ - + ]: 100 : if (m_subExpr1->getExprValue() == NULL)
960 : 0 : return NULL;
961 [ + - ]: 100 : m_subExpr2->setExprValue(m_subExpr2->eval_internal(ek));
962 [ - + ]: 100 : if (m_subExpr2->getExprValue() == NULL)
963 : 0 : return NULL;
964 [ + - ]: 100 : m_subExpr2->setExprValue(m_subExpr2->coerce(eType));
965 [ - + ]: 100 : if (m_subExpr2->getExprValue() == NULL)
966 : 0 : return NULL;
967 : :
968 [ + - ]: 100 : std::auto_ptr< AstExprValue > retval(new AstExprValue());
969 : 100 : retval->et = eType;
970 : :
971 [ - + - - : 100 : switch (m_combOperator)
- - ]
972 : : {
973 : : case EC_mod:
974 [ # # ]: 0 : if (m_subExpr2->getExprValue()->u.hval == 0)
975 : 0 : return NULL;
976 : 0 : retval->u.hval = m_subExpr1->getExprValue()->u.hval % m_subExpr2->getExprValue()->u.hval;
977 : 0 : break;
978 : : case EC_add:
979 : 100 : retval->u.dval = m_subExpr1->getExprValue()->u.dval + m_subExpr2->getExprValue()->u.dval;
980 : 100 : break;
981 : : case EC_minus:
982 : 0 : retval->u.dval = m_subExpr1->getExprValue()->u.dval - m_subExpr2->getExprValue()->u.dval;
983 : 0 : break;
984 : : case EC_mul:
985 : 0 : retval->u.dval = m_subExpr1->getExprValue()->u.dval * m_subExpr2->getExprValue()->u.dval;
986 : 0 : break;
987 : : case EC_div:
988 [ # # ]: 0 : if (m_subExpr2->getExprValue()->u.dval == 0.0)
989 : 0 : return NULL;
990 : 0 : retval->u.dval = m_subExpr1->getExprValue()->u.dval / m_subExpr2->getExprValue()->u.dval;
991 : 0 : break;
992 : : default:
993 : 0 : return NULL;
994 : : }
995 : :
996 : 100 : return retval.release();
997 : : }
998 : :
999 : 32 : AstExprValue* AstExpression::eval_bit_op(EvalKind ek)
1000 : : {
1001 [ - + ][ # # ]: 32 : if (ek != EK_const && ek != EK_positive_int)
1002 : 0 : return NULL;
1003 [ + - ][ - + ]: 32 : if (m_subExpr1 == NULL || m_subExpr2 == NULL)
1004 : 0 : return NULL;
1005 [ + - ]: 32 : m_subExpr1->setExprValue(m_subExpr1->eval_internal(ek));
1006 [ - + ]: 32 : if (m_subExpr1->getExprValue() == NULL)
1007 : 0 : return NULL;
1008 [ + - ]: 32 : m_subExpr1->setExprValue(m_subExpr1->coerce(ET_long));
1009 [ - + ]: 32 : if (m_subExpr1->getExprValue() == NULL)
1010 : 0 : return NULL;
1011 [ + - ]: 32 : m_subExpr2->setExprValue(m_subExpr2->eval_internal(ek));
1012 [ - + ]: 32 : if (m_subExpr2->getExprValue() == NULL)
1013 : 0 : return NULL;
1014 [ + - ]: 32 : m_subExpr2->setExprValue(m_subExpr2->coerce(ET_long));
1015 [ - + ]: 32 : if (m_subExpr2->getExprValue() == NULL)
1016 : 0 : return NULL;
1017 : :
1018 : : SAL_WNODEPRECATED_DECLARATIONS_PUSH
1019 [ + - ]: 32 : std::auto_ptr< AstExprValue > retval(new AstExprValue());
1020 : : SAL_WNODEPRECATED_DECLARATIONS_POP
1021 : 32 : retval->et = ET_long;
1022 : :
1023 [ + - - - : 32 : switch (m_combOperator)
- - ]
1024 : : {
1025 : : case EC_or:
1026 : 32 : retval->u.lval = m_subExpr1->getExprValue()->u.lval | m_subExpr2->getExprValue()->u.lval;
1027 : 32 : break;
1028 : : case EC_xor:
1029 : 0 : retval->u.lval = m_subExpr1->getExprValue()->u.lval ^ m_subExpr2->getExprValue()->u.lval;
1030 : 0 : break;
1031 : : case EC_and:
1032 : 0 : retval->u.lval = m_subExpr1->getExprValue()->u.lval & m_subExpr2->getExprValue()->u.lval;
1033 : 0 : break;
1034 : : case EC_left:
1035 : 0 : retval->u.lval = m_subExpr1->getExprValue()->u.lval << m_subExpr2->getExprValue()->u.lval;
1036 : 0 : break;
1037 : : case EC_right:
1038 : 0 : retval->u.lval = m_subExpr1->getExprValue()->u.lval >> m_subExpr2->getExprValue()->u.lval;
1039 : 0 : break;
1040 : : default:
1041 : 0 : return NULL;
1042 : : }
1043 : :
1044 : 32 : return retval.release();
1045 : : }
1046 : :
1047 : 0 : AstExprValue* AstExpression::eval_un_op(EvalKind ek)
1048 : : {
1049 [ # # ]: 0 : if (m_exprValue != NULL)
1050 : 0 : return m_exprValue;
1051 : :
1052 [ # # ][ # # ]: 0 : if (ek != EK_const && ek != EK_positive_int)
1053 : 0 : return NULL;
1054 [ # # ]: 0 : if (m_subExpr1 == NULL)
1055 : 0 : return NULL;
1056 [ # # ]: 0 : m_subExpr1->setExprValue(m_subExpr1->eval_internal(ek));
1057 [ # # ]: 0 : if (m_subExpr1->getExprValue() == NULL)
1058 : 0 : return NULL;
1059 [ # # ]: 0 : m_subExpr1->setExprValue(m_subExpr1->coerce(ET_double));
1060 [ # # ]: 0 : if (m_subExpr1->getExprValue() == NULL)
1061 : 0 : return NULL;
1062 : :
1063 : : SAL_WNODEPRECATED_DECLARATIONS_PUSH
1064 [ # # ]: 0 : std::auto_ptr< AstExprValue > retval(new AstExprValue());
1065 : : SAL_WNODEPRECATED_DECLARATIONS_POP
1066 : 0 : retval->et = ET_double;
1067 : :
1068 [ # # # # ]: 0 : switch (m_combOperator)
1069 : : {
1070 : : case EC_u_plus:
1071 : 0 : retval->u.lval = m_subExpr1->getExprValue()->u.lval;
1072 : 0 : break;
1073 : : case EC_u_minus:
1074 : 0 : retval->u.lval = -(m_subExpr1->getExprValue()->u.lval);
1075 : 0 : break;
1076 : : case EC_bit_neg:
1077 [ # # ]: 0 : m_subExpr1->setExprValue(m_subExpr1->coerce(ET_long));
1078 [ # # ]: 0 : if (m_subExpr1->getExprValue() == NULL)
1079 : 0 : return NULL;
1080 : 0 : retval->u.lval = ~m_subExpr1->getExprValue()->u.lval;
1081 : 0 : break;
1082 : : default:
1083 : 0 : return NULL;
1084 : : }
1085 : :
1086 : 0 : return retval.release();
1087 : : }
1088 : :
1089 : 193 : AstExprValue* AstExpression::eval_symbol(EvalKind ek)
1090 : : {
1091 : 193 : AstScope *pScope = 0;
1092 : : AstDeclaration *pDecl;
1093 : : AstConstant *pConst;
1094 : :
1095 : : /*
1096 : : * Is there a symbol stored?
1097 : : */
1098 [ - + ]: 193 : if (m_pSymbolicName == NULL)
1099 : : {
1100 : 0 : idlc()->error()->evalError(this);
1101 : 0 : return NULL;
1102 : : }
1103 : : /*
1104 : : * Get current scope for lookup
1105 : : */
1106 [ + - ]: 193 : if (idlc()->scopes()->depth() > 0)
1107 : 193 : pScope = idlc()->scopes()->topNonNull();
1108 [ - + ]: 193 : if ( !pScope )
1109 : : {
1110 : 0 : idlc()->error()->lookupError(*m_pSymbolicName);
1111 : 0 : return NULL;
1112 : : }
1113 : : /*
1114 : : * Do lookup
1115 : : */
1116 : 193 : pDecl = pScope->lookupByName(*m_pSymbolicName);
1117 [ - + ]: 193 : if (pDecl == NULL)
1118 : : {
1119 : 0 : idlc()->error()->lookupError(*m_pSymbolicName);
1120 : 0 : return NULL;
1121 : : }
1122 : : /*
1123 : : * Is it a constant?
1124 : : */
1125 [ - + # # ]: 193 : if (pDecl->getNodeType() != NT_const &&
[ - + ]
1126 : 0 : pDecl->getNodeType() != NT_enum_val)
1127 : : {
1128 : 0 : idlc()->error()->constantExpected(pDecl, *m_pSymbolicName);
1129 : 0 : return NULL;
1130 : : }
1131 [ - + ]: 193 : if (!idlc()->error()->checkPublished(pDecl))
1132 : : {
1133 : 0 : return NULL;
1134 : : }
1135 : : /*
1136 : : * OK, now evaluate the constant we just got, to produce its value
1137 : : */
1138 : 193 : pConst = static_cast< AstConstant* >(pDecl);
1139 [ - + ]: 193 : if (pConst == NULL)
1140 : 0 : return NULL;
1141 : 193 : return pConst->getConstValue()->eval_internal(ek);
1142 : : }
1143 : :
1144 : 0 : OString AstExpression::toString()
1145 : : {
1146 : 0 : OString exprStr;
1147 [ # # ]: 0 : if ( m_combOperator == EC_symbol )
1148 : 0 : return *m_pSymbolicName;
1149 : :
1150 [ # # ]: 0 : if ( m_exprValue )
1151 : : {
1152 [ # # # # : 0 : switch (m_exprValue->et)
# # # # #
# # ]
1153 : : {
1154 : : case ET_short:
1155 : 0 : return OString::valueOf((sal_Int32)m_exprValue->u.sval);
1156 : : case ET_ushort:
1157 : 0 : return OString::valueOf((sal_Int32)m_exprValue->u.usval);
1158 : : case ET_long:
1159 : 0 : return OString::valueOf(m_exprValue->u.lval);
1160 : : case ET_ulong:
1161 : 0 : return OString::valueOf((sal_Int32)m_exprValue->u.ulval);
1162 : : case ET_hyper:
1163 : 0 : return OString::valueOf(m_exprValue->u.hval);
1164 : : case ET_uhyper:
1165 : 0 : return OString::valueOf((sal_Int64)m_exprValue->u.uhval);
1166 : : case ET_float:
1167 : 0 : return OString::valueOf(m_exprValue->u.fval);
1168 : : case ET_double:
1169 : 0 : return OString::valueOf(m_exprValue->u.dval);
1170 : : case ET_byte:
1171 : 0 : return OString::valueOf((sal_Int32)m_exprValue->u.byval);
1172 : : case ET_boolean:
1173 [ # # ]: 0 : if ( m_exprValue->u.lval == 0)
1174 : 0 : return OString("FALSE");
1175 : : else
1176 : 0 : return OString("TRUE");
1177 : : default:
1178 : : OSL_ASSERT(false);
1179 : 0 : return OString();
1180 : : }
1181 : : }
1182 : :
1183 [ # # # # ]: 0 : switch (m_combOperator)
1184 : : {
1185 : : case EC_u_plus:
1186 : 0 : exprStr += OString("+");
1187 : 0 : break;
1188 : : case EC_u_minus:
1189 : 0 : exprStr += OString("-");
1190 : 0 : break;
1191 : : case EC_bit_neg:
1192 : 0 : exprStr += OString("~");
1193 : 0 : break;
1194 : : default:
1195 : 0 : break;
1196 : : }
1197 [ # # ]: 0 : if ( m_subExpr1 )
1198 [ # # ]: 0 : exprStr += m_subExpr1->toString();
1199 [ # # # # : 0 : switch (m_combOperator)
# # # # #
# # ]
1200 : : {
1201 : : case EC_add:
1202 : 0 : exprStr += OString(" + ");
1203 : 0 : break;
1204 : : case EC_minus:
1205 : 0 : exprStr += OString(" - ");
1206 : 0 : break;
1207 : : case EC_mul:
1208 : 0 : exprStr += OString(" * ");
1209 : 0 : break;
1210 : : case EC_div:
1211 : 0 : exprStr += OString(" / ");
1212 : 0 : break;
1213 : : case EC_mod:
1214 : 0 : exprStr += OString(" % ");
1215 : 0 : break;
1216 : : case EC_or:
1217 : 0 : exprStr += OString(" | ");
1218 : 0 : break;
1219 : : case EC_xor:
1220 : 0 : exprStr += OString(" ^ ");
1221 : 0 : break;
1222 : : case EC_and:
1223 : 0 : exprStr += OString(" & ");
1224 : 0 : break;
1225 : : case EC_left:
1226 : 0 : exprStr += OString(" << ");
1227 : 0 : break;
1228 : : case EC_right:
1229 : 0 : exprStr += OString(" >> ");
1230 : 0 : break;
1231 : : default:
1232 : 0 : break;
1233 : : }
1234 : :
1235 [ # # ]: 0 : if ( m_subExpr2 )
1236 [ # # ]: 0 : exprStr += m_subExpr2->toString();
1237 : :
1238 : 0 : return exprStr;
1239 : : }
1240 : :
1241 : : // Convert the type of an AST_Expression to a char *
1242 : 12202 : const sal_Char* SAL_CALL exprTypeToString(ExprType t)
1243 : : {
1244 [ + + + + : 12202 : switch (t)
+ + + - -
+ - - - -
- - - ]
1245 : : {
1246 : : case ET_short:
1247 : 2450 : return "short";
1248 : : case ET_ushort:
1249 : 2 : return "unsigned short";
1250 : : case ET_long:
1251 : 9406 : return "long";
1252 : : case ET_ulong:
1253 : 41 : return "unsigned long";
1254 : : case ET_hyper:
1255 : 31 : return "hyper";
1256 : : case ET_uhyper:
1257 : 2 : return "unsigned hyper";
1258 : : case ET_float:
1259 : 20 : return "float";
1260 : : case ET_double:
1261 : 0 : return "double";
1262 : : case ET_char:
1263 : 0 : return "char";
1264 : : case ET_byte:
1265 : 250 : return "byte";
1266 : : case ET_boolean:
1267 : 0 : return "boolean";
1268 : : case ET_string:
1269 : 0 : return "string";
1270 : : case ET_any:
1271 : 0 : return "any";
1272 : : case ET_type:
1273 : 0 : return "type";
1274 : : case ET_void:
1275 : 0 : return "void";
1276 : : case ET_none:
1277 : 0 : return "none";
1278 : : }
1279 : :
1280 : 12202 : return ("unkown");
1281 : : }
1282 : :
1283 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
