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