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