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 66 : 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 66 : , m_pSymbolicName(NULL)
43 : {
44 66 : fillDefinitionDetails();
45 :
46 66 : }
47 :
48 63608 : AstExpression::AstExpression(sal_Int32 l)
49 : : m_combOperator(EC_none)
50 : , m_subExpr1(NULL)
51 : , m_subExpr2(NULL)
52 : , m_exprValue(NULL)
53 63608 : , m_pSymbolicName(NULL)
54 : {
55 63608 : fillDefinitionDetails();
56 :
57 63608 : m_exprValue = new AstExprValue();
58 63608 : m_exprValue->et = ET_long;
59 63608 : m_exprValue->u.lval = l;
60 63608 : }
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 13984 : AstExpression::AstExpression(sal_Int64 h)
77 : : m_combOperator(EC_none)
78 : , m_subExpr1(NULL)
79 : , m_subExpr2(NULL)
80 : , m_exprValue(NULL)
81 13984 : , m_pSymbolicName(NULL)
82 : {
83 13984 : fillDefinitionDetails();
84 :
85 13984 : m_exprValue = new AstExprValue();
86 13984 : m_exprValue->et = ET_hyper;
87 13984 : m_exprValue->u.hval = h;
88 13984 : }
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 98 : AstExpression::AstExpression(::rtl::OString* scopedName)
119 : : m_combOperator(EC_symbol)
120 : , m_subExpr1(NULL)
121 : , m_subExpr2(NULL)
122 : , m_exprValue(NULL)
123 98 : , m_pSymbolicName(scopedName)
124 : {
125 98 : fillDefinitionDetails();
126 98 : }
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 14105 : coerce_value(AstExprValue *ev, ExprType t)
147 : {
148 14105 : if (ev == NULL)
149 0 : return NULL;
150 :
151 14105 : switch (t)
152 : {
153 : case ET_short:
154 2975 : switch (ev->et)
155 : {
156 : case ET_short:
157 17 : 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 2908 : if (ev->u.hval < SAL_MIN_INT16 || ev->u.hval > SAL_MAX_INT16)
178 0 : return NULL;
179 2908 : ev->u.sval = (sal_Int16)ev->u.hval;
180 2908 : ev->et = ET_short;
181 2908 : 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 50 : if (ev->u.dval < SAL_MIN_INT16 || ev->u.dval > SAL_MAX_INT16)
200 0 : return NULL;
201 50 : ev->u.sval = (sal_Int16)ev->u.dval;
202 50 : ev->et = ET_short;
203 50 : 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 10517 : 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 15 : 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 10502 : if (ev->u.hval < SAL_MIN_INT32 || ev->u.hval > SAL_MAX_INT32)
292 0 : return NULL;
293 10502 : ev->u.lval = (sal_Int32)ev->u.hval;
294 10502 : ev->et = ET_long;
295 10502 : 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 2 : 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 2 : if (ev->u.hval < 0 || ev->u.hval > SAL_MAX_UINT32)
349 0 : return NULL;
350 2 : ev->u.lval = (sal_uInt32)ev->u.hval;
351 2 : ev->et = ET_ulong;
352 2 : 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;
494 0 : ev->et = ET_boolean;
495 0 : return ev;
496 : case ET_ushort:
497 0 : ev->u.bval = ev->u.usval != 0;
498 0 : ev->et = ET_boolean;
499 0 : return ev;
500 : case ET_long:
501 0 : ev->u.bval = ev->u.lval != 0;
502 0 : ev->et = ET_boolean;
503 0 : return ev;
504 : case ET_ulong:
505 0 : ev->u.bval = ev->u.ulval != 0;
506 0 : ev->et = ET_boolean;
507 0 : return ev;
508 : case ET_hyper:
509 0 : ev->u.bval = ev->u.hval != 0;
510 0 : ev->et = ET_boolean;
511 0 : return ev;
512 : case ET_uhyper:
513 0 : ev->u.bval = ev->u.uhval != 0;
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;
520 0 : ev->et = ET_boolean;
521 0 : return ev;
522 : case ET_double:
523 0 : ev->u.bval = ev->u.dval != 0.0;
524 0 : ev->et = ET_boolean;
525 0 : return ev;
526 : case ET_byte:
527 0 : ev->u.bval = ev->u.byval != 0;
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 ? 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 100 : switch (ev->et)
585 : {
586 : case ET_short:
587 50 : ev->u.dval = (double)ev->u.sval;
588 50 : ev->et = ET_double;
589 50 : 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 50 : ev->u.dval = (double)ev->u.hval;
604 50 : ev->et = ET_double;
605 50 : 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 ? 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 488 : 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 488 : if (ev->u.hval < SAL_MIN_INT8 || ev->u.hval > SAL_MAX_UINT8)
659 0 : return NULL;
660 488 : ev->u.byval = (sal_uChar) ev->u.hval;
661 488 : ev->et = ET_byte;
662 488 : 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 ? 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 0 : 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 3529503 : eval_kind(AstExprValue *ev, EvalKind ek)
706 : {
707 3529503 : if (ek == EK_const)
708 3529503 : return ev;
709 0 : if (ek == EK_positive_int)
710 0 : return coerce_value(ev, ET_ulong);
711 :
712 0 : return NULL;
713 : }
714 :
715 14169 : AstExprValue* AstExpression::coerce(ExprType t, sal_Bool bAssign)
716 : {
717 : AstExprValue *copy;
718 :
719 : /*
720 : * Is it already of the right type?
721 : */
722 14169 : if (m_exprValue != NULL && m_exprValue->et == t)
723 64 : 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 14105 : m_exprValue = eval_internal(EK_const);
731 14105 : if (m_exprValue == NULL)
732 0 : return NULL;
733 :
734 : /*
735 : * Create a copy to contain coercion result
736 : */
737 14105 : copy = new AstExprValue;
738 :
739 14105 : copy->et = m_exprValue->et;
740 14105 : switch (m_exprValue->et)
741 : {
742 : case ET_short:
743 67 : copy->u.sval = m_exprValue->u.sval;
744 67 : break;
745 : case ET_ushort:
746 0 : copy->u.usval = m_exprValue->u.usval;
747 0 : break;
748 : case ET_long:
749 15 : copy->u.lval = m_exprValue->u.lval;
750 15 : break;
751 : case ET_ulong:
752 0 : copy->u.ulval = m_exprValue->u.ulval;
753 0 : break;
754 : case ET_hyper:
755 13953 : copy->u.hval = m_exprValue->u.hval;
756 13953 : 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 70 : copy->u.dval = m_exprValue->u.dval;
768 70 : 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 14105 : AstExprValue* const coerced(coerce_value(copy, t));
778 14105 : if (!coerced)
779 0 : delete copy;
780 :
781 14105 : if (bAssign)
782 14105 : m_exprValue = coerced;
783 :
784 14105 : return coerced;
785 : }
786 :
787 1757584 : void AstExpression::evaluate(EvalKind ek)
788 : {
789 1757584 : m_exprValue = eval_internal(ek);
790 1757584 : m_exprValue = eval_kind(m_exprValue, ek);
791 1757584 : }
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 878559 : sal_Bool AstExpression::compare(AstExpression *pExpr)
846 : {
847 878559 : bool bRet = sal_False;
848 878559 : if (m_combOperator != pExpr->getCombOperator())
849 0 : return bRet;
850 878559 : evaluate(EK_const);
851 878559 : pExpr->evaluate(EK_const);
852 878559 : if (m_exprValue == NULL || pExpr->getExprValue() == NULL)
853 0 : return bRet;
854 878559 : if (m_exprValue->et != pExpr->getExprValue()->et)
855 0 : return bRet;
856 878559 : 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 878559 : bRet = (m_exprValue->u.lval == pExpr->getExprValue()->u.lval) ? sal_True : sal_False;
866 878559 : 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 878559 : return bRet;
894 : }
895 :
896 77777 : void AstExpression::fillDefinitionDetails()
897 : {
898 77777 : m_pScope = idlc()->scopes()->depth() > 0 ? idlc()->scopes()->top() : NULL;
899 77777 : m_lineNo = idlc()->getLineNumber();
900 77777 : m_fileName = idlc()->getFileName();
901 77777 : }
902 :
903 1771919 : AstExprValue* AstExpression::eval_internal(EvalKind ek)
904 : {
905 : /*
906 : * Already evaluated?
907 : */
908 1771919 : if ( m_exprValue != NULL )
909 1771755 : return eval_kind(m_exprValue, ek);
910 : /*
911 : * OK, must evaluate operator
912 : */
913 164 : 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 50 : m_exprValue = eval_bin_op(ek);
921 50 : 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 16 : m_exprValue = eval_bit_op(ek);
928 16 : 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 98 : m_exprValue = eval_symbol(ek);
936 98 : return eval_kind(m_exprValue, ek);
937 : case EC_none:
938 0 : return NULL;
939 : }
940 :
941 0 : return NULL;
942 : }
943 :
944 50 : AstExprValue* AstExpression::eval_bin_op(EvalKind ek)
945 : {
946 50 : ExprType eType = ET_double;
947 :
948 50 : if ( m_combOperator == EC_mod )
949 0 : eType = ET_hyper;
950 :
951 50 : if (ek != EK_const && ek != EK_positive_int)
952 0 : return NULL;
953 50 : if (m_subExpr1 == NULL || m_subExpr2 == NULL)
954 0 : return NULL;
955 50 : m_subExpr1->setExprValue(m_subExpr1->eval_internal(ek));
956 50 : if (m_subExpr1->getExprValue() == NULL)
957 0 : return NULL;
958 50 : m_subExpr1->setExprValue(m_subExpr1->coerce(eType));
959 50 : if (m_subExpr1->getExprValue() == NULL)
960 0 : return NULL;
961 50 : m_subExpr2->setExprValue(m_subExpr2->eval_internal(ek));
962 50 : if (m_subExpr2->getExprValue() == NULL)
963 0 : return NULL;
964 50 : m_subExpr2->setExprValue(m_subExpr2->coerce(eType));
965 50 : if (m_subExpr2->getExprValue() == NULL)
966 0 : return NULL;
967 :
968 50 : std::auto_ptr< AstExprValue > retval(new AstExprValue());
969 50 : retval->et = eType;
970 :
971 50 : 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 50 : retval->u.dval = m_subExpr1->getExprValue()->u.dval + m_subExpr2->getExprValue()->u.dval;
980 50 : 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 50 : return retval.release();
997 : }
998 :
999 16 : AstExprValue* AstExpression::eval_bit_op(EvalKind ek)
1000 : {
1001 16 : if (ek != EK_const && ek != EK_positive_int)
1002 0 : return NULL;
1003 16 : if (m_subExpr1 == NULL || m_subExpr2 == NULL)
1004 0 : return NULL;
1005 16 : m_subExpr1->setExprValue(m_subExpr1->eval_internal(ek));
1006 16 : if (m_subExpr1->getExprValue() == NULL)
1007 0 : return NULL;
1008 16 : m_subExpr1->setExprValue(m_subExpr1->coerce(ET_long));
1009 16 : if (m_subExpr1->getExprValue() == NULL)
1010 0 : return NULL;
1011 16 : m_subExpr2->setExprValue(m_subExpr2->eval_internal(ek));
1012 16 : if (m_subExpr2->getExprValue() == NULL)
1013 0 : return NULL;
1014 16 : m_subExpr2->setExprValue(m_subExpr2->coerce(ET_long));
1015 16 : if (m_subExpr2->getExprValue() == NULL)
1016 0 : return NULL;
1017 :
1018 : SAL_WNODEPRECATED_DECLARATIONS_PUSH
1019 16 : std::auto_ptr< AstExprValue > retval(new AstExprValue());
1020 : SAL_WNODEPRECATED_DECLARATIONS_POP
1021 16 : retval->et = ET_long;
1022 :
1023 16 : switch (m_combOperator)
1024 : {
1025 : case EC_or:
1026 16 : retval->u.lval = m_subExpr1->getExprValue()->u.lval | m_subExpr2->getExprValue()->u.lval;
1027 16 : 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 16 : 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 98 : AstExprValue* AstExpression::eval_symbol(EvalKind ek)
1090 : {
1091 98 : AstScope *pScope = 0;
1092 : AstDeclaration *pDecl;
1093 : AstConstant *pConst;
1094 :
1095 : /*
1096 : * Is there a symbol stored?
1097 : */
1098 98 : 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 98 : if (idlc()->scopes()->depth() > 0)
1107 98 : pScope = idlc()->scopes()->topNonNull();
1108 98 : if ( !pScope )
1109 : {
1110 0 : idlc()->error()->lookupError(*m_pSymbolicName);
1111 0 : return NULL;
1112 : }
1113 : /*
1114 : * Do lookup
1115 : */
1116 98 : pDecl = pScope->lookupByName(*m_pSymbolicName);
1117 98 : if (pDecl == NULL)
1118 : {
1119 0 : idlc()->error()->lookupError(*m_pSymbolicName);
1120 0 : return NULL;
1121 : }
1122 : /*
1123 : * Is it a constant?
1124 : */
1125 98 : 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 98 : 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 98 : pConst = static_cast< AstConstant* >(pDecl);
1139 98 : if (pConst == NULL)
1140 0 : return NULL;
1141 98 : 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 11695 : const sal_Char* SAL_CALL exprTypeToString(ExprType t)
1243 : {
1244 11695 : switch (t)
1245 : {
1246 : case ET_short:
1247 2043 : return "short";
1248 : case ET_ushort:
1249 2 : return "unsigned short";
1250 : case ET_long:
1251 9347 : return "long";
1252 : case ET_ulong:
1253 2 : 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 248 : 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 0 : return ("unkown");
1281 : }
1282 :
1283 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
