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