Branch data Line data Source code
1 : : /* do not edit automatically generated by mc from M2ALU. */
2 : : /* M2ALU.mod gcc implementation of the M2ALU module.
3 : :
4 : : Copyright (C) 2001-2024 Free Software Foundation, Inc.
5 : : Contributed by Gaius Mulley <gaius.mulley@southwales.ac.uk>.
6 : :
7 : : This file is part of GNU Modula-2.
8 : :
9 : : GNU Modula-2 is free software; you can redistribute it and/or modify
10 : : it under the terms of the GNU General Public License as published by
11 : : the Free Software Foundation; either version 3, or (at your option)
12 : : any later version.
13 : :
14 : : GNU Modula-2 is distributed in the hope that it will be useful, but
15 : : WITHOUT ANY WARRANTY; without even the implied warranty of
16 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 : : General Public License for more details.
18 : :
19 : : You should have received a copy of the GNU General Public License
20 : : along with GNU Modula-2; see the file COPYING3. If not see
21 : : <http://www.gnu.org/licenses/>. */
22 : :
23 : : #include "config.h"
24 : : #include "system.h"
25 : : #include "gcc-consolidation.h"
26 : :
27 : : #include <stdbool.h>
28 : : # if !defined (PROC_D)
29 : : # define PROC_D
30 : : typedef void (*PROC_t) (void);
31 : : typedef struct { PROC_t proc; } PROC;
32 : : # endif
33 : :
34 : : # if !defined (TRUE)
35 : : # define TRUE (1==1)
36 : : # endif
37 : :
38 : : # if !defined (FALSE)
39 : : # define FALSE (1==0)
40 : : # endif
41 : :
42 : : # include "GStorage.h"
43 : : # include "Gmcrts.h"
44 : : #if defined(__cplusplus)
45 : : # undef NULL
46 : : # define NULL 0
47 : : #endif
48 : : #define _M2ALU_C
49 : :
50 : : #include "GM2ALU.h"
51 : : # include "GASCII.h"
52 : : # include "GSYSTEM.h"
53 : : # include "GNameKey.h"
54 : : # include "GM2Error.h"
55 : : # include "GM2Debug.h"
56 : : # include "GStorage.h"
57 : : # include "GStringConvert.h"
58 : : # include "GM2GCCDeclare.h"
59 : : # include "GM2GenGCC.h"
60 : : # include "GM2Bitset.h"
61 : : # include "GSymbolConversion.h"
62 : : # include "GM2Printf.h"
63 : : # include "GM2Base.h"
64 : : # include "GDynamicStrings.h"
65 : : # include "GM2LexBuf.h"
66 : : # include "GM2MetaError.h"
67 : : # include "GSymbolTable.h"
68 : : # include "Ggcctypes.h"
69 : : # include "Gm2linemap.h"
70 : : # include "Gm2expr.h"
71 : : # include "Gm2decl.h"
72 : : # include "Gm2misc.h"
73 : : # include "Gm2type.h"
74 : : # include "Gm2convert.h"
75 : : # include "Gm2block.h"
76 : :
77 : : # define Debugging false
78 : : # define DebugGarbage true
79 : : typedef struct M2ALU_rList_r M2ALU_rList;
80 : :
81 : : typedef M2ALU_rList *M2ALU_listOfRange;
82 : :
83 : : typedef struct M2ALU_fList_r M2ALU_fList;
84 : :
85 : : typedef M2ALU_fList *M2ALU_listOfFields;
86 : :
87 : : typedef struct M2ALU_eList_r M2ALU_eList;
88 : :
89 : : typedef M2ALU_eList *M2ALU_listOfElements;
90 : :
91 : : typedef struct M2ALU_cell_r M2ALU_cell;
92 : :
93 : : typedef struct M2ALU_DoSetProcedure_p M2ALU_DoSetProcedure;
94 : :
95 : : typedef enum {M2ALU_none, M2ALU_integer, M2ALU_real, M2ALU_complex, M2ALU_set, M2ALU_constructor, M2ALU_array, M2ALU_record} M2ALU_cellType;
96 : :
97 : : typedef M2ALU_cell *M2ALU_PtrToValue__opaque;
98 : :
99 : : struct M2ALU_rList_r {
100 : : unsigned int low;
101 : : unsigned int high;
102 : : M2ALU_listOfRange next;
103 : : };
104 : :
105 : : struct M2ALU_fList_r {
106 : : unsigned int field;
107 : : M2ALU_listOfFields next;
108 : : };
109 : :
110 : : struct M2ALU_eList_r {
111 : : unsigned int element;
112 : : unsigned int by;
113 : : M2ALU_listOfElements next;
114 : : };
115 : :
116 : : struct M2ALU_cell_r {
117 : : location_t location;
118 : : bool areAllConstants;
119 : : bool solved;
120 : : unsigned int constructorType;
121 : : M2ALU_PtrToValue__opaque next;
122 : : tree numberValue;
123 : : M2ALU_cellType type; /* case tag */
124 : : union {
125 : : M2ALU_listOfRange setValue;
126 : : M2ALU_listOfFields fieldValues;
127 : : M2ALU_listOfElements arrayValues;
128 : : };
129 : : };
130 : :
131 : : typedef M2ALU_listOfRange (*M2ALU_DoSetProcedure_t) (unsigned int, M2ALU_listOfRange, M2ALU_listOfRange);
132 : : struct M2ALU_DoSetProcedure_p { M2ALU_DoSetProcedure_t proc; };
133 : :
134 : : static M2ALU_listOfElements ElementFreeList;
135 : : static M2ALU_listOfFields FieldFreeList;
136 : : static M2ALU_listOfRange RangeFreeList;
137 : : static M2ALU_PtrToValue__opaque FreeList;
138 : : static M2ALU_PtrToValue__opaque TopOfStack;
139 : : static tree EnumerationValue;
140 : : static unsigned int EnumerationField;
141 : : static unsigned int CurrentTokenNo;
142 : :
143 : : /*
144 : : InitValue - initializes and returns a memory cell.
145 : : */
146 : :
147 : : extern "C" M2ALU_PtrToValue M2ALU_InitValue (void);
148 : :
149 : : /*
150 : : IsValueTypeNone - returns TRUE if the value on the top stack has no value.
151 : : */
152 : :
153 : : extern "C" bool M2ALU_IsValueTypeNone (void);
154 : :
155 : : /*
156 : : IsValueTypeInteger - returns TRUE if the value on the top stack is an integer.
157 : : */
158 : :
159 : : extern "C" bool M2ALU_IsValueTypeInteger (void);
160 : :
161 : : /*
162 : : IsValueTypeReal - returns TRUE if the value on the top stack is a real.
163 : : */
164 : :
165 : : extern "C" bool M2ALU_IsValueTypeReal (void);
166 : :
167 : : /*
168 : : IsValueTypeComplex - returns TRUE if the value on the top stack is a complex.
169 : : */
170 : :
171 : : extern "C" bool M2ALU_IsValueTypeComplex (void);
172 : :
173 : : /*
174 : : IsValueTypeSet - returns TRUE if the value on the top stack is a set.
175 : : */
176 : :
177 : : extern "C" bool M2ALU_IsValueTypeSet (void);
178 : :
179 : : /*
180 : : IsValueTypeConstructor - returns TRUE if the value on the top
181 : : stack is a constructor.
182 : : */
183 : :
184 : : extern "C" bool M2ALU_IsValueTypeConstructor (void);
185 : :
186 : : /*
187 : : IsValueTypeArray - returns TRUE if the value on the top stack is
188 : : an array.
189 : : */
190 : :
191 : : extern "C" bool M2ALU_IsValueTypeArray (void);
192 : :
193 : : /*
194 : : IsValueTypeRecord - returns TRUE if the value on the top stack is
195 : : a record.
196 : : */
197 : :
198 : : extern "C" bool M2ALU_IsValueTypeRecord (void);
199 : :
200 : : /*
201 : : GetSetValueType - returns the set type on top of the ALU stack.
202 : : */
203 : :
204 : : extern "C" unsigned int M2ALU_GetSetValueType (void);
205 : :
206 : : /*
207 : : PushIntegerTree - pushes a gcc tree value onto the ALU stack.
208 : : */
209 : :
210 : : extern "C" void M2ALU_PushIntegerTree (tree t);
211 : :
212 : : /*
213 : : PopIntegerTree - pops a gcc tree value from the ALU stack.
214 : : */
215 : :
216 : : extern "C" tree M2ALU_PopIntegerTree (void);
217 : :
218 : : /*
219 : : PushRealTree - pushes a gcc tree value onto the ALU stack.
220 : : */
221 : :
222 : : extern "C" void M2ALU_PushRealTree (tree t);
223 : :
224 : : /*
225 : : PopRealTree - pops a gcc tree value from the ALU stack.
226 : : */
227 : :
228 : : extern "C" tree M2ALU_PopRealTree (void);
229 : :
230 : : /*
231 : : PushComplexTree - pushes a gcc tree value onto the ALU stack.
232 : : */
233 : :
234 : : extern "C" void M2ALU_PushComplexTree (tree t);
235 : :
236 : : /*
237 : : PopComplexTree - pops a gcc tree value from the ALU stack.
238 : : */
239 : :
240 : : extern "C" tree M2ALU_PopComplexTree (void);
241 : :
242 : : /*
243 : : PushSetTree - pushes a gcc tree onto the ALU stack.
244 : : The tree, t, is expected to contain a
245 : : word value. It is converted into a set
246 : : type (sym). Bit 0 maps onto MIN(sym).
247 : : */
248 : :
249 : : extern "C" void M2ALU_PushSetTree (unsigned int tokenno, tree t, unsigned int sym);
250 : :
251 : : /*
252 : : PopSetTree - pops a gcc tree from the ALU stack.
253 : : */
254 : :
255 : : extern "C" tree M2ALU_PopSetTree (unsigned int tokenno);
256 : :
257 : : /*
258 : : PopConstructorTree - returns a tree containing the compound literal.
259 : : */
260 : :
261 : : extern "C" tree M2ALU_PopConstructorTree (unsigned int tokenno);
262 : :
263 : : /*
264 : : PushFrom - pushes a copy of the contents of, v, onto stack.
265 : : */
266 : :
267 : : extern "C" void M2ALU_PushFrom (M2ALU_PtrToValue v);
268 : :
269 : : /*
270 : : PopInto - pops the top element from the stack and places it into, v.
271 : : */
272 : :
273 : : extern "C" void M2ALU_PopInto (M2ALU_PtrToValue v);
274 : :
275 : : /*
276 : : PushCard - pushes a cardinal onto the stack.
277 : : */
278 : :
279 : : extern "C" void M2ALU_PushCard (unsigned int c);
280 : :
281 : : /*
282 : : PushInt - pushes an integer onto the stack.
283 : : */
284 : :
285 : : extern "C" void M2ALU_PushInt (int i);
286 : :
287 : : /*
288 : : PushChar - pushes a char onto the stack.
289 : : */
290 : :
291 : : extern "C" void M2ALU_PushChar (char c);
292 : :
293 : : /*
294 : : PopChar - pops a char from the stack.
295 : : */
296 : :
297 : : extern "C" char M2ALU_PopChar (unsigned int tokenno);
298 : :
299 : : /*
300 : : PushString - pushes the numerical value of the string onto the stack.
301 : : */
302 : :
303 : : extern "C" void M2ALU_PushString (unsigned int tokenno, NameKey_Name s, bool issueError);
304 : :
305 : : /*
306 : : CoerseLongRealToCard - performs a coersion between a REAL to a CARDINAL
307 : : */
308 : :
309 : : extern "C" void M2ALU_CoerseLongRealToCard (void);
310 : :
311 : : /*
312 : : ConvertRealToInt - converts a REAL into an INTEGER
313 : : */
314 : :
315 : : extern "C" void M2ALU_ConvertRealToInt (void);
316 : :
317 : : /*
318 : : ConvertToInt - converts the value into an INTEGER. This should be used
319 : : if we are computing the number of elements in a char set to
320 : : avoid an overflow.
321 : : */
322 : :
323 : : extern "C" void M2ALU_ConvertToInt (void);
324 : :
325 : : /*
326 : : ConvertToType - converts the top of stack to type, t.
327 : : */
328 : :
329 : : extern "C" void M2ALU_ConvertToType (unsigned int t);
330 : :
331 : : /*
332 : : IsSolved - returns true if the memory cell indicated by v
333 : : has a known value.
334 : : */
335 : :
336 : : extern "C" bool M2ALU_IsSolved (M2ALU_PtrToValue v);
337 : :
338 : : /*
339 : : PutConstructorSolved - records that this constructor is solved.
340 : : */
341 : :
342 : : extern "C" void M2ALU_PutConstructorSolved (unsigned int sym);
343 : :
344 : : /*
345 : : EvaluateValue - attempts to evaluate the symbol, sym, value.
346 : : */
347 : :
348 : : extern "C" void M2ALU_EvaluateValue (unsigned int sym);
349 : :
350 : : /*
351 : : TryEvaluateValue - attempts to evaluate the symbol, sym, value.
352 : : */
353 : :
354 : : extern "C" void M2ALU_TryEvaluateValue (unsigned int sym);
355 : : extern "C" void M2ALU_Addn (void);
356 : :
357 : : /*
358 : : Sub - subtracts the top two elements on the stack.
359 : :
360 : : The Stack:
361 : :
362 : : Entry Exit
363 : :
364 : : Ptr ->
365 : : +------------+
366 : : | Op1 | <- Ptr
367 : : |------------| +------------+
368 : : | Op2 | | Op2 - Op1 |
369 : : |------------| |------------|
370 : : */
371 : :
372 : : extern "C" void M2ALU_Sub (void);
373 : : extern "C" void M2ALU_Multn (void);
374 : :
375 : : /*
376 : : DivFloor - divides the top two elements on the stack.
377 : :
378 : : The Stack:
379 : :
380 : : Entry Exit
381 : :
382 : : Ptr ->
383 : : +------------+
384 : : | Op1 | <- Ptr
385 : : |------------| +--------------+
386 : : | Op2 | | Op2 DIV Op1 |
387 : : |------------| |--------------|
388 : : */
389 : :
390 : : extern "C" void M2ALU_DivFloor (void);
391 : :
392 : : /*
393 : : ModFloor - modulus of the top two elements on the stack.
394 : :
395 : : The Stack:
396 : :
397 : : Entry Exit
398 : :
399 : : Ptr ->
400 : : +------------+
401 : : | Op1 | <- Ptr
402 : : |------------| +--------------+
403 : : | Op2 | | Op2 MOD Op1 |
404 : : |------------| |--------------|
405 : : */
406 : :
407 : : extern "C" void M2ALU_ModFloor (void);
408 : :
409 : : /*
410 : : DivTrunc - divides the top two elements on the stack.
411 : :
412 : : The Stack:
413 : :
414 : : Entry Exit
415 : :
416 : : Ptr ->
417 : : +------------+
418 : : | Op1 | <- Ptr
419 : : |------------| +--------------+
420 : : | Op2 | | Op2 DIV Op1 |
421 : : |------------| |--------------|
422 : : */
423 : :
424 : : extern "C" void M2ALU_DivTrunc (void);
425 : :
426 : : /*
427 : : ModTrunc - modulus of the top two elements on the stack.
428 : :
429 : : The Stack:
430 : :
431 : : Entry Exit
432 : :
433 : : Ptr ->
434 : : +------------+
435 : : | Op1 | <- Ptr
436 : : |------------| +--------------+
437 : : | Op2 | | Op2 MOD Op1 |
438 : : |------------| |--------------|
439 : : */
440 : :
441 : : extern "C" void M2ALU_ModTrunc (void);
442 : :
443 : : /*
444 : : Equ - returns true if the top two elements on the stack
445 : : are identical.
446 : :
447 : : The Stack:
448 : :
449 : : Entry Exit
450 : :
451 : : Ptr ->
452 : : +------------+
453 : : | Op1 |
454 : : |------------|
455 : : | Op2 |
456 : : |------------| Empty
457 : :
458 : : RETURN( Op2 = Op1 )
459 : : */
460 : :
461 : : extern "C" bool M2ALU_Equ (unsigned int tokenno);
462 : :
463 : : /*
464 : : NotEqu - returns true if the top two elements on the stack
465 : : are not identical.
466 : :
467 : : The Stack:
468 : :
469 : : Entry Exit
470 : :
471 : : Ptr ->
472 : : +------------+
473 : : | Op1 |
474 : : |------------|
475 : : | Op2 |
476 : : |------------| Empty
477 : :
478 : : RETURN( Op2 # Op1 )
479 : : */
480 : :
481 : : extern "C" bool M2ALU_NotEqu (unsigned int tokenno);
482 : :
483 : : /*
484 : : Less - returns true if Op2 < Op1
485 : :
486 : : The Stack:
487 : :
488 : : Entry Exit
489 : :
490 : : Ptr ->
491 : : +------------+
492 : : | Op1 |
493 : : |------------|
494 : : | Op2 |
495 : : |------------| Empty
496 : :
497 : : RETURN( Op2 < Op1 )
498 : : */
499 : :
500 : : extern "C" bool M2ALU_Less (unsigned int tokenno);
501 : :
502 : : /*
503 : : Gre - returns true if Op2 > Op1
504 : :
505 : : The Stack:
506 : :
507 : : Entry Exit
508 : :
509 : : Ptr ->
510 : : +------------+
511 : : | Op1 |
512 : : |------------|
513 : : | Op2 |
514 : : |------------| Empty
515 : :
516 : : RETURN( Op2 > Op1 )
517 : : */
518 : :
519 : : extern "C" bool M2ALU_Gre (unsigned int tokenno);
520 : :
521 : : /*
522 : : LessEqu - returns true if Op2<Op1
523 : :
524 : : The Stack:
525 : :
526 : : Entry Exit
527 : :
528 : : Ptr ->
529 : : +------------+
530 : : | Op1 |
531 : : |------------|
532 : : | Op2 |
533 : : |------------| Empty
534 : :
535 : : RETURN( Op2 <= Op1 )
536 : : */
537 : :
538 : : extern "C" bool M2ALU_LessEqu (unsigned int tokenno);
539 : :
540 : : /*
541 : : GreEqu - returns true if Op2 >= Op1
542 : : are not identical.
543 : :
544 : : The Stack:
545 : :
546 : : Entry Exit
547 : :
548 : : Ptr ->
549 : : +------------+
550 : : | Op1 |
551 : : |------------|
552 : : | Op2 |
553 : : |------------| Empty
554 : :
555 : : RETURN( Op2 >= Op1 )
556 : : */
557 : :
558 : : extern "C" bool M2ALU_GreEqu (unsigned int tokenno);
559 : :
560 : : /*
561 : : IsNulSet - returns TRUE if the top element is the nul set constant, {}.
562 : : */
563 : :
564 : : extern "C" bool M2ALU_IsNulSet (void);
565 : :
566 : : /*
567 : : IsGenericNulSet - returns TRUE if the top element is the generic nul set constant, {}.
568 : : */
569 : :
570 : : extern "C" bool M2ALU_IsGenericNulSet (void);
571 : :
572 : : /*
573 : : PushNulSet - pushes an empty set {} onto the ALU stack. The subrange type used
574 : : to construct the set is defined by, constructorType.
575 : : If this is NulSym then
576 : : the set is generic and compatible with all sets.
577 : :
578 : : The Stack:
579 : :
580 : : Entry Exit
581 : :
582 : : <- Ptr
583 : : +------------+
584 : : | {} |
585 : : Ptr -> |------------|
586 : :
587 : : */
588 : :
589 : : extern "C" void M2ALU_PushNulSet (unsigned int settype);
590 : :
591 : : /*
592 : : AddBitRange - adds the range op1..op2 to the underlying set.
593 : :
594 : : Ptr ->
595 : : <- Ptr
596 : : +------------+ +------------+
597 : : | Set | | Set |
598 : : |------------| |------------|
599 : :
600 : : */
601 : :
602 : : extern "C" void M2ALU_AddBitRange (unsigned int tokenno, unsigned int op1, unsigned int op2);
603 : :
604 : : /*
605 : : AddBit - adds the bit op1 to the underlying set. INCL(Set, op1)
606 : :
607 : : Ptr ->
608 : : <- Ptr
609 : : +------------+ +------------+
610 : : | Set | | Set |
611 : : |------------| |------------|
612 : : */
613 : :
614 : : extern "C" void M2ALU_AddBit (unsigned int tokenno, unsigned int op1);
615 : :
616 : : /*
617 : : SubBit - removes a bit op1 from the underlying set. EXCL(Set, Op1)
618 : :
619 : : Ptr ->
620 : : <- Ptr
621 : : +------------+ +------------+
622 : : | Set | | Set |
623 : : |------------| |------------|
624 : : */
625 : :
626 : : extern "C" void M2ALU_SubBit (unsigned int tokenno, unsigned int op1);
627 : :
628 : : /*
629 : : SetIn - returns true if Op2 IN Op1
630 : :
631 : : The Stack:
632 : :
633 : : Entry Exit
634 : :
635 : : Ptr ->
636 : : +------------+
637 : : | Set |
638 : : |------------| Empty
639 : :
640 : : RETURN( Op1 IN Set )
641 : : */
642 : :
643 : : extern "C" bool M2ALU_SetIn (unsigned int tokenno, unsigned int Op1);
644 : :
645 : : /*
646 : : SetOr - performs an inclusive OR of the top two elements on the stack.
647 : :
648 : : The Stack:
649 : :
650 : : Entry Exit
651 : :
652 : : Ptr ->
653 : : +------------+
654 : : | Set1 | <- Ptr
655 : : |------------| +------------+
656 : : | Set2 | | Set1 + Set2|
657 : : |------------| |------------|
658 : :
659 : : */
660 : :
661 : : extern "C" void M2ALU_SetOr (unsigned int tokenno);
662 : :
663 : : /*
664 : : SetAnd - performs a set AND the top two elements on the stack.
665 : :
666 : : The Stack:
667 : :
668 : : Entry Exit
669 : :
670 : : Ptr ->
671 : : +------------+
672 : : | Op1 | <- Ptr
673 : : |------------| +------------+
674 : : | Op2 | | Op2 * Op1 |
675 : : |------------| |------------|
676 : : */
677 : :
678 : : extern "C" void M2ALU_SetAnd (unsigned int tokenno);
679 : :
680 : : /*
681 : : SetDifference - performs a set difference of the top two elements on the stack.
682 : : For each member in the set
683 : : if member in Op2 and not member in Op1
684 : :
685 : : The Stack:
686 : :
687 : : Entry Exit
688 : :
689 : : Ptr ->
690 : : +------------+
691 : : | Op1 | <- Ptr
692 : : |------------| +-------------------+
693 : : | Op2 | | Op2 and (not Op1) |
694 : : |------------| |-------------------|
695 : : */
696 : :
697 : : extern "C" void M2ALU_SetDifference (unsigned int tokenno);
698 : :
699 : : /*
700 : : SetSymmetricDifference - performs a set difference of the top two elements on the stack.
701 : :
702 : : The Stack:
703 : :
704 : : Entry Exit
705 : :
706 : : Ptr ->
707 : : +------------+
708 : : | Op1 | <- Ptr
709 : : |------------| +-------------+
710 : : | Op2 | | Op2 xor Op1 |
711 : : |------------| |-------------|
712 : : */
713 : :
714 : : extern "C" void M2ALU_SetSymmetricDifference (unsigned int tokenno);
715 : :
716 : : /*
717 : : SetNegate - negates the top set on the stack.
718 : :
719 : : Ptr -> <- Ptr
720 : : +-----------+ +------------+
721 : : | Set | | Set |
722 : : |-----------| |------------|
723 : : */
724 : :
725 : : extern "C" void M2ALU_SetNegate (unsigned int tokenno);
726 : :
727 : : /*
728 : : SetShift - if op1 is positive
729 : : then
730 : : result := op2 << op1
731 : : else
732 : : result := op2 >> op1
733 : : fi
734 : :
735 : :
736 : : The Stack:
737 : :
738 : : Entry Exit
739 : :
740 : : Ptr ->
741 : : +------------+
742 : : | Op1 | <- Ptr
743 : : |------------| +------------+
744 : : | Op2 | | result |
745 : : |------------| |------------|
746 : :
747 : : */
748 : :
749 : : extern "C" void M2ALU_SetShift (unsigned int tokenno);
750 : :
751 : : /*
752 : : SetRotate - if op1 is positive
753 : : then
754 : : result := ROTATERIGHT(op2, op1)
755 : : else
756 : : result := ROTATELEFT(op2, op1)
757 : : fi
758 : :
759 : :
760 : : The Stack:
761 : :
762 : : Entry Exit
763 : :
764 : : Ptr ->
765 : : +------------+
766 : : | Op1 | <- Ptr
767 : : |------------| +------------+
768 : : | Op2 | | result |
769 : : |------------| |------------|
770 : : */
771 : :
772 : : extern "C" void M2ALU_SetRotate (unsigned int tokenno);
773 : :
774 : : /*
775 : : GetValue - returns and pops the value from the top of stack.
776 : : */
777 : :
778 : : extern "C" M2ALU_PtrToValue M2ALU_GetValue (unsigned int tokenno);
779 : :
780 : : /*
781 : : GetRange - returns TRUE if range number, n, exists in the value, v.
782 : : A non empty set is defined by having 1..N ranges
783 : : */
784 : :
785 : : extern "C" bool M2ALU_GetRange (M2ALU_PtrToValue v, unsigned int n, unsigned int *low, unsigned int *high);
786 : :
787 : : /*
788 : : ConstructSetConstant - builds a struct of integers which represents the
789 : : set const as defined by, v.
790 : : */
791 : :
792 : : extern "C" tree M2ALU_ConstructSetConstant (unsigned int tokenno, M2ALU_PtrToValue v);
793 : :
794 : : /*
795 : : BuildRange - returns a integer sized constant which represents the
796 : : value {e1..e2}.
797 : : */
798 : :
799 : : extern "C" tree M2ALU_BuildRange (unsigned int tokenno, tree e1, tree e2);
800 : :
801 : : /*
802 : : IsConstructorDependants - return TRUE if all q(dependants) of,
803 : : sym, return TRUE.
804 : : */
805 : :
806 : : extern "C" bool M2ALU_IsConstructorDependants (unsigned int sym, M2GCCDeclare_IsAction q);
807 : :
808 : : /*
809 : : WalkConstructorDependants - walk the constructor, sym, calling
810 : : p for each dependant.
811 : : */
812 : :
813 : : extern "C" void M2ALU_WalkConstructorDependants (unsigned int sym, M2GCCDeclare_WalkAction p);
814 : :
815 : : /*
816 : : IsValueAndTreeKnown - returns TRUE if the value is known and the gcc tree
817 : : is defined.
818 : :
819 : : The Stack:
820 : :
821 : : Entry Exit
822 : :
823 : : Ptr ->
824 : : +------------+
825 : : | Op1 | <- Ptr
826 : : |------------| +------------+
827 : : */
828 : :
829 : : extern "C" bool M2ALU_IsValueAndTreeKnown (void);
830 : :
831 : : /*
832 : : CheckOrResetOverflow - tests to see whether the tree, t, has caused
833 : : an overflow error and if so it generates an
834 : : error message.
835 : : */
836 : :
837 : : extern "C" void M2ALU_CheckOrResetOverflow (unsigned int tokenno, tree t, bool check);
838 : :
839 : : /*
840 : : AddElements - adds the elements, el BY, n, to the array constant.
841 : :
842 : : Ptr ->
843 : : <- Ptr
844 : : +------------+ +------------+
845 : : | Array | | Array |
846 : : |------------| |------------|
847 : :
848 : : */
849 : :
850 : : extern "C" void M2ALU_AddElements (unsigned int tokenno, unsigned int el, unsigned int n);
851 : :
852 : : /*
853 : : AddField - adds the field op1 to the underlying constructor.
854 : :
855 : : Ptr ->
856 : : <- Ptr
857 : : +------------+ +------------+
858 : : | const | | const |
859 : : |------------| |------------|
860 : :
861 : : */
862 : :
863 : : extern "C" void M2ALU_AddField (unsigned int tokenno, unsigned int op1);
864 : :
865 : : /*
866 : : PushEmptyConstructor - pushes an empty constructor {} onto the ALU stack.
867 : : This is expected to be filled in by subsequent
868 : : calls to AddElements, AddRange or AddField.
869 : :
870 : : The Stack:
871 : :
872 : : Entry Exit
873 : :
874 : : <- Ptr
875 : : +------------+
876 : : | {} |
877 : : Ptr -> |------------|
878 : :
879 : : */
880 : :
881 : : extern "C" void M2ALU_PushEmptyConstructor (unsigned int constype);
882 : :
883 : : /*
884 : : PushEmptyArray - pushes an empty array {} onto the ALU stack.
885 : : This is expected to be filled in by subsequent
886 : : calls to AddElements.
887 : :
888 : : The Stack:
889 : :
890 : : Entry Exit
891 : :
892 : : <- Ptr
893 : : +------------+
894 : : | {} |
895 : : Ptr -> |------------|
896 : :
897 : : */
898 : :
899 : : extern "C" void M2ALU_PushEmptyArray (unsigned int arraytype);
900 : :
901 : : /*
902 : : PushEmptyRecord - pushes an empty record {} onto the ALU stack.
903 : : This is expected to be filled in by subsequent
904 : : calls to AddField.
905 : :
906 : : The Stack:
907 : :
908 : : Entry Exit
909 : :
910 : : <- Ptr
911 : : +------------+
912 : : | {} |
913 : : Ptr -> |------------|
914 : :
915 : : */
916 : :
917 : : extern "C" void M2ALU_PushEmptyRecord (unsigned int recordtype);
918 : :
919 : : /*
920 : : ChangeToConstructor - change the top of stack value to a constructor, type.
921 : : (Constructor, Set, Array or Record).
922 : : */
923 : :
924 : : extern "C" void M2ALU_ChangeToConstructor (unsigned int tokenno, unsigned int constype);
925 : :
926 : : /*
927 : : IsValueConst - returns true if the memory cell indicated by v
928 : : is only defined by constants. For example
929 : : no variables are used in the constructor.
930 : : */
931 : :
932 : : extern "C" bool M2ALU_IsValueConst (M2ALU_PtrToValue v);
933 : :
934 : : /*
935 : : PushTypeOfTree - pushes tree, gcc, to the stack and records the
936 : : front end type.
937 : : */
938 : :
939 : : extern "C" void M2ALU_PushTypeOfTree (unsigned int sym, tree gcc);
940 : :
941 : : /*
942 : : New - allocate a PtrToValue. Firstly check the FreeList, if empty call upon New.
943 : : */
944 : :
945 : : static M2ALU_PtrToValue__opaque New (void);
946 : :
947 : : /*
948 : : InitRecord - initialize the non variant fields of, v. Return v.
949 : : */
950 : :
951 : : static M2ALU_PtrToValue__opaque InitRecord (M2ALU_PtrToValue__opaque v);
952 : :
953 : : /*
954 : : NewRange - assigns, v, to a new area of memory.
955 : : */
956 : :
957 : : static void NewRange (M2ALU_listOfRange *v);
958 : :
959 : : /*
960 : : DisposeRange - adds the list, v, to the free list.
961 : : */
962 : :
963 : : static void DisposeRange (M2ALU_listOfRange *v);
964 : :
965 : : /*
966 : : IsOnFieldFreeList - returns TRUE if, r, is on the FieldFreeList.
967 : : */
968 : :
969 : : static bool IsOnFieldFreeList (M2ALU_listOfFields r);
970 : :
971 : : /*
972 : : IsOnElementFreeList - returns TRUE if, r, is on the ElementFreeList.
973 : : */
974 : :
975 : : static bool IsOnElementFreeList (M2ALU_listOfElements r);
976 : :
977 : : /*
978 : : DisposeFields - adds the list, v, to the free list.
979 : : */
980 : :
981 : : static void DisposeFields (M2ALU_listOfFields *v);
982 : :
983 : : /*
984 : : NewField - adds the list, v, to the free list.
985 : : */
986 : :
987 : : static void NewField (M2ALU_listOfFields *v);
988 : :
989 : : /*
990 : : NewElement - returns a new element record.
991 : : */
992 : :
993 : : static void NewElement (M2ALU_listOfElements *e);
994 : :
995 : : /*
996 : : DisposeElements - returns the list, e, to the free list.
997 : : */
998 : :
999 : : static void DisposeElements (M2ALU_listOfElements *e);
1000 : :
1001 : : /*
1002 : : CheckNotAlreadyOnFreeList - checks to see whether, v, is already on the free list
1003 : : and aborts if this is the case.
1004 : : */
1005 : :
1006 : : static void CheckNotAlreadyOnFreeList (M2ALU_PtrToValue__opaque v);
1007 : :
1008 : : /*
1009 : : CheckNotOnStack - checks to see whether, v, is already on the stack
1010 : : and aborts if this is the case.
1011 : : */
1012 : :
1013 : : static void CheckNotOnStack (M2ALU_PtrToValue__opaque v);
1014 : :
1015 : : /*
1016 : : Dispose - place, v, onto the FreeList.
1017 : : */
1018 : :
1019 : : static void Dispose (M2ALU_PtrToValue__opaque v);
1020 : :
1021 : : /*
1022 : : AddRange - returns a ListOfRange which is prepended to the front of the current list.
1023 : : */
1024 : :
1025 : : static M2ALU_listOfRange AddRange (M2ALU_listOfRange head, unsigned int l, unsigned int h);
1026 : :
1027 : : /*
1028 : : DupRange - duplicates and returns the list, t.
1029 : : */
1030 : :
1031 : : static M2ALU_listOfRange DupRange (M2ALU_listOfRange r);
1032 : :
1033 : : /*
1034 : : Pop - pops and returns top element from the stack.
1035 : : */
1036 : :
1037 : : static M2ALU_PtrToValue__opaque Pop (void);
1038 : :
1039 : : /*
1040 : : Push - pushes the value onto the stack.
1041 : : */
1042 : :
1043 : : static void Push (M2ALU_PtrToValue__opaque v);
1044 : :
1045 : : /*
1046 : : Reduce - remove the top element of the stack.
1047 : : */
1048 : :
1049 : : static void Reduce (void);
1050 : :
1051 : : /*
1052 : : PrintValue - debugging procedure to display the value on the top of the stack.
1053 : : */
1054 : :
1055 : : static void PrintValue (void);
1056 : :
1057 : : /*
1058 : : DupFields - duplicates the field list in order.
1059 : : */
1060 : :
1061 : : static M2ALU_listOfFields DupFields (M2ALU_listOfFields f);
1062 : :
1063 : : /*
1064 : : DupElements - duplicates the array list in order.
1065 : : */
1066 : :
1067 : : static M2ALU_listOfElements DupElements (M2ALU_listOfElements f);
1068 : :
1069 : : /*
1070 : : IsReal - returns TRUE if a is a REAL number.
1071 : : */
1072 : :
1073 : : static bool IsReal (DynamicStrings_String a);
1074 : :
1075 : : /*
1076 : : IsSolvedGCC - returns TRUE if the value, sym, is solved.
1077 : : If TRUE then it also ensures this symbol is
1078 : : entered into the double book keeping table
1079 : : for GM2 <-> GCC.
1080 : : */
1081 : :
1082 : : static bool IsSolvedGCC (unsigned int sym);
1083 : :
1084 : : /*
1085 : : ConvertIntToReal - converts a INTEGER into a LONGREAL
1086 : : */
1087 : :
1088 : : static void ConvertIntToReal (void);
1089 : :
1090 : : /*
1091 : : EitherReal - returns TRUE if either, Op1, or, Op2, are Real.
1092 : : */
1093 : :
1094 : : static bool EitherReal (M2ALU_PtrToValue__opaque Op1, M2ALU_PtrToValue__opaque Op2);
1095 : :
1096 : : /*
1097 : : EitherComplex - returns TRUE if either, Op1, or, Op2, are Real.
1098 : : */
1099 : :
1100 : : static bool EitherComplex (M2ALU_PtrToValue__opaque Op1, M2ALU_PtrToValue__opaque Op2);
1101 : :
1102 : : /*
1103 : : RealAdd - adds two numbers. One of which is a Real.
1104 : : */
1105 : :
1106 : : static void RealAdd (M2ALU_PtrToValue__opaque Op1, M2ALU_PtrToValue__opaque Op2);
1107 : :
1108 : : /*
1109 : : ComplexAdd - adds two complex numbers.
1110 : : */
1111 : :
1112 : : static void ComplexAdd (M2ALU_PtrToValue__opaque Op1, M2ALU_PtrToValue__opaque Op2);
1113 : :
1114 : : /*
1115 : : RealSub - subtracts two numbers. One of which is a Real.
1116 : : */
1117 : :
1118 : : static void RealSub (M2ALU_PtrToValue__opaque Op1, M2ALU_PtrToValue__opaque Op2);
1119 : :
1120 : : /*
1121 : : ComplexSub - subtracts two complex numbers.
1122 : : */
1123 : :
1124 : : static void ComplexSub (M2ALU_PtrToValue__opaque Op1, M2ALU_PtrToValue__opaque Op2);
1125 : :
1126 : : /*
1127 : : RealMult - multiplies two numbers. One of which is a Real.
1128 : : */
1129 : :
1130 : : static void RealMult (M2ALU_PtrToValue__opaque Op1, M2ALU_PtrToValue__opaque Op2);
1131 : :
1132 : : /*
1133 : : ComplexMult - multiplies two complex numbers.
1134 : : */
1135 : :
1136 : : static void ComplexMult (M2ALU_PtrToValue__opaque Op1, M2ALU_PtrToValue__opaque Op2);
1137 : :
1138 : : /*
1139 : : RealDiv - divides two numbers. One of which is a Real.
1140 : : */
1141 : :
1142 : : static void RealDiv (M2ALU_PtrToValue__opaque Op1, M2ALU_PtrToValue__opaque Op2);
1143 : :
1144 : : /*
1145 : : ComplexDiv - divides two complex numbers.
1146 : : */
1147 : :
1148 : : static void ComplexDiv (M2ALU_PtrToValue__opaque Op1, M2ALU_PtrToValue__opaque Op2);
1149 : :
1150 : : /*
1151 : : AreSetsEqual - returns TRUE if sets, op1, and, op2, contain the same
1152 : : members.
1153 : : */
1154 : :
1155 : : static bool AreSetsEqual (unsigned int tokenno, M2ALU_PtrToValue__opaque op1, M2ALU_PtrToValue__opaque op2);
1156 : :
1157 : : /*
1158 : : IsSubset - returns TRUE if the set as defined by, s1, is a subset of set, s2.
1159 : : */
1160 : :
1161 : : static bool IsSubset (unsigned int tokenno, M2ALU_PtrToValue__opaque s1, M2ALU_PtrToValue__opaque s2);
1162 : :
1163 : : /*
1164 : : IsSuperset - returns TRUE if the set as defined by, s1, is a superset of set, s2.
1165 : : */
1166 : :
1167 : : static bool IsSuperset (unsigned int tokenno, M2ALU_PtrToValue__opaque s1, M2ALU_PtrToValue__opaque s2);
1168 : :
1169 : : /*
1170 : : cellTypeString - returns a string corresponding to, s.
1171 : : */
1172 : :
1173 : : static DynamicStrings_String cellTypeString (M2ALU_cellType s);
1174 : :
1175 : : /*
1176 : : ToSetValue - converts a list of fields into a list of ranges.
1177 : : In effect it turns a generic constructor into
1178 : : a set type.
1179 : : */
1180 : :
1181 : : static M2ALU_listOfRange ToSetValue (M2ALU_listOfFields f);
1182 : :
1183 : : /*
1184 : : ToArrayValue - converts a list of fields into an array initialiser.
1185 : : In effect it turns a generic constructor into
1186 : : an array type.
1187 : : */
1188 : :
1189 : : static M2ALU_listOfElements ToArrayValue (unsigned int tok, M2ALU_listOfFields f);
1190 : :
1191 : : /*
1192 : : CoerseTo - attempts to coerses a cellType, v, into, type, t.
1193 : : Normally this will be a generic constructors converting
1194 : : into set or array.
1195 : : */
1196 : :
1197 : : static M2ALU_PtrToValue__opaque CoerseTo (unsigned int tokenno, M2ALU_cellType t, M2ALU_PtrToValue__opaque v);
1198 : :
1199 : : /*
1200 : : AddElementToEnd - appends, e, to the end of list, v.
1201 : : */
1202 : :
1203 : : static void AddElementToEnd (M2ALU_PtrToValue__opaque v, M2ALU_listOfElements e);
1204 : :
1205 : : /*
1206 : : AddFieldToEnd - appends, f, to the end of list, v.
1207 : : */
1208 : :
1209 : : static void AddFieldToEnd (M2ALU_PtrToValue__opaque v, M2ALU_listOfFields f);
1210 : :
1211 : : /*
1212 : : ElementsSolved - returns TRUE if all ranges in the set have been solved.
1213 : : */
1214 : :
1215 : : static bool ElementsSolved (unsigned int tokenno, M2ALU_listOfRange r);
1216 : :
1217 : : /*
1218 : : ArrayElementsSolved - returns TRUE if all ranges in the set have been solved.
1219 : : */
1220 : :
1221 : : static bool ArrayElementsSolved (M2ALU_listOfElements e);
1222 : :
1223 : : /*
1224 : : EvalFieldValues - returns TRUE if all fields in the record have been solved.
1225 : : */
1226 : :
1227 : : static bool EvalFieldValues (M2ALU_listOfFields e);
1228 : :
1229 : : /*
1230 : : Swap - swaps the contents of, i, and, j.
1231 : : */
1232 : :
1233 : : static void Swap (M2ALU_listOfRange i, M2ALU_listOfRange j);
1234 : :
1235 : : /*
1236 : : DisplayElements -
1237 : : */
1238 : :
1239 : : static void DisplayElements (M2ALU_listOfRange i);
1240 : :
1241 : : /*
1242 : : SortElements - sorts the list as defined by, h, into ascending range order.
1243 : : The low element is the sort key.
1244 : : */
1245 : :
1246 : : static void SortElements (unsigned int tokenno, M2ALU_listOfRange h);
1247 : :
1248 : : /*
1249 : : CombineElements - given a sorted list determine whether there is any
1250 : : overlap in the low..high bounds. If overlap exists
1251 : : then remove it.
1252 : : */
1253 : :
1254 : : static void CombineElements (unsigned int tokenno, M2ALU_listOfRange r);
1255 : :
1256 : : /*
1257 : : EvalSetValues - returns TRUE if all elements in this set have been resolved.
1258 : : */
1259 : :
1260 : : static bool EvalSetValues (unsigned int tokenno, M2ALU_listOfRange r);
1261 : :
1262 : : /*
1263 : : Eval - attempts to solve a constructor type.
1264 : : */
1265 : :
1266 : : static void Eval (unsigned int tokenno, M2ALU_PtrToValue__opaque v);
1267 : :
1268 : : /*
1269 : : WalkSetValueDependants -
1270 : : */
1271 : :
1272 : : static void WalkSetValueDependants (M2ALU_listOfRange r, M2GCCDeclare_WalkAction p);
1273 : :
1274 : : /*
1275 : : IsSetValueDependants -
1276 : : */
1277 : :
1278 : : static bool IsSetValueDependants (M2ALU_listOfRange r, M2GCCDeclare_IsAction q);
1279 : :
1280 : : /*
1281 : : WalkFieldValueDependants -
1282 : : */
1283 : :
1284 : : static void WalkFieldValueDependants (M2ALU_listOfFields f, M2GCCDeclare_WalkAction p);
1285 : :
1286 : : /*
1287 : : IsFieldValueDependants -
1288 : : */
1289 : :
1290 : : static bool IsFieldValueDependants (M2ALU_listOfFields f, M2GCCDeclare_IsAction q);
1291 : :
1292 : : /*
1293 : : WalkArrayValueDependants -
1294 : : */
1295 : :
1296 : : static void WalkArrayValueDependants (M2ALU_listOfElements a, M2GCCDeclare_WalkAction p);
1297 : :
1298 : : /*
1299 : : IsArrayValueDependants -
1300 : : */
1301 : :
1302 : : static bool IsArrayValueDependants (M2ALU_listOfElements a, M2GCCDeclare_IsAction q);
1303 : :
1304 : : /*
1305 : : DefinedByConstants - returns TRUE if the value, v, is defined by constants.
1306 : : It assigns, v^.areAllConstants, with the result.
1307 : : */
1308 : :
1309 : : static bool DefinedByConstants (M2ALU_PtrToValue__opaque v);
1310 : :
1311 : : /*
1312 : : rangeConstant - returns TRUE if all the range entities are constant.
1313 : : */
1314 : :
1315 : : static bool rangeConstant (M2ALU_listOfRange r);
1316 : :
1317 : : /*
1318 : : fieldsConstant - returns TRUE if all the field entities are constant.
1319 : : */
1320 : :
1321 : : static bool fieldsConstant (M2ALU_listOfFields f);
1322 : :
1323 : : /*
1324 : : arrayConstant - returns TRUE if the, element, and, by, components
1325 : : of an array constructor are constant.
1326 : : */
1327 : :
1328 : : static bool arrayConstant (M2ALU_listOfElements e);
1329 : :
1330 : : /*
1331 : : FindValueEnum -
1332 : : */
1333 : :
1334 : : static void FindValueEnum (unsigned int field);
1335 : :
1336 : : /*
1337 : : Val - returns a GCC symbol enumeration or a GCC constant which has, value, and which is
1338 : : of type, type.
1339 : : */
1340 : :
1341 : : static unsigned int Val (unsigned int tokenno, unsigned int type, tree value);
1342 : :
1343 : : /*
1344 : : DupConst - duplicates and returns a constant, sym, but adds, offset to its value.
1345 : : */
1346 : :
1347 : : static unsigned int DupConst (unsigned int tokenno, unsigned int sym, int offset);
1348 : :
1349 : : /*
1350 : : DupConstAndAdd - duplicates and returns a constant, sym,
1351 : : but adds the symbol, extra.
1352 : : */
1353 : :
1354 : : static unsigned int DupConstAndAdd (unsigned int tokenno, unsigned int sym, tree extra);
1355 : :
1356 : : /*
1357 : : DupConstAndAddMod - duplicates and returns a constant, sym,
1358 : : but adds the symbol, extra, and ensures that
1359 : : the result in within limits: min..max using
1360 : : modulo arithmetic.
1361 : : */
1362 : :
1363 : : static unsigned int DupConstAndAddMod (unsigned int tokenno, unsigned int sym, tree extra, unsigned int l, unsigned int h);
1364 : :
1365 : : /*
1366 : : Remove - removes, v, from list, h.
1367 : : */
1368 : :
1369 : : static void Remove (M2ALU_listOfRange *h, M2ALU_listOfRange v);
1370 : :
1371 : : /*
1372 : : RemoveBit - remove bit, op1, from range, v, on list, h.
1373 : : */
1374 : :
1375 : : static void RemoveBit (unsigned int tokenno, M2ALU_listOfRange *h, M2ALU_listOfRange v, unsigned int op1);
1376 : :
1377 : : /*
1378 : : PerformSubBit -
1379 : : */
1380 : :
1381 : : static void PerformSubBit (unsigned int tokenno, M2ALU_listOfRange *h, unsigned int op1);
1382 : :
1383 : : /*
1384 : : PerformSetIn - returns TRUE if op1 is in set.
1385 : : */
1386 : :
1387 : : static bool PerformSetIn (unsigned int tokenno, unsigned int op1, M2ALU_listOfRange h);
1388 : :
1389 : : /*
1390 : : SetOp - perform the function doOp on the top two elements of the stack.
1391 : : */
1392 : :
1393 : : static void SetOp (unsigned int tokenno, M2ALU_DoSetProcedure doOp);
1394 : :
1395 : : /*
1396 : : PerformOr - performs a logical OR between the two ranges.
1397 : : The ranges, r1, r2, are destroyed.
1398 : : */
1399 : :
1400 : : static M2ALU_listOfRange PerformOr (unsigned int tokenno, M2ALU_listOfRange r1, M2ALU_listOfRange r2);
1401 : :
1402 : : /*
1403 : : Min - returns the symbol which has the least value.
1404 : : */
1405 : :
1406 : : static unsigned int Min (unsigned int tokenno, unsigned int a, unsigned int b);
1407 : :
1408 : : /*
1409 : : Max - returns the symbol which has the greatest value.
1410 : : */
1411 : :
1412 : : static unsigned int Max (unsigned int tokenno, unsigned int a, unsigned int b);
1413 : :
1414 : : /*
1415 : : IsRangeIntersection - returns TRUE if ranges, r1, and, r2, intersect.
1416 : : */
1417 : :
1418 : : static bool IsRangeIntersection (unsigned int tokenno, M2ALU_listOfRange r1, M2ALU_listOfRange r2);
1419 : :
1420 : : /*
1421 : : IsRangeLess - returns TRUE if r1^.low is < r2^.low
1422 : : */
1423 : :
1424 : : static bool IsRangeLess (unsigned int tokenno, M2ALU_listOfRange r1, M2ALU_listOfRange r2);
1425 : :
1426 : : /*
1427 : : MinTree - returns the tree symbol which has the least value.
1428 : : */
1429 : :
1430 : : static tree MinTree (unsigned int tokenno, tree a, tree b);
1431 : :
1432 : : /*
1433 : : MaxTree - returns the symbol which has the greatest value.
1434 : : */
1435 : :
1436 : : static tree MaxTree (unsigned int tokenno, tree a, tree b);
1437 : :
1438 : : /*
1439 : : IsIntersectionTree - returns TRUE if ranges, a..b, and, c..d, intersect.
1440 : : */
1441 : :
1442 : : static bool IsIntersectionTree (unsigned int tokenno, tree a, tree b, tree c, tree d);
1443 : :
1444 : : /*
1445 : : SubTree - returns the tree value containing (a-b)
1446 : : */
1447 : :
1448 : : static tree SubTree (tree a, tree b);
1449 : :
1450 : : /*
1451 : : PerformAnd - performs a logical AND between the two ranges.
1452 : : The ranges, r1, r2, are unaltered.
1453 : : */
1454 : :
1455 : : static M2ALU_listOfRange PerformAnd (unsigned int tokenno, M2ALU_listOfRange r1, M2ALU_listOfRange r2);
1456 : :
1457 : : /*
1458 : : BuildStructBitset - v is the PtrToValue.
1459 : : low and high are the limits of the subrange.
1460 : : */
1461 : :
1462 : : static tree BuildStructBitset (unsigned int tokenno, M2ALU_PtrToValue__opaque v, tree low, tree high);
1463 : :
1464 : : /*
1465 : : ConstructLargeOrSmallSet - generates a constant representing the set value of the symbol, sym.
1466 : : We manufacture the constant by using a initialization
1467 : : structure of cardinals.
1468 : :
1469 : : { (cardinal), (cardinal) etc }
1470 : : */
1471 : :
1472 : : static tree ConstructLargeOrSmallSet (unsigned int tokenno, M2ALU_PtrToValue__opaque v, unsigned int low, unsigned int high);
1473 : :
1474 : : /*
1475 : : ConvertConstToType - returns a Tree containing an initialiser,
1476 : : init, ready to be assigned to a record or
1477 : : array constructor.
1478 : : */
1479 : :
1480 : : static tree ConvertConstToType (unsigned int tokenno, unsigned int field, unsigned int init);
1481 : :
1482 : : /*
1483 : : ConstructRecordConstant - builds a struct initializer, as defined by, v.
1484 : : */
1485 : :
1486 : : static tree ConstructRecordConstant (unsigned int tokenno, M2ALU_PtrToValue__opaque v);
1487 : :
1488 : : /*
1489 : : GetConstructorField - returns a symbol containing the constructor field, i.
1490 : : */
1491 : :
1492 : : static unsigned int GetConstructorField (M2ALU_PtrToValue__opaque v, unsigned int i);
1493 : :
1494 : : /*
1495 : : GetConstructorElement - returns a symbol containing the array constructor element, i.
1496 : : */
1497 : :
1498 : : static unsigned int GetConstructorElement (unsigned int tokenno, M2ALU_PtrToValue__opaque v, unsigned int i);
1499 : :
1500 : : /*
1501 : : IsString - returns TRUE if sym is an ARRAY [..] OF CHAR
1502 : : */
1503 : :
1504 : : static bool IsString (unsigned int sym);
1505 : :
1506 : : /*
1507 : : StringFitsArray -
1508 : : */
1509 : :
1510 : : static bool StringFitsArray (unsigned int arrayType, unsigned int el, unsigned int tokenno);
1511 : :
1512 : : /*
1513 : : GetArrayLimits -
1514 : : */
1515 : :
1516 : : static void GetArrayLimits (unsigned int array, unsigned int *low, unsigned int *high);
1517 : :
1518 : : /*
1519 : : InitialiseArrayOfCharWithString -
1520 : : */
1521 : :
1522 : : static tree InitialiseArrayOfCharWithString (unsigned int tokenno, void * cons, unsigned int el, unsigned int baseType, unsigned int arrayType);
1523 : :
1524 : : /*
1525 : : CheckElementString -
1526 : : */
1527 : :
1528 : : static tree CheckElementString (unsigned int el, unsigned int arrayType, unsigned int tokenno);
1529 : :
1530 : : /*
1531 : : InitialiseArrayWith -
1532 : : */
1533 : :
1534 : : static tree InitialiseArrayWith (unsigned int tokenno, void * cons, M2ALU_PtrToValue__opaque v, unsigned int el, unsigned int high, unsigned int low, unsigned int arrayType);
1535 : :
1536 : : /*
1537 : : CheckGetCharFromString - return TRUE if a char from the position arrayIndex in the list of
1538 : : constDecl elements can be extracted. The character is returned
1539 : : in value.
1540 : : */
1541 : :
1542 : : static bool CheckGetCharFromString (location_t location, unsigned int tokenno, M2ALU_PtrToValue__opaque constDecl, unsigned int consType, unsigned int arrayIndex, tree *value);
1543 : :
1544 : : /*
1545 : : InitialiseArrayOfCharWith -
1546 : : */
1547 : :
1548 : : static tree InitialiseArrayOfCharWith (unsigned int tokenno, void * cons, M2ALU_PtrToValue__opaque constDecl, unsigned int el, unsigned int high, unsigned int low, unsigned int consType, unsigned int arrayType);
1549 : :
1550 : : /*
1551 : : ConstructArrayConstant - builds a struct initializer, as defined by, v.
1552 : : */
1553 : :
1554 : : static tree ConstructArrayConstant (unsigned int tokenno, M2ALU_PtrToValue__opaque v);
1555 : :
1556 : : /*
1557 : : BuildBitset - given a set, v, construct the bitmask for its
1558 : : constant value which lie in the range low..high.
1559 : : */
1560 : :
1561 : : static tree BuildBitset (unsigned int tokenno, M2ALU_PtrToValue__opaque v, tree low, tree high);
1562 : :
1563 : : /*
1564 : : CheckOverflow - tests to see whether the tree, t, has caused
1565 : : an overflow error and if so it generates an
1566 : : error message.
1567 : : */
1568 : :
1569 : : static void CheckOverflow (unsigned int tokenno, tree t);
1570 : :
1571 : : /*
1572 : : PushGCCArrayTree - pushes a gcc tree value onto the ALU stack.
1573 : : */
1574 : :
1575 : : static void PushGCCArrayTree (tree gcc, unsigned int t);
1576 : :
1577 : : /*
1578 : : PushGCCSetTree - pushes a gcc tree value onto the ALU stack.
1579 : : */
1580 : :
1581 : : static void PushGCCSetTree (tree gcc, unsigned int t);
1582 : :
1583 : : /*
1584 : : PushGCCRecordTree - pushes a gcc tree value onto the ALU stack.
1585 : : */
1586 : :
1587 : : static void PushGCCRecordTree (tree gcc, unsigned int t);
1588 : :
1589 : : /*
1590 : : Init - initialises the stack and the free list.
1591 : : */
1592 : :
1593 : : static void Init (void);
1594 : :
1595 : :
1596 : : /*
1597 : : New - allocate a PtrToValue. Firstly check the FreeList, if empty call upon New.
1598 : : */
1599 : :
1600 : 54837337 : static M2ALU_PtrToValue__opaque New (void)
1601 : : {
1602 : 54837337 : M2ALU_PtrToValue__opaque v;
1603 : :
1604 : 54837337 : if (FreeList == NULL)
1605 : : {
1606 : 32584913 : Storage_ALLOCATE ((void **) &v, sizeof (M2ALU_cell));
1607 : : }
1608 : : else
1609 : : {
1610 : 22252424 : v = FreeList;
1611 : 22252424 : FreeList = FreeList->next;
1612 : : }
1613 : 54837337 : v->numberValue = NULL;
1614 : 109674674 : return InitRecord (v);
1615 : : /* static analysis guarentees a RETURN statement will be used before here. */
1616 : : __builtin_unreachable ();
1617 : : }
1618 : :
1619 : :
1620 : : /*
1621 : : InitRecord - initialize the non variant fields of, v. Return v.
1622 : : */
1623 : :
1624 : 54837337 : static M2ALU_PtrToValue__opaque InitRecord (M2ALU_PtrToValue__opaque v)
1625 : : {
1626 : 54837337 : v->location = m2linemap_UnknownLocation ();
1627 : 54837337 : v->areAllConstants = false;
1628 : 54837337 : v->solved = false;
1629 : 54837337 : v->constructorType = SymbolTable_NulSym;
1630 : 54837337 : v->numberValue = NULL;
1631 : 54837337 : return v;
1632 : : /* static analysis guarentees a RETURN statement will be used before here. */
1633 : : __builtin_unreachable ();
1634 : : }
1635 : :
1636 : :
1637 : : /*
1638 : : NewRange - assigns, v, to a new area of memory.
1639 : : */
1640 : :
1641 : 378778 : static void NewRange (M2ALU_listOfRange *v)
1642 : : {
1643 : 378778 : if (RangeFreeList == NULL)
1644 : : {
1645 : : /* avoid dangling else. */
1646 : 367210 : Storage_ALLOCATE ((void **) &(*v), sizeof (M2ALU_rList));
1647 : 367210 : if ((*v) == NULL)
1648 : : {
1649 : 0 : M2Error_InternalError ((const char *) "out of memory error", 19);
1650 : : }
1651 : : }
1652 : : else
1653 : : {
1654 : 11568 : (*v) = RangeFreeList;
1655 : 11568 : RangeFreeList = RangeFreeList->next;
1656 : : }
1657 : 378778 : }
1658 : :
1659 : :
1660 : : /*
1661 : : DisposeRange - adds the list, v, to the free list.
1662 : : */
1663 : :
1664 : 68102 : static void DisposeRange (M2ALU_listOfRange *v)
1665 : : {
1666 : 68102 : M2ALU_listOfRange r;
1667 : :
1668 : 68102 : if ((*v) != NULL)
1669 : : {
1670 : : r = (*v);
1671 : 11676 : while ((r != NULL) && (r->next != NULL))
1672 : : {
1673 : : r = r->next;
1674 : : }
1675 : 9666 : if (r != NULL)
1676 : : {
1677 : 9666 : r->next = RangeFreeList;
1678 : : }
1679 : 9666 : RangeFreeList = (*v);
1680 : 9666 : (*v) = NULL;
1681 : : }
1682 : 68102 : }
1683 : :
1684 : :
1685 : : /*
1686 : : IsOnFieldFreeList - returns TRUE if, r, is on the FieldFreeList.
1687 : : */
1688 : :
1689 : 7292 : static bool IsOnFieldFreeList (M2ALU_listOfFields r)
1690 : : {
1691 : 7292 : M2ALU_listOfFields s;
1692 : :
1693 : 7292 : s = FieldFreeList;
1694 : 7292 : while (s != NULL)
1695 : : {
1696 : 0 : if (s == r)
1697 : : {
1698 : : return true;
1699 : : }
1700 : : else
1701 : : {
1702 : 0 : s = s->next;
1703 : : }
1704 : : }
1705 : : return false;
1706 : : /* static analysis guarentees a RETURN statement will be used before here. */
1707 : : __builtin_unreachable ();
1708 : : }
1709 : :
1710 : :
1711 : : /*
1712 : : IsOnElementFreeList - returns TRUE if, r, is on the ElementFreeList.
1713 : : */
1714 : :
1715 : 5482 : static bool IsOnElementFreeList (M2ALU_listOfElements r)
1716 : : {
1717 : 5482 : M2ALU_listOfElements s;
1718 : :
1719 : 5482 : s = ElementFreeList;
1720 : 5482 : while (s != NULL)
1721 : : {
1722 : 0 : if (s == r)
1723 : : {
1724 : : return true;
1725 : : }
1726 : : else
1727 : : {
1728 : 0 : s = s->next;
1729 : : }
1730 : : }
1731 : : return false;
1732 : : /* static analysis guarentees a RETURN statement will be used before here. */
1733 : : __builtin_unreachable ();
1734 : : }
1735 : :
1736 : :
1737 : : /*
1738 : : DisposeFields - adds the list, v, to the free list.
1739 : : */
1740 : :
1741 : 54150 : static void DisposeFields (M2ALU_listOfFields *v)
1742 : : {
1743 : 54150 : M2ALU_listOfFields r;
1744 : :
1745 : 54150 : if ((*v) != NULL)
1746 : : {
1747 : : r = (*v);
1748 : 9624 : while (r->next != NULL)
1749 : : {
1750 : 14584 : M2Debug_Assert (! (IsOnFieldFreeList (r)));
1751 : 7292 : r = r->next;
1752 : : }
1753 : 2332 : r->next = FieldFreeList;
1754 : 2332 : FieldFreeList = (*v);
1755 : 2332 : (*v) = NULL;
1756 : : }
1757 : 54150 : }
1758 : :
1759 : :
1760 : : /*
1761 : : NewField - adds the list, v, to the free list.
1762 : : */
1763 : :
1764 : 1908354 : static void NewField (M2ALU_listOfFields *v)
1765 : : {
1766 : 1908354 : if (FieldFreeList == NULL)
1767 : : {
1768 : : /* avoid dangling else. */
1769 : 1898766 : Storage_ALLOCATE ((void **) &(*v), sizeof (M2ALU_fList));
1770 : 1898766 : if ((*v) == NULL)
1771 : : {
1772 : 0 : M2Error_InternalError ((const char *) "out of memory error", 19);
1773 : : }
1774 : : }
1775 : : else
1776 : : {
1777 : 9588 : (*v) = FieldFreeList;
1778 : 9588 : FieldFreeList = FieldFreeList->next;
1779 : : }
1780 : 1908354 : }
1781 : :
1782 : :
1783 : : /*
1784 : : NewElement - returns a new element record.
1785 : : */
1786 : :
1787 : 1040640 : static void NewElement (M2ALU_listOfElements *e)
1788 : : {
1789 : 1040640 : if (ElementFreeList == NULL)
1790 : : {
1791 : : /* avoid dangling else. */
1792 : 1034434 : Storage_ALLOCATE ((void **) &(*e), sizeof (M2ALU_eList));
1793 : 1034434 : if ((*e) == NULL)
1794 : : {
1795 : 0 : M2Error_InternalError ((const char *) "out of memory error", 19);
1796 : : }
1797 : : }
1798 : : else
1799 : : {
1800 : 6206 : (*e) = ElementFreeList;
1801 : 6206 : ElementFreeList = ElementFreeList->next;
1802 : : }
1803 : 1040640 : }
1804 : :
1805 : :
1806 : : /*
1807 : : DisposeElements - returns the list, e, to the free list.
1808 : : */
1809 : :
1810 : 8106 : static void DisposeElements (M2ALU_listOfElements *e)
1811 : : {
1812 : 8106 : M2ALU_listOfElements r;
1813 : :
1814 : 8106 : if ((*e) != NULL)
1815 : : {
1816 : : r = (*e);
1817 : 6206 : while (r->next != NULL)
1818 : : {
1819 : 10964 : M2Debug_Assert (! (IsOnElementFreeList (r)));
1820 : 5482 : r = r->next;
1821 : : }
1822 : 724 : r->next = ElementFreeList;
1823 : 724 : ElementFreeList = (*e);
1824 : 724 : (*e) = NULL;
1825 : : }
1826 : 8106 : }
1827 : :
1828 : :
1829 : : /*
1830 : : CheckNotAlreadyOnFreeList - checks to see whether, v, is already on the free list
1831 : : and aborts if this is the case.
1832 : : */
1833 : :
1834 : 89248894 : static void CheckNotAlreadyOnFreeList (M2ALU_PtrToValue__opaque v)
1835 : : {
1836 : 89248894 : M2ALU_PtrToValue__opaque l;
1837 : :
1838 : 89248894 : if (DebugGarbage)
1839 : : {
1840 : 89248894 : l = FreeList;
1841 : 159198826 : while (l != NULL)
1842 : : {
1843 : 69949932 : if (l == v)
1844 : : {
1845 : 0 : M2Error_InternalError ((const char *) "value is already on the free list", 33);
1846 : : }
1847 : 69949932 : l = l->next;
1848 : : }
1849 : : }
1850 : 89248894 : }
1851 : :
1852 : :
1853 : : /*
1854 : : CheckNotOnStack - checks to see whether, v, is already on the stack
1855 : : and aborts if this is the case.
1856 : : */
1857 : :
1858 : 48752864 : static void CheckNotOnStack (M2ALU_PtrToValue__opaque v)
1859 : : {
1860 : 48752864 : M2ALU_PtrToValue__opaque l;
1861 : :
1862 : 48752864 : if (DebugGarbage)
1863 : : {
1864 : 48752864 : l = TopOfStack;
1865 : 74550099 : while (l != NULL)
1866 : : {
1867 : 25797235 : if (l == v)
1868 : : {
1869 : 0 : M2Error_InternalError ((const char *) "value is already on the stack", 29);
1870 : : }
1871 : 25797235 : l = l->next;
1872 : : }
1873 : : }
1874 : 48752864 : }
1875 : :
1876 : :
1877 : : /*
1878 : : Dispose - place, v, onto the FreeList.
1879 : : */
1880 : :
1881 : 22277757 : static void Dispose (M2ALU_PtrToValue__opaque v)
1882 : : {
1883 : 22277757 : CheckNotAlreadyOnFreeList (v);
1884 : 22277757 : CheckNotOnStack (v);
1885 : 22277757 : switch (v->type)
1886 : : {
1887 : 65188 : case M2ALU_set:
1888 : 65188 : DisposeRange (&v->setValue);
1889 : 65188 : break;
1890 : :
1891 : 35124 : case M2ALU_constructor:
1892 : 35124 : case M2ALU_record:
1893 : 35124 : DisposeFields (&v->fieldValues);
1894 : 35124 : break;
1895 : :
1896 : 8106 : case M2ALU_array:
1897 : 8106 : DisposeElements (&v->arrayValues);
1898 : 8106 : break;
1899 : :
1900 : :
1901 : : default:
1902 : : break;
1903 : : }
1904 : 22277757 : v->next = FreeList;
1905 : 22277757 : FreeList = v;
1906 : 22277757 : }
1907 : :
1908 : :
1909 : : /*
1910 : : AddRange - returns a ListOfRange which is prepended to the front of the current list.
1911 : : */
1912 : :
1913 : 378778 : static M2ALU_listOfRange AddRange (M2ALU_listOfRange head, unsigned int l, unsigned int h)
1914 : : {
1915 : 378778 : M2ALU_listOfRange r;
1916 : :
1917 : 0 : NewRange (&r);
1918 : 378778 : r->low = l;
1919 : 378778 : r->high = h;
1920 : 378778 : r->next = head;
1921 : 378778 : return r;
1922 : : /* static analysis guarentees a RETURN statement will be used before here. */
1923 : : __builtin_unreachable ();
1924 : : }
1925 : :
1926 : :
1927 : : /*
1928 : : DupRange - duplicates and returns the list, t.
1929 : : */
1930 : :
1931 : 298660 : static M2ALU_listOfRange DupRange (M2ALU_listOfRange r)
1932 : : {
1933 : 298660 : M2ALU_listOfRange s;
1934 : :
1935 : 298660 : s = NULL;
1936 : 666782 : while (r != NULL)
1937 : : {
1938 : 368122 : s = AddRange (s, r->low, r->high);
1939 : 368122 : r = r->next;
1940 : : }
1941 : 298660 : return s;
1942 : : /* static analysis guarentees a RETURN statement will be used before here. */
1943 : : __builtin_unreachable ();
1944 : : }
1945 : :
1946 : :
1947 : : /*
1948 : : Pop - pops and returns top element from the stack.
1949 : : */
1950 : :
1951 : 26472005 : static M2ALU_PtrToValue__opaque Pop (void)
1952 : : {
1953 : 26472005 : M2ALU_PtrToValue__opaque v;
1954 : :
1955 : 26472005 : if (TopOfStack == NULL)
1956 : : {
1957 : 0 : M2Error_InternalError ((const char *) "stack underflow error", 21);
1958 : : }
1959 : : else
1960 : : {
1961 : 26472005 : v = TopOfStack;
1962 : 26472005 : TopOfStack = TopOfStack->next;
1963 : : }
1964 : 26472005 : CheckNotAlreadyOnFreeList (v);
1965 : 26472005 : return v;
1966 : : /* static analysis guarentees a RETURN statement will be used before here. */
1967 : : __builtin_unreachable ();
1968 : : }
1969 : :
1970 : :
1971 : : /*
1972 : : Push - pushes the value onto the stack.
1973 : : */
1974 : :
1975 : 26475107 : static void Push (M2ALU_PtrToValue__opaque v)
1976 : : {
1977 : 26475107 : CheckNotAlreadyOnFreeList (v);
1978 : 26475107 : CheckNotOnStack (v);
1979 : 26475107 : v->next = TopOfStack;
1980 : 26475107 : TopOfStack = v;
1981 : 26475107 : }
1982 : :
1983 : :
1984 : : /*
1985 : : Reduce - remove the top element of the stack.
1986 : : */
1987 : :
1988 : 0 : static void Reduce (void)
1989 : : {
1990 : 0 : Dispose (Pop ());
1991 : 0 : }
1992 : :
1993 : :
1994 : : /*
1995 : : PrintValue - debugging procedure to display the value on the top of the stack.
1996 : : */
1997 : :
1998 : 0 : static void PrintValue (void)
1999 : : {
2000 : 0 : M2ALU_PtrToValue__opaque v;
2001 : :
2002 : 0 : v = Pop ();
2003 : 0 : if (v->type == M2ALU_integer)
2004 : : {
2005 : 0 : m2misc_DebugTree (v->numberValue);
2006 : : }
2007 : 0 : Push (v);
2008 : 0 : }
2009 : :
2010 : :
2011 : : /*
2012 : : DupFields - duplicates the field list in order.
2013 : : */
2014 : :
2015 : 457900 : static M2ALU_listOfFields DupFields (M2ALU_listOfFields f)
2016 : : {
2017 : 457900 : M2ALU_listOfFields p;
2018 : 457900 : M2ALU_listOfFields q;
2019 : 457900 : M2ALU_listOfFields l;
2020 : :
2021 : 457900 : p = NULL;
2022 : 457900 : l = NULL;
2023 : 2356822 : while (f != NULL)
2024 : : {
2025 : 1898922 : NewField (&q);
2026 : 1898922 : if (p == NULL)
2027 : : {
2028 : 455642 : p = q;
2029 : : }
2030 : 1898922 : q->field = f->field;
2031 : 1898922 : q->next = NULL;
2032 : 1898922 : if (l != NULL)
2033 : : {
2034 : 1443280 : l->next = q;
2035 : : }
2036 : 1898922 : l = q;
2037 : 1898922 : f = f->next;
2038 : : }
2039 : 457900 : return p;
2040 : : /* static analysis guarentees a RETURN statement will be used before here. */
2041 : : __builtin_unreachable ();
2042 : : }
2043 : :
2044 : :
2045 : : /*
2046 : : DupElements - duplicates the array list in order.
2047 : : */
2048 : :
2049 : 97460 : static M2ALU_listOfElements DupElements (M2ALU_listOfElements f)
2050 : : {
2051 : 97460 : M2ALU_listOfElements p;
2052 : 97460 : M2ALU_listOfElements q;
2053 : 97460 : M2ALU_listOfElements l;
2054 : :
2055 : 97460 : p = NULL;
2056 : 97460 : l = NULL;
2057 : 1133898 : while (f != NULL)
2058 : : {
2059 : 1036438 : NewElement (&q);
2060 : 1036438 : if (p == NULL)
2061 : : {
2062 : 96994 : p = q;
2063 : : }
2064 : 1036438 : q->element = f->element;
2065 : 1036438 : q->by = f->by;
2066 : 1036438 : q->next = NULL;
2067 : 1036438 : if (l != NULL)
2068 : : {
2069 : 939444 : l->next = q;
2070 : : }
2071 : 1036438 : l = q;
2072 : 1036438 : f = f->next;
2073 : : }
2074 : 97460 : return p;
2075 : : /* static analysis guarentees a RETURN statement will be used before here. */
2076 : : __builtin_unreachable ();
2077 : : }
2078 : :
2079 : :
2080 : : /*
2081 : : IsReal - returns TRUE if a is a REAL number.
2082 : : */
2083 : :
2084 : 398366 : static bool IsReal (DynamicStrings_String a)
2085 : : {
2086 : 0 : return (DynamicStrings_Index (a, '.', 0)) != -1;
2087 : : /* static analysis guarentees a RETURN statement will be used before here. */
2088 : : __builtin_unreachable ();
2089 : : }
2090 : :
2091 : :
2092 : : /*
2093 : : IsSolvedGCC - returns TRUE if the value, sym, is solved.
2094 : : If TRUE then it also ensures this symbol is
2095 : : entered into the double book keeping table
2096 : : for GM2 <-> GCC.
2097 : : */
2098 : :
2099 : 39318 : static bool IsSolvedGCC (unsigned int sym)
2100 : : {
2101 : 39318 : if (SymbolTable_IsValueSolved (sym))
2102 : : {
2103 : 39312 : if (! (SymbolConversion_GccKnowsAbout (sym)))
2104 : : {
2105 : 2392 : M2GCCDeclare_DeclareConstant (SymbolTable_GetDeclaredMod (sym), sym);
2106 : : }
2107 : 39312 : return true;
2108 : : }
2109 : : else
2110 : : {
2111 : : return false;
2112 : : }
2113 : : /* static analysis guarentees a RETURN statement will be used before here. */
2114 : : __builtin_unreachable ();
2115 : : }
2116 : :
2117 : :
2118 : : /*
2119 : : ConvertIntToReal - converts a INTEGER into a LONGREAL
2120 : : */
2121 : :
2122 : 0 : static void ConvertIntToReal (void)
2123 : : {
2124 : 0 : M2ALU_PtrToValue__opaque v;
2125 : :
2126 : 0 : v = Pop ();
2127 : 0 : if (v->type == M2ALU_integer)
2128 : : {
2129 : 0 : v->numberValue = m2convert_ConvertConstantAndCheck (v->location, m2type_GetLongRealType (), v->numberValue);
2130 : 0 : v->type = M2ALU_real;
2131 : 0 : v->areAllConstants = true;
2132 : 0 : v->solved = true;
2133 : : }
2134 : : else
2135 : : {
2136 : 0 : M2Error_InternalError ((const char *) "expecting an INTEGER number", 27);
2137 : : }
2138 : 0 : Push (v);
2139 : 0 : }
2140 : :
2141 : :
2142 : : /*
2143 : : EitherReal - returns TRUE if either, Op1, or, Op2, are Real.
2144 : : */
2145 : :
2146 : 594492 : static bool EitherReal (M2ALU_PtrToValue__opaque Op1, M2ALU_PtrToValue__opaque Op2)
2147 : : {
2148 : 594492 : return (Op1->type == M2ALU_real) || (Op2->type == M2ALU_real);
2149 : : /* static analysis guarentees a RETURN statement will be used before here. */
2150 : : __builtin_unreachable ();
2151 : : }
2152 : :
2153 : :
2154 : : /*
2155 : : EitherComplex - returns TRUE if either, Op1, or, Op2, are Real.
2156 : : */
2157 : :
2158 : 594492 : static bool EitherComplex (M2ALU_PtrToValue__opaque Op1, M2ALU_PtrToValue__opaque Op2)
2159 : : {
2160 : 594492 : return (Op1->type == M2ALU_complex) || (Op2->type == M2ALU_complex);
2161 : : /* static analysis guarentees a RETURN statement will be used before here. */
2162 : : __builtin_unreachable ();
2163 : : }
2164 : :
2165 : :
2166 : : /*
2167 : : RealAdd - adds two numbers. One of which is a Real.
2168 : : */
2169 : :
2170 : 0 : static void RealAdd (M2ALU_PtrToValue__opaque Op1, M2ALU_PtrToValue__opaque Op2)
2171 : : {
2172 : 0 : M2ALU_PtrToValue__opaque Temp;
2173 : :
2174 : 0 : if (Op1->type == M2ALU_integer)
2175 : : {
2176 : 0 : Push (Op1);
2177 : 0 : ConvertIntToReal ();
2178 : 0 : Op1 = Pop ();
2179 : : }
2180 : 0 : if (Op2->type == M2ALU_integer)
2181 : : {
2182 : 0 : Push (Op2);
2183 : 0 : ConvertIntToReal ();
2184 : 0 : Op2 = Pop ();
2185 : : }
2186 : 0 : Temp = New ();
2187 : 0 : Temp->location = Op1->location;
2188 : 0 : Temp->numberValue = m2expr_BuildAdd (Temp->location, Op1->numberValue, Op2->numberValue, false);
2189 : 0 : Temp->type = M2ALU_real;
2190 : 0 : Temp->solved = true;
2191 : 0 : Push (Temp);
2192 : 0 : }
2193 : :
2194 : :
2195 : : /*
2196 : : ComplexAdd - adds two complex numbers.
2197 : : */
2198 : :
2199 : 0 : static void ComplexAdd (M2ALU_PtrToValue__opaque Op1, M2ALU_PtrToValue__opaque Op2)
2200 : : {
2201 : 0 : M2ALU_PtrToValue__opaque Temp;
2202 : :
2203 : 0 : if ((Op1->type == M2ALU_complex) && (Op2->type == M2ALU_complex))
2204 : : {
2205 : 0 : Temp = New ();
2206 : 0 : Temp->location = Op1->location;
2207 : 0 : Temp->numberValue = m2expr_BuildAdd (Temp->location, Op1->numberValue, Op2->numberValue, false);
2208 : 0 : Temp->type = M2ALU_complex;
2209 : 0 : Temp->solved = true;
2210 : 0 : Push (Temp);
2211 : : }
2212 : : else
2213 : : {
2214 : 0 : M2Error_InternalError ((const char *) "expecting both operands to be of type COMPLEX", 45);
2215 : : }
2216 : 0 : }
2217 : :
2218 : :
2219 : : /*
2220 : : RealSub - subtracts two numbers. One of which is a Real.
2221 : : */
2222 : :
2223 : 0 : static void RealSub (M2ALU_PtrToValue__opaque Op1, M2ALU_PtrToValue__opaque Op2)
2224 : : {
2225 : 0 : M2ALU_PtrToValue__opaque Temp;
2226 : :
2227 : 0 : if (Op1->type == M2ALU_integer)
2228 : : {
2229 : 0 : Push (Op1);
2230 : 0 : ConvertIntToReal ();
2231 : 0 : Op1 = Pop ();
2232 : : }
2233 : 0 : if (Op2->type == M2ALU_integer)
2234 : : {
2235 : 0 : Push (Op2);
2236 : 0 : ConvertIntToReal ();
2237 : 0 : Op2 = Pop ();
2238 : : }
2239 : 0 : Temp = New ();
2240 : 0 : Temp->location = Op1->location;
2241 : 0 : Temp->numberValue = m2expr_BuildSub (Temp->location, Op2->numberValue, Op1->numberValue, false);
2242 : 0 : Temp->type = M2ALU_real;
2243 : 0 : Temp->solved = true;
2244 : 0 : Push (Temp);
2245 : 0 : }
2246 : :
2247 : :
2248 : : /*
2249 : : ComplexSub - subtracts two complex numbers.
2250 : : */
2251 : :
2252 : 0 : static void ComplexSub (M2ALU_PtrToValue__opaque Op1, M2ALU_PtrToValue__opaque Op2)
2253 : : {
2254 : 0 : M2ALU_PtrToValue__opaque Temp;
2255 : :
2256 : 0 : if ((Op1->type == M2ALU_complex) && (Op2->type == M2ALU_complex))
2257 : : {
2258 : 0 : Temp = New ();
2259 : 0 : Temp->location = Op1->location;
2260 : 0 : Temp->numberValue = m2expr_BuildSub (Temp->location, Op2->numberValue, Op1->numberValue, false);
2261 : 0 : Temp->type = M2ALU_complex;
2262 : 0 : Temp->solved = true;
2263 : 0 : Push (Temp);
2264 : : }
2265 : : else
2266 : : {
2267 : 0 : M2Error_InternalError ((const char *) "expecting both operands to be of type COMPLEX", 45);
2268 : : }
2269 : 0 : }
2270 : :
2271 : :
2272 : : /*
2273 : : RealMult - multiplies two numbers. One of which is a Real.
2274 : : */
2275 : :
2276 : 0 : static void RealMult (M2ALU_PtrToValue__opaque Op1, M2ALU_PtrToValue__opaque Op2)
2277 : : {
2278 : 0 : M2ALU_PtrToValue__opaque Temp;
2279 : :
2280 : 0 : if (Op1->type == M2ALU_integer)
2281 : : {
2282 : 0 : Push (Op1);
2283 : 0 : ConvertIntToReal ();
2284 : 0 : Op1 = Pop ();
2285 : : }
2286 : 0 : if (Op2->type == M2ALU_integer)
2287 : : {
2288 : 0 : Push (Op2);
2289 : 0 : ConvertIntToReal ();
2290 : 0 : Op2 = Pop ();
2291 : : }
2292 : 0 : Temp = New (); /* as it is a temp */
2293 : 0 : Temp->location = Op1->location; /* as it is a temp */
2294 : 0 : Temp->numberValue = m2expr_BuildMult (Temp->location, Op2->numberValue, Op1->numberValue, false);
2295 : 0 : Temp->type = M2ALU_real;
2296 : 0 : Temp->solved = true;
2297 : 0 : Push (Temp);
2298 : 0 : }
2299 : :
2300 : :
2301 : : /*
2302 : : ComplexMult - multiplies two complex numbers.
2303 : : */
2304 : :
2305 : 0 : static void ComplexMult (M2ALU_PtrToValue__opaque Op1, M2ALU_PtrToValue__opaque Op2)
2306 : : {
2307 : 0 : M2ALU_PtrToValue__opaque Temp;
2308 : :
2309 : 0 : if ((Op1->type == M2ALU_complex) && (Op2->type == M2ALU_complex))
2310 : : {
2311 : 0 : Temp = New ();
2312 : 0 : Temp->location = Op1->location;
2313 : 0 : Temp->numberValue = m2expr_BuildMult (Temp->location, Op2->numberValue, Op1->numberValue, false);
2314 : 0 : Temp->type = M2ALU_complex;
2315 : 0 : Temp->solved = true;
2316 : 0 : Push (Temp);
2317 : : }
2318 : : else
2319 : : {
2320 : 0 : M2Error_InternalError ((const char *) "expecting both operands to be of type COMPLEX", 45);
2321 : : }
2322 : 0 : }
2323 : :
2324 : :
2325 : : /*
2326 : : RealDiv - divides two numbers. One of which is a Real.
2327 : : */
2328 : :
2329 : 0 : static void RealDiv (M2ALU_PtrToValue__opaque Op1, M2ALU_PtrToValue__opaque Op2)
2330 : : {
2331 : 0 : M2ALU_PtrToValue__opaque Temp;
2332 : :
2333 : 0 : if (Op1->type == M2ALU_integer)
2334 : : {
2335 : 0 : Push (Op1);
2336 : 0 : ConvertIntToReal ();
2337 : 0 : Op1 = Pop ();
2338 : : }
2339 : 0 : if (Op2->type == M2ALU_integer)
2340 : : {
2341 : 0 : Push (Op2);
2342 : 0 : ConvertIntToReal ();
2343 : 0 : Op2 = Pop ();
2344 : : }
2345 : 0 : Temp = New (); /* as it is a temp */
2346 : 0 : Temp->location = Op1->location; /* as it is a temp */
2347 : 0 : Temp->numberValue = m2expr_BuildDivTrunc (Temp->location, Op2->numberValue, Op1->numberValue, false);
2348 : 0 : Temp->type = M2ALU_real;
2349 : 0 : Temp->solved = true;
2350 : 0 : Push (Temp);
2351 : 0 : }
2352 : :
2353 : :
2354 : : /*
2355 : : ComplexDiv - divides two complex numbers.
2356 : : */
2357 : :
2358 : 0 : static void ComplexDiv (M2ALU_PtrToValue__opaque Op1, M2ALU_PtrToValue__opaque Op2)
2359 : : {
2360 : 0 : M2ALU_PtrToValue__opaque Temp;
2361 : :
2362 : 0 : if ((Op1->type == M2ALU_complex) && (Op2->type == M2ALU_complex))
2363 : : {
2364 : 0 : Temp = New ();
2365 : 0 : Temp->location = Op1->location;
2366 : 0 : Temp->numberValue = m2expr_BuildDivTrunc (Temp->location, Op2->numberValue, Op1->numberValue, false);
2367 : 0 : Temp->type = M2ALU_complex;
2368 : 0 : Temp->solved = true;
2369 : 0 : Push (Temp);
2370 : : }
2371 : : else
2372 : : {
2373 : 0 : M2Error_InternalError ((const char *) "expecting both operands to be of type COMPLEX", 45);
2374 : : }
2375 : 0 : }
2376 : :
2377 : :
2378 : : /*
2379 : : AreSetsEqual - returns TRUE if sets, op1, and, op2, contain the same
2380 : : members.
2381 : : */
2382 : :
2383 : 0 : static bool AreSetsEqual (unsigned int tokenno, M2ALU_PtrToValue__opaque op1, M2ALU_PtrToValue__opaque op2)
2384 : : {
2385 : 0 : unsigned int low1;
2386 : 0 : unsigned int low2;
2387 : 0 : unsigned int high1;
2388 : 0 : unsigned int high2;
2389 : 0 : unsigned int i;
2390 : :
2391 : 0 : i = 1;
2392 : 0 : Eval (tokenno, op1);
2393 : 0 : Eval (tokenno, op2);
2394 : 0 : if (! (op1->solved && op2->solved))
2395 : : {
2396 : 0 : M2Error_InternalError ((const char *) "can only compare set values when they are known", 47);
2397 : : }
2398 : 0 : for (;;)
2399 : : {
2400 : 0 : if (M2ALU_GetRange (static_cast<M2ALU_PtrToValue> (op1), i, &low1, &high1))
2401 : : {
2402 : 0 : if (M2ALU_GetRange (static_cast<M2ALU_PtrToValue> (op2), i, &low2, &high2))
2403 : : {
2404 : 0 : SymbolTable_PushValue (low1);
2405 : 0 : SymbolTable_PushValue (low2);
2406 : 0 : if (M2ALU_NotEqu (tokenno))
2407 : : {
2408 : : return false;
2409 : : }
2410 : 0 : SymbolTable_PushValue (high1);
2411 : 0 : SymbolTable_PushValue (high2);
2412 : 0 : if (M2ALU_NotEqu (tokenno))
2413 : : {
2414 : : return false;
2415 : : }
2416 : 0 : i += 1;
2417 : : }
2418 : : else
2419 : : {
2420 : : /* op2 is out of ranges, but op1 still has >= 1 range left */
2421 : : return false;
2422 : : }
2423 : : }
2424 : : else
2425 : : {
2426 : 0 : if (M2ALU_GetRange (static_cast<M2ALU_PtrToValue> (op2), i, &low2, &high2))
2427 : : {
2428 : : /* op1 is out of ranges, but op2 still has >= 1 range left */
2429 : : return false;
2430 : : }
2431 : : else
2432 : : {
2433 : : /* both out of ranges and they were the same */
2434 : : return true;
2435 : : }
2436 : : }
2437 : : }
2438 : : ReturnException ("/home/worker/buildworker/tiber-lcov/build/gcc/m2/gm2-compiler/M2ALU.def", 20, 1);
2439 : : __builtin_unreachable ();
2440 : : }
2441 : :
2442 : :
2443 : : /*
2444 : : IsSubset - returns TRUE if the set as defined by, s1, is a subset of set, s2.
2445 : : */
2446 : :
2447 : 0 : static bool IsSubset (unsigned int tokenno, M2ALU_PtrToValue__opaque s1, M2ALU_PtrToValue__opaque s2)
2448 : : {
2449 : 0 : Push (s1);
2450 : 0 : Push (s2);
2451 : 0 : M2ALU_SetAnd (tokenno);
2452 : 0 : Push (s1);
2453 : 0 : return M2ALU_Equ (tokenno);
2454 : : /* static analysis guarentees a RETURN statement will be used before here. */
2455 : : __builtin_unreachable ();
2456 : : }
2457 : :
2458 : :
2459 : : /*
2460 : : IsSuperset - returns TRUE if the set as defined by, s1, is a superset of set, s2.
2461 : : */
2462 : :
2463 : 0 : static bool IsSuperset (unsigned int tokenno, M2ALU_PtrToValue__opaque s1, M2ALU_PtrToValue__opaque s2)
2464 : : {
2465 : 0 : M2ALU_PushFrom (static_cast<M2ALU_PtrToValue> (s1));
2466 : 0 : M2ALU_PushFrom (static_cast<M2ALU_PtrToValue> (s2));
2467 : 0 : M2ALU_SetAnd (tokenno);
2468 : 0 : M2ALU_PushFrom (static_cast<M2ALU_PtrToValue> (s2));
2469 : 0 : return M2ALU_Equ (tokenno);
2470 : : /* static analysis guarentees a RETURN statement will be used before here. */
2471 : : __builtin_unreachable ();
2472 : : }
2473 : :
2474 : :
2475 : : /*
2476 : : cellTypeString - returns a string corresponding to, s.
2477 : : */
2478 : :
2479 : 0 : static DynamicStrings_String cellTypeString (M2ALU_cellType s)
2480 : : {
2481 : 0 : switch (s)
2482 : : {
2483 : 0 : case M2ALU_none:
2484 : 0 : return DynamicStrings_InitString ((const char *) "none", 4);
2485 : 0 : break;
2486 : :
2487 : 0 : case M2ALU_integer:
2488 : 0 : return DynamicStrings_InitString ((const char *) "integer", 7);
2489 : 0 : break;
2490 : :
2491 : 0 : case M2ALU_real:
2492 : 0 : return DynamicStrings_InitString ((const char *) "real", 4);
2493 : 0 : break;
2494 : :
2495 : 0 : case M2ALU_complex:
2496 : 0 : return DynamicStrings_InitString ((const char *) "complex", 7);
2497 : 0 : break;
2498 : :
2499 : 0 : case M2ALU_set:
2500 : 0 : return DynamicStrings_InitString ((const char *) "set", 3);
2501 : 0 : break;
2502 : :
2503 : 0 : case M2ALU_constructor:
2504 : 0 : return DynamicStrings_InitString ((const char *) "constructor", 11);
2505 : 0 : break;
2506 : :
2507 : 0 : case M2ALU_array:
2508 : 0 : return DynamicStrings_InitString ((const char *) "array", 5);
2509 : 0 : break;
2510 : :
2511 : 0 : case M2ALU_record:
2512 : 0 : return DynamicStrings_InitString ((const char *) "record", 6);
2513 : 0 : break;
2514 : :
2515 : :
2516 : 0 : default:
2517 : 0 : M2Error_InternalError ((const char *) "unexpected value of s", 21);
2518 : : break;
2519 : : }
2520 : : return static_cast<DynamicStrings_String> (NULL);
2521 : : /* static analysis guarentees a RETURN statement will be used before here. */
2522 : : __builtin_unreachable ();
2523 : : }
2524 : :
2525 : :
2526 : : /*
2527 : : ToSetValue - converts a list of fields into a list of ranges.
2528 : : In effect it turns a generic constructor into
2529 : : a set type.
2530 : : */
2531 : :
2532 : 18160 : static M2ALU_listOfRange ToSetValue (M2ALU_listOfFields f)
2533 : : {
2534 : 18160 : M2ALU_listOfFields g;
2535 : 18160 : M2ALU_listOfRange r;
2536 : 18160 : M2ALU_listOfRange s;
2537 : :
2538 : 18160 : g = f;
2539 : 18160 : r = NULL;
2540 : 18160 : while (f != NULL)
2541 : : {
2542 : 0 : NewRange (&s);
2543 : 0 : s->low = f->field;
2544 : 0 : s->high = s->low;
2545 : 0 : s->next = r;
2546 : 0 : if (r == NULL)
2547 : : {
2548 : 0 : r = s;
2549 : : }
2550 : 0 : f = f->next;
2551 : : }
2552 : 18160 : DisposeFields (&g);
2553 : 18160 : return r;
2554 : : /* static analysis guarentees a RETURN statement will be used before here. */
2555 : : __builtin_unreachable ();
2556 : : }
2557 : :
2558 : :
2559 : : /*
2560 : : ToArrayValue - converts a list of fields into an array initialiser.
2561 : : In effect it turns a generic constructor into
2562 : : an array type.
2563 : : */
2564 : :
2565 : 866 : static M2ALU_listOfElements ToArrayValue (unsigned int tok, M2ALU_listOfFields f)
2566 : : {
2567 : 866 : M2ALU_listOfFields g;
2568 : 866 : M2ALU_listOfElements r;
2569 : 866 : M2ALU_listOfElements s;
2570 : :
2571 : 866 : g = f;
2572 : 866 : r = NULL;
2573 : 866 : while (f != NULL)
2574 : : {
2575 : 0 : NewElement (&s);
2576 : 0 : s->element = f->field;
2577 : 0 : s->by = SymbolTable_MakeConstLit (tok, NameKey_MakeKey ((const char *) "1", 1), M2Base_ZType);
2578 : 0 : s->next = r;
2579 : 0 : if (r == NULL)
2580 : : {
2581 : 0 : r = s;
2582 : : }
2583 : 0 : f = f->next;
2584 : : }
2585 : 866 : DisposeFields (&g);
2586 : 866 : return r;
2587 : : /* static analysis guarentees a RETURN statement will be used before here. */
2588 : : __builtin_unreachable ();
2589 : : }
2590 : :
2591 : :
2592 : : /*
2593 : : CoerseTo - attempts to coerses a cellType, v, into, type, t.
2594 : : Normally this will be a generic constructors converting
2595 : : into set or array.
2596 : : */
2597 : :
2598 : 55776 : static M2ALU_PtrToValue__opaque CoerseTo (unsigned int tokenno, M2ALU_cellType t, M2ALU_PtrToValue__opaque v)
2599 : : {
2600 : 55776 : DynamicStrings_String s1;
2601 : 55776 : DynamicStrings_String s2;
2602 : 55776 : DynamicStrings_String s3;
2603 : :
2604 : 55776 : if (t == v->type)
2605 : : {
2606 : : return v;
2607 : : }
2608 : 21284 : else if ((v->type == M2ALU_constructor) && (t == M2ALU_set))
2609 : : {
2610 : : /* avoid dangling else. */
2611 : 18160 : v->type = M2ALU_set;
2612 : 18160 : v->setValue = ToSetValue (v->fieldValues);
2613 : 18160 : return v;
2614 : : }
2615 : 3124 : else if ((v->type == M2ALU_constructor) && (t == M2ALU_array))
2616 : : {
2617 : : /* avoid dangling else. */
2618 : 866 : v->type = M2ALU_array;
2619 : 866 : v->arrayValues = ToArrayValue (tokenno, v->fieldValues);
2620 : 866 : return v;
2621 : : }
2622 : 2258 : else if ((v->type == M2ALU_constructor) && (t == M2ALU_record))
2623 : : {
2624 : : /* avoid dangling else. */
2625 : : /* nothing to do other than change tag */
2626 : 2258 : v->type = M2ALU_record;
2627 : 2258 : return v;
2628 : : }
2629 : : else
2630 : : {
2631 : : /* avoid dangling else. */
2632 : 0 : s1 = cellTypeString (t);
2633 : 0 : s2 = cellTypeString (v->type);
2634 : 0 : s3 = DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) "cannot mix construction of a ", 29), DynamicStrings_Mark (DynamicStrings_ConCat (DynamicStrings_Mark (s1), DynamicStrings_Mark (DynamicStrings_ConCat (DynamicStrings_InitString ((const char *) " with a ", 8), DynamicStrings_Mark (s2))))));
2635 : 0 : M2MetaError_MetaErrorStringT0 (tokenno, s3);
2636 : 0 : return v;
2637 : : }
2638 : : /* static analysis guarentees a RETURN statement will be used before here. */
2639 : : __builtin_unreachable ();
2640 : : }
2641 : :
2642 : :
2643 : : /*
2644 : : AddElementToEnd - appends, e, to the end of list, v.
2645 : : */
2646 : :
2647 : 4202 : static void AddElementToEnd (M2ALU_PtrToValue__opaque v, M2ALU_listOfElements e)
2648 : : {
2649 : 4202 : M2ALU_listOfElements a;
2650 : :
2651 : 0 : if (v->arrayValues == NULL)
2652 : : {
2653 : 466 : v->arrayValues = e;
2654 : : }
2655 : : else
2656 : : {
2657 : : a = v->arrayValues;
2658 : 51888 : while (a->next != NULL)
2659 : : {
2660 : : a = a->next;
2661 : : }
2662 : 3736 : a->next = e;
2663 : : }
2664 : 0 : }
2665 : :
2666 : :
2667 : : /*
2668 : : AddFieldToEnd - appends, f, to the end of list, v.
2669 : : */
2670 : :
2671 : 9432 : static void AddFieldToEnd (M2ALU_PtrToValue__opaque v, M2ALU_listOfFields f)
2672 : : {
2673 : 9432 : M2ALU_listOfFields a;
2674 : :
2675 : 0 : if (v->fieldValues == NULL)
2676 : : {
2677 : 2258 : v->fieldValues = f;
2678 : : }
2679 : : else
2680 : : {
2681 : : a = v->fieldValues;
2682 : 16242 : while (a->next != NULL)
2683 : : {
2684 : : a = a->next;
2685 : : }
2686 : 7174 : a->next = f;
2687 : : }
2688 : 0 : }
2689 : :
2690 : :
2691 : : /*
2692 : : ElementsSolved - returns TRUE if all ranges in the set have been solved.
2693 : : */
2694 : :
2695 : 7384 : static bool ElementsSolved (unsigned int tokenno, M2ALU_listOfRange r)
2696 : : {
2697 : 18272 : while (r != NULL)
2698 : : {
2699 : 10894 : if (! (SymbolTable_IsConst (r->low)))
2700 : : {
2701 : 0 : M2MetaError_MetaErrorT1 (tokenno, (const char *) "a constant set can only contain constant set elements, {%1Ead} is not a constant", 80, r->low);
2702 : : }
2703 : 10894 : if ((r->high != r->low) && (! (SymbolTable_IsConst (r->high))))
2704 : : {
2705 : 6 : M2MetaError_MetaErrorT1 (tokenno, (const char *) "a constant set can only contain constant set elements, {%1Ead} is not a constant", 80, r->high);
2706 : : }
2707 : 10894 : if (! ((IsSolvedGCC (r->low)) && (IsSolvedGCC (r->high))))
2708 : : {
2709 : 0 : return false;
2710 : : }
2711 : 10888 : r = r->next;
2712 : : }
2713 : : return true;
2714 : : /* static analysis guarentees a RETURN statement will be used before here. */
2715 : : __builtin_unreachable ();
2716 : : }
2717 : :
2718 : :
2719 : : /*
2720 : : ArrayElementsSolved - returns TRUE if all ranges in the set have been solved.
2721 : : */
2722 : :
2723 : 448 : static bool ArrayElementsSolved (M2ALU_listOfElements e)
2724 : : {
2725 : 4596 : while (e != NULL)
2726 : : {
2727 : 4148 : if (! ((IsSolvedGCC (e->element)) && (IsSolvedGCC (e->by))))
2728 : : {
2729 : 0 : return false;
2730 : : }
2731 : 4148 : e = e->next;
2732 : : }
2733 : : return true;
2734 : : /* static analysis guarentees a RETURN statement will be used before here. */
2735 : : __builtin_unreachable ();
2736 : : }
2737 : :
2738 : :
2739 : : /*
2740 : : EvalFieldValues - returns TRUE if all fields in the record have been solved.
2741 : : */
2742 : :
2743 : 2240 : static bool EvalFieldValues (M2ALU_listOfFields e)
2744 : : {
2745 : 11618 : while (e != NULL)
2746 : : {
2747 : 9378 : if (SymbolTable_IsConst (e->field))
2748 : : {
2749 : : /* avoid dangling else. */
2750 : 9234 : if (! (IsSolvedGCC (e->field)))
2751 : : {
2752 : : return false;
2753 : : }
2754 : : }
2755 : : /* RETURN( FALSE ) */
2756 : 9378 : e = e->next;
2757 : : }
2758 : : return true;
2759 : : /* static analysis guarentees a RETURN statement will be used before here. */
2760 : : __builtin_unreachable ();
2761 : : }
2762 : :
2763 : :
2764 : : /*
2765 : : Swap - swaps the contents of, i, and, j.
2766 : : */
2767 : :
2768 : 11348 : static void Swap (M2ALU_listOfRange i, M2ALU_listOfRange j)
2769 : : {
2770 : 11348 : unsigned int t;
2771 : :
2772 : 11348 : t = i->low;
2773 : 11348 : i->low = j->low;
2774 : 11348 : j->low = t;
2775 : 11348 : t = i->high;
2776 : 11348 : i->high = j->high;
2777 : 11348 : j->high = t;
2778 : 0 : }
2779 : :
2780 : :
2781 : : /*
2782 : : DisplayElements -
2783 : : */
2784 : :
2785 : 0 : static void DisplayElements (M2ALU_listOfRange i)
2786 : : {
2787 : 0 : while (i != NULL)
2788 : : {
2789 : 0 : SymbolTable_PushValue (i->low);
2790 : 0 : PrintValue ();
2791 : 0 : Reduce ();
2792 : 0 : SymbolTable_PushValue (i->high);
2793 : 0 : PrintValue ();
2794 : 0 : Reduce ();
2795 : 0 : i = i->next;
2796 : : }
2797 : 0 : }
2798 : :
2799 : :
2800 : : /*
2801 : : SortElements - sorts the list as defined by, h, into ascending range order.
2802 : : The low element is the sort key.
2803 : : */
2804 : :
2805 : 7590 : static void SortElements (unsigned int tokenno, M2ALU_listOfRange h)
2806 : : {
2807 : 7590 : M2ALU_listOfRange i;
2808 : 7590 : M2ALU_listOfRange j;
2809 : 7590 : M2ALU_listOfRange k;
2810 : :
2811 : 7590 : i = h;
2812 : 18938 : while (i != NULL)
2813 : : {
2814 : 11348 : j = i;
2815 : 11348 : k = i->next;
2816 : 27830 : while (k != NULL)
2817 : : {
2818 : 16482 : SymbolTable_PushValue (k->low);
2819 : 16482 : M2ALU_ConvertToInt ();
2820 : 16482 : SymbolTable_PushValue (j->low);
2821 : 16482 : M2ALU_ConvertToInt ();
2822 : 16482 : if (M2ALU_Less (tokenno))
2823 : : {
2824 : 5996 : j = k;
2825 : : }
2826 : 16482 : k = k->next;
2827 : : }
2828 : 11348 : Swap (i, j);
2829 : 11348 : i = i->next;
2830 : : }
2831 : 7590 : }
2832 : :
2833 : :
2834 : : /*
2835 : : CombineElements - given a sorted list determine whether there is any
2836 : : overlap in the low..high bounds. If overlap exists
2837 : : then remove it.
2838 : : */
2839 : :
2840 : 7590 : static void CombineElements (unsigned int tokenno, M2ALU_listOfRange r)
2841 : : {
2842 : 7590 : M2ALU_listOfRange t;
2843 : 7590 : M2ALU_listOfRange j;
2844 : :
2845 : 16034 : while (r != NULL)
2846 : : {
2847 : 8444 : j = r->next;
2848 : 13342 : while (j != NULL)
2849 : : {
2850 : 4898 : SymbolTable_PushValue (r->high);
2851 : 4898 : M2ALU_ConvertToInt ();
2852 : 4898 : M2ALU_PushCard (1);
2853 : 4898 : M2ALU_Addn ();
2854 : 4898 : SymbolTable_PushValue (j->low);
2855 : 4898 : M2ALU_ConvertToInt ();
2856 : 4898 : if (M2ALU_GreEqu (tokenno))
2857 : : {
2858 : 2904 : r->high = j->high;
2859 : 2904 : t = j->next;
2860 : 2904 : r->next = j->next;
2861 : 2904 : j->next = NULL;
2862 : 2904 : DisposeRange (&j);
2863 : 2904 : j = t;
2864 : : }
2865 : : else
2866 : : {
2867 : 1994 : j = NULL;
2868 : : }
2869 : : }
2870 : 8444 : r = r->next;
2871 : : }
2872 : 7590 : }
2873 : :
2874 : :
2875 : : /*
2876 : : EvalSetValues - returns TRUE if all elements in this set have been resolved.
2877 : : */
2878 : :
2879 : 7384 : static bool EvalSetValues (unsigned int tokenno, M2ALU_listOfRange r)
2880 : : {
2881 : 7384 : if (ElementsSolved (tokenno, r))
2882 : : {
2883 : 7378 : SortElements (tokenno, r);
2884 : 7378 : CombineElements (tokenno, r);
2885 : 7378 : return true;
2886 : : }
2887 : : else
2888 : : {
2889 : : return false;
2890 : : }
2891 : : /* static analysis guarentees a RETURN statement will be used before here. */
2892 : : __builtin_unreachable ();
2893 : : }
2894 : :
2895 : :
2896 : : /*
2897 : : Eval - attempts to solve a constructor type.
2898 : : */
2899 : :
2900 : 56490 : static void Eval (unsigned int tokenno, M2ALU_PtrToValue__opaque v)
2901 : : {
2902 : 56490 : CheckNotAlreadyOnFreeList (v);
2903 : 56490 : if (! v->solved)
2904 : : {
2905 : 23834 : if (SymbolTable_IsSet (SymbolTable_SkipType (v->constructorType)))
2906 : : {
2907 : 18524 : v = CoerseTo (tokenno, M2ALU_set, v);
2908 : : }
2909 : 5310 : else if (SymbolTable_IsRecord (SymbolTable_SkipType (v->constructorType)))
2910 : : {
2911 : : /* avoid dangling else. */
2912 : 3056 : v = CoerseTo (tokenno, M2ALU_record, v);
2913 : : }
2914 : 2254 : else if (SymbolTable_IsArray (SymbolTable_SkipType (v->constructorType)))
2915 : : {
2916 : : /* avoid dangling else. */
2917 : 2254 : v = CoerseTo (tokenno, M2ALU_array, v);
2918 : : }
2919 : 23834 : v->areAllConstants = DefinedByConstants (v);
2920 : 23834 : switch (v->type)
2921 : : {
2922 : 18524 : case M2ALU_set:
2923 : 37048 : M2Debug_Assert ((v->constructorType == SymbolTable_NulSym) || (SymbolTable_IsSet (SymbolTable_SkipType (v->constructorType))));
2924 : 18524 : v->solved = (M2GCCDeclare_CompletelyResolved (v->constructorType)) && (EvalSetValues (tokenno, v->setValue));
2925 : 18518 : break;
2926 : :
2927 : 2254 : case M2ALU_array:
2928 : 4508 : M2Debug_Assert ((v->constructorType == SymbolTable_NulSym) || (SymbolTable_IsArray (SymbolTable_SkipType (v->constructorType))));
2929 : 2254 : v->solved = (M2GCCDeclare_CompletelyResolved (v->constructorType)) && (ArrayElementsSolved (v->arrayValues));
2930 : 2254 : break;
2931 : :
2932 : 3056 : case M2ALU_record:
2933 : 6112 : M2Debug_Assert ((v->constructorType == SymbolTable_NulSym) || (SymbolTable_IsRecord (SymbolTable_SkipType (v->constructorType))));
2934 : 3056 : v->solved = (M2GCCDeclare_CompletelyResolved (v->constructorType)) && (EvalFieldValues (v->fieldValues));
2935 : 3056 : break;
2936 : :
2937 : :
2938 : : default:
2939 : : break;
2940 : : }
2941 : : }
2942 : : /* do nothing */
2943 : 56484 : }
2944 : :
2945 : :
2946 : : /*
2947 : : WalkSetValueDependants -
2948 : : */
2949 : :
2950 : 221858 : static void WalkSetValueDependants (M2ALU_listOfRange r, M2GCCDeclare_WalkAction p)
2951 : : {
2952 : 489480 : while (r != NULL)
2953 : : {
2954 : 267622 : (*p.proc) (r->low);
2955 : 267622 : (*p.proc) (r->high);
2956 : 267622 : r = r->next;
2957 : : }
2958 : 221858 : }
2959 : :
2960 : :
2961 : : /*
2962 : : IsSetValueDependants -
2963 : : */
2964 : :
2965 : 18790 : static bool IsSetValueDependants (M2ALU_listOfRange r, M2GCCDeclare_IsAction q)
2966 : : {
2967 : 18790 : bool result;
2968 : :
2969 : 18790 : result = true;
2970 : 44742 : while (r != NULL)
2971 : : {
2972 : 25952 : if (! ((*q.proc) (r->low)))
2973 : : {
2974 : 15700 : result = false;
2975 : : }
2976 : 25952 : if (! ((*q.proc) (r->high)))
2977 : : {
2978 : 15700 : result = false;
2979 : : }
2980 : 25952 : r = r->next;
2981 : : }
2982 : 18790 : return result;
2983 : : /* static analysis guarentees a RETURN statement will be used before here. */
2984 : : __builtin_unreachable ();
2985 : : }
2986 : :
2987 : :
2988 : : /*
2989 : : WalkFieldValueDependants -
2990 : : */
2991 : :
2992 : 408836 : static void WalkFieldValueDependants (M2ALU_listOfFields f, M2GCCDeclare_WalkAction p)
2993 : : {
2994 : 2172308 : while (f != NULL)
2995 : : {
2996 : 1763472 : (*p.proc) (f->field);
2997 : 1763472 : f = f->next;
2998 : : }
2999 : 0 : }
3000 : :
3001 : :
3002 : : /*
3003 : : IsFieldValueDependants -
3004 : : */
3005 : :
3006 : 15388 : static bool IsFieldValueDependants (M2ALU_listOfFields f, M2GCCDeclare_IsAction q)
3007 : : {
3008 : 15388 : bool result;
3009 : :
3010 : 15388 : result = true;
3011 : 56350 : while (f != NULL)
3012 : : {
3013 : 40962 : if (! ((*q.proc) (f->field)))
3014 : : {
3015 : 23970 : result = false;
3016 : : }
3017 : 40962 : f = f->next;
3018 : : }
3019 : 15388 : return result;
3020 : : /* static analysis guarentees a RETURN statement will be used before here. */
3021 : : __builtin_unreachable ();
3022 : : }
3023 : :
3024 : :
3025 : : /*
3026 : : WalkArrayValueDependants -
3027 : : */
3028 : :
3029 : 85884 : static void WalkArrayValueDependants (M2ALU_listOfElements a, M2GCCDeclare_WalkAction p)
3030 : : {
3031 : 999178 : while (a != NULL)
3032 : : {
3033 : 913294 : (*p.proc) (a->element);
3034 : 913294 : (*p.proc) (a->by);
3035 : 913294 : a = a->next;
3036 : : }
3037 : 85884 : }
3038 : :
3039 : :
3040 : : /*
3041 : : IsArrayValueDependants -
3042 : : */
3043 : :
3044 : 2530 : static bool IsArrayValueDependants (M2ALU_listOfElements a, M2GCCDeclare_IsAction q)
3045 : : {
3046 : 2530 : bool result;
3047 : :
3048 : 2530 : result = true;
3049 : 27954 : while (a != NULL)
3050 : : {
3051 : 25424 : if (! ((*q.proc) (a->element)))
3052 : : {
3053 : 18618 : result = false;
3054 : : }
3055 : 25424 : if (! ((*q.proc) (a->by)))
3056 : : {
3057 : 19218 : result = false;
3058 : : }
3059 : 25424 : a = a->next;
3060 : : }
3061 : 2530 : return result;
3062 : : /* static analysis guarentees a RETURN statement will be used before here. */
3063 : : __builtin_unreachable ();
3064 : : }
3065 : :
3066 : :
3067 : : /*
3068 : : DefinedByConstants - returns TRUE if the value, v, is defined by constants.
3069 : : It assigns, v^.areAllConstants, with the result.
3070 : : */
3071 : :
3072 : 23834 : static bool DefinedByConstants (M2ALU_PtrToValue__opaque v)
3073 : : {
3074 : 23834 : switch (v->type)
3075 : : {
3076 : 0 : case M2ALU_none:
3077 : 0 : case M2ALU_integer:
3078 : 0 : case M2ALU_real:
3079 : 0 : case M2ALU_complex:
3080 : 0 : v->areAllConstants = true;
3081 : 0 : break;
3082 : :
3083 : 18524 : case M2ALU_set:
3084 : 18524 : v->areAllConstants = rangeConstant (v->setValue);
3085 : 18524 : break;
3086 : :
3087 : 3056 : case M2ALU_constructor:
3088 : 3056 : case M2ALU_record:
3089 : 3056 : v->areAllConstants = fieldsConstant (v->fieldValues);
3090 : 3056 : break;
3091 : :
3092 : 2254 : case M2ALU_array:
3093 : 2254 : v->areAllConstants = arrayConstant (v->arrayValues);
3094 : 2254 : break;
3095 : :
3096 : :
3097 : 0 : default:
3098 : 0 : M2Error_InternalError ((const char *) "unexpected type", 15);
3099 : 23834 : break;
3100 : : }
3101 : 23834 : return v->areAllConstants;
3102 : : /* static analysis guarentees a RETURN statement will be used before here. */
3103 : : __builtin_unreachable ();
3104 : : }
3105 : :
3106 : :
3107 : : /*
3108 : : rangeConstant - returns TRUE if all the range entities are constant.
3109 : : */
3110 : :
3111 : 18524 : static bool rangeConstant (M2ALU_listOfRange r)
3112 : : {
3113 : 44680 : while (r != NULL)
3114 : : {
3115 : 26162 : if ((! (SymbolTable_IsConst (r->low))) || (! (SymbolTable_IsConst (r->high))))
3116 : : {
3117 : 6 : return false;
3118 : : }
3119 : 26156 : r = r->next;
3120 : : }
3121 : : return true;
3122 : : /* static analysis guarentees a RETURN statement will be used before here. */
3123 : : __builtin_unreachable ();
3124 : : }
3125 : :
3126 : :
3127 : : /*
3128 : : fieldsConstant - returns TRUE if all the field entities are constant.
3129 : : */
3130 : :
3131 : 3056 : static bool fieldsConstant (M2ALU_listOfFields f)
3132 : : {
3133 : 13928 : while (f != NULL)
3134 : : {
3135 : 11124 : if (! (SymbolTable_IsConst (f->field)))
3136 : : {
3137 : : return false;
3138 : : }
3139 : 10872 : f = f->next;
3140 : : }
3141 : : return true;
3142 : : /* static analysis guarentees a RETURN statement will be used before here. */
3143 : : __builtin_unreachable ();
3144 : : }
3145 : :
3146 : :
3147 : : /*
3148 : : arrayConstant - returns TRUE if the, element, and, by, components
3149 : : of an array constructor are constant.
3150 : : */
3151 : :
3152 : 2254 : static bool arrayConstant (M2ALU_listOfElements e)
3153 : : {
3154 : 25620 : while (e != NULL)
3155 : : {
3156 : 23366 : if ((! (SymbolTable_IsConst (e->element))) && (! (SymbolTable_IsConst (e->by))))
3157 : : {
3158 : : return false;
3159 : : }
3160 : 23366 : e = e->next;
3161 : : }
3162 : : return true;
3163 : : /* static analysis guarentees a RETURN statement will be used before here. */
3164 : : __builtin_unreachable ();
3165 : : }
3166 : :
3167 : :
3168 : : /*
3169 : : FindValueEnum -
3170 : : */
3171 : :
3172 : 0 : static void FindValueEnum (unsigned int field)
3173 : : {
3174 : 0 : SymbolTable_PushValue (field);
3175 : 0 : M2ALU_PushIntegerTree (EnumerationValue);
3176 : 0 : if (M2ALU_Equ (CurrentTokenNo))
3177 : : {
3178 : 0 : EnumerationField = static_cast<unsigned int> (field);
3179 : : }
3180 : 0 : }
3181 : :
3182 : :
3183 : : /*
3184 : : Val - returns a GCC symbol enumeration or a GCC constant which has, value, and which is
3185 : : of type, type.
3186 : : */
3187 : :
3188 : 24 : static unsigned int Val (unsigned int tokenno, unsigned int type, tree value)
3189 : : {
3190 : 24 : unsigned int sym;
3191 : :
3192 : 24 : if (SymbolTable_IsEnumeration (type))
3193 : : {
3194 : 0 : EnumerationField = SymbolTable_NulSym;
3195 : 0 : EnumerationValue = value;
3196 : 0 : CurrentTokenNo = tokenno;
3197 : 0 : SymbolTable_ForeachFieldEnumerationDo (type, (SymbolKey_PerformOperation) {(SymbolKey_PerformOperation_t) FindValueEnum});
3198 : 0 : if (EnumerationField == SymbolTable_NulSym)
3199 : : {
3200 : 0 : M2Error_InternalError ((const char *) "enumeration value exceeds range", 31);
3201 : : }
3202 : : return EnumerationField;
3203 : : }
3204 : : else
3205 : : {
3206 : 24 : sym = SymbolTable_MakeTemporary (tokenno, SymbolTable_ImmediateValue);
3207 : 24 : SymbolTable_PutVar (sym, type);
3208 : 24 : CheckOverflow (tokenno, value);
3209 : 24 : M2ALU_PushIntegerTree (value);
3210 : 24 : SymbolTable_PopValue (sym);
3211 : 24 : return sym;
3212 : : }
3213 : : /* static analysis guarentees a RETURN statement will be used before here. */
3214 : : __builtin_unreachable ();
3215 : : }
3216 : :
3217 : :
3218 : : /*
3219 : : DupConst - duplicates and returns a constant, sym, but adds, offset to its value.
3220 : : */
3221 : :
3222 : 24 : static unsigned int DupConst (unsigned int tokenno, unsigned int sym, int offset)
3223 : : {
3224 : 24 : SymbolTable_PushValue (sym);
3225 : 24 : M2ALU_PushInt (offset);
3226 : 24 : M2ALU_Addn ();
3227 : 24 : return Val (tokenno, SymbolTable_GetType (sym), M2ALU_PopIntegerTree ());
3228 : : /* static analysis guarentees a RETURN statement will be used before here. */
3229 : : __builtin_unreachable ();
3230 : : }
3231 : :
3232 : :
3233 : : /*
3234 : : DupConstAndAdd - duplicates and returns a constant, sym,
3235 : : but adds the symbol, extra.
3236 : : */
3237 : :
3238 : 0 : static unsigned int DupConstAndAdd (unsigned int tokenno, unsigned int sym, tree extra)
3239 : : {
3240 : 0 : SymbolTable_PushValue (sym);
3241 : 0 : M2ALU_PushIntegerTree (extra);
3242 : 0 : M2ALU_Addn ();
3243 : 0 : return Val (tokenno, SymbolTable_GetType (sym), M2ALU_PopIntegerTree ());
3244 : : /* static analysis guarentees a RETURN statement will be used before here. */
3245 : : __builtin_unreachable ();
3246 : : }
3247 : :
3248 : :
3249 : : /*
3250 : : DupConstAndAddMod - duplicates and returns a constant, sym,
3251 : : but adds the symbol, extra, and ensures that
3252 : : the result in within limits: min..max using
3253 : : modulo arithmetic.
3254 : : */
3255 : :
3256 : 0 : static unsigned int DupConstAndAddMod (unsigned int tokenno, unsigned int sym, tree extra, unsigned int l, unsigned int h)
3257 : : {
3258 : : /* result := (((sym-l) + extra) MOD (h-l)) + l) */
3259 : 0 : SymbolTable_PushValue (sym);
3260 : 0 : SymbolTable_PushValue (l);
3261 : 0 : M2ALU_Sub ();
3262 : 0 : M2ALU_PushIntegerTree (extra);
3263 : 0 : M2ALU_Addn ();
3264 : 0 : SymbolTable_PushValue (h);
3265 : 0 : SymbolTable_PushValue (l);
3266 : 0 : M2ALU_Sub ();
3267 : 0 : M2ALU_ModTrunc ();
3268 : 0 : SymbolTable_PushValue (l);
3269 : 0 : M2ALU_Addn ();
3270 : 0 : return Val (tokenno, SymbolTable_GetType (sym), M2ALU_PopIntegerTree ());
3271 : : /* static analysis guarentees a RETURN statement will be used before here. */
3272 : : __builtin_unreachable ();
3273 : : }
3274 : :
3275 : :
3276 : : /*
3277 : : Remove - removes, v, from list, h.
3278 : : */
3279 : :
3280 : 0 : static void Remove (M2ALU_listOfRange *h, M2ALU_listOfRange v)
3281 : : {
3282 : 0 : M2ALU_listOfRange i;
3283 : :
3284 : 0 : if ((*h) == v)
3285 : : {
3286 : 0 : (*h) = (*h)->next;
3287 : : }
3288 : : else
3289 : : {
3290 : : i = (*h);
3291 : 0 : while ((i != NULL) && (i->next != v))
3292 : : {
3293 : : i = i->next;
3294 : : }
3295 : 0 : if (i == NULL)
3296 : : {
3297 : 0 : M2Error_InternalError ((const char *) "expecting v to be on the list", 29);
3298 : : }
3299 : : else
3300 : : {
3301 : 0 : i = v->next;
3302 : : }
3303 : : }
3304 : 0 : v->next = NULL;
3305 : 0 : DisposeRange (&v);
3306 : 0 : }
3307 : :
3308 : :
3309 : : /*
3310 : : RemoveBit - remove bit, op1, from range, v, on list, h.
3311 : : */
3312 : :
3313 : 0 : static void RemoveBit (unsigned int tokenno, M2ALU_listOfRange *h, M2ALU_listOfRange v, unsigned int op1)
3314 : : {
3315 : 0 : SymbolTable_PushValue (v->low);
3316 : 0 : SymbolTable_PushValue (v->high);
3317 : 0 : if (M2ALU_Equ (tokenno))
3318 : : {
3319 : : /* avoid dangling else. */
3320 : : /* single bit in this range */
3321 : 0 : SymbolTable_PushValue (v->low);
3322 : 0 : SymbolTable_PushValue (op1);
3323 : 0 : if (M2ALU_Equ (tokenno))
3324 : : {
3325 : : /* remove entry */
3326 : 0 : Remove (h, v);
3327 : 0 : return;
3328 : : }
3329 : : }
3330 : : else
3331 : : {
3332 : : /* is op1 equal to low? */
3333 : 0 : SymbolTable_PushValue (op1);
3334 : 0 : SymbolTable_PushValue (v->low);
3335 : 0 : if (M2ALU_Equ (tokenno))
3336 : : {
3337 : 0 : v->low = DupConst (tokenno, v->low, 1);
3338 : : }
3339 : : else
3340 : : {
3341 : 0 : SymbolTable_PushValue (op1);
3342 : 0 : SymbolTable_PushValue (v->high);
3343 : 0 : if (M2ALU_Equ (tokenno))
3344 : : {
3345 : 0 : v->high = DupConst (tokenno, v->high, -1);
3346 : : }
3347 : : else
3348 : : {
3349 : 0 : v->high = DupConst (tokenno, op1, -1);
3350 : 0 : (*h) = AddRange ((*h), DupConst (tokenno, op1, 1), v->high);
3351 : 0 : SortElements (tokenno, (*h));
3352 : : }
3353 : : }
3354 : : }
3355 : : }
3356 : :
3357 : :
3358 : : /*
3359 : : PerformSubBit -
3360 : : */
3361 : :
3362 : 0 : static void PerformSubBit (unsigned int tokenno, M2ALU_listOfRange *h, unsigned int op1)
3363 : : {
3364 : 0 : M2ALU_listOfRange v;
3365 : :
3366 : 0 : v = (*h);
3367 : 0 : while (v != NULL)
3368 : : {
3369 : 0 : SymbolTable_PushValue (v->low);
3370 : 0 : SymbolTable_PushValue (op1);
3371 : 0 : if (M2ALU_LessEqu (tokenno))
3372 : : {
3373 : 0 : SymbolTable_PushValue (op1);
3374 : 0 : SymbolTable_PushValue (v->high);
3375 : 0 : if (M2ALU_LessEqu (tokenno))
3376 : : {
3377 : 0 : RemoveBit (tokenno, h, v, op1);
3378 : 0 : return;
3379 : : }
3380 : : }
3381 : 0 : v = v->next;
3382 : : }
3383 : : }
3384 : :
3385 : :
3386 : : /*
3387 : : PerformSetIn - returns TRUE if op1 is in set.
3388 : : */
3389 : :
3390 : 0 : static bool PerformSetIn (unsigned int tokenno, unsigned int op1, M2ALU_listOfRange h)
3391 : : {
3392 : 0 : while (h != NULL)
3393 : : {
3394 : 0 : SymbolTable_PushValue (op1);
3395 : 0 : M2ALU_ConvertToInt ();
3396 : 0 : SymbolTable_PushValue (h->low);
3397 : 0 : M2ALU_ConvertToInt ();
3398 : 0 : if (M2ALU_GreEqu (tokenno))
3399 : : {
3400 : : /* avoid dangling else. */
3401 : 0 : SymbolTable_PushValue (op1);
3402 : 0 : SymbolTable_PushValue (h->high);
3403 : 0 : if (M2ALU_LessEqu (tokenno))
3404 : : {
3405 : : return true;
3406 : : }
3407 : : }
3408 : : else
3409 : : {
3410 : : /* op1 is smaller than this and all subsequent ranges */
3411 : : return false;
3412 : : }
3413 : 0 : h = h->next;
3414 : : }
3415 : : return false;
3416 : : /* static analysis guarentees a RETURN statement will be used before here. */
3417 : : __builtin_unreachable ();
3418 : : }
3419 : :
3420 : :
3421 : : /*
3422 : : SetOp - perform the function doOp on the top two elements of the stack.
3423 : : */
3424 : :
3425 : 218 : static void SetOp (unsigned int tokenno, M2ALU_DoSetProcedure doOp)
3426 : : {
3427 : 218 : M2ALU_PtrToValue__opaque Result;
3428 : 218 : M2ALU_PtrToValue__opaque Set1;
3429 : 218 : M2ALU_PtrToValue__opaque Set2;
3430 : :
3431 : 218 : Set1 = Pop ();
3432 : 218 : Set2 = Pop ();
3433 : 218 : Eval (tokenno, Set1);
3434 : 218 : Eval (tokenno, Set2);
3435 : 218 : if (! (Set1->solved && Set2->solved))
3436 : : {
3437 : 0 : M2Error_InternalError ((const char *) "one or more operands have not been resolved", 43);
3438 : : }
3439 : 218 : if (Set1->type != M2ALU_set)
3440 : : {
3441 : 0 : M2Error_InternalError ((const char *) "expecting type of constant to be a set", 38);
3442 : : }
3443 : 218 : if (Set2->type != M2ALU_set)
3444 : : {
3445 : 0 : M2Error_InternalError ((const char *) "expecting type of constant to be a set", 38);
3446 : : }
3447 : 218 : Result = New ();
3448 : 218 : Result->type = M2ALU_set;
3449 : 218 : Result->setValue = (*doOp.proc) (tokenno, Set1->setValue, Set2->setValue);
3450 : 218 : Result->constructorType = M2Base_MixTypes (Set1->constructorType, Set2->constructorType, tokenno);
3451 : 218 : Result->solved = false;
3452 : : /* Set1 and Set2 have given their range lists to the Result */
3453 : 218 : Set1->setValue = NULL;
3454 : 218 : Set2->setValue = NULL;
3455 : 218 : Eval (tokenno, Result);
3456 : 218 : Push (Result);
3457 : 218 : Dispose (Set1);
3458 : 218 : Dispose (Set2);
3459 : 218 : }
3460 : :
3461 : :
3462 : : /*
3463 : : PerformOr - performs a logical OR between the two ranges.
3464 : : The ranges, r1, r2, are destroyed.
3465 : : */
3466 : :
3467 : 212 : static M2ALU_listOfRange PerformOr (unsigned int tokenno, M2ALU_listOfRange r1, M2ALU_listOfRange r2)
3468 : : {
3469 : 212 : M2ALU_listOfRange i;
3470 : :
3471 : 212 : i = r1;
3472 : 212 : while ((i != NULL) && (i->next != NULL))
3473 : : {
3474 : : i = i->next;
3475 : : }
3476 : 212 : if (i == NULL)
3477 : : {
3478 : : r1 = r2;
3479 : : }
3480 : : else
3481 : : {
3482 : 212 : i->next = r2;
3483 : : }
3484 : 212 : SortElements (tokenno, r1);
3485 : 212 : CombineElements (tokenno, r1);
3486 : 212 : return r1;
3487 : : /* static analysis guarentees a RETURN statement will be used before here. */
3488 : : __builtin_unreachable ();
3489 : : }
3490 : :
3491 : :
3492 : : /*
3493 : : Min - returns the symbol which has the least value.
3494 : : */
3495 : :
3496 : 6 : static unsigned int Min (unsigned int tokenno, unsigned int a, unsigned int b)
3497 : : {
3498 : 6 : SymbolTable_PushValue (a);
3499 : 6 : M2ALU_ConvertToInt ();
3500 : 6 : SymbolTable_PushValue (b);
3501 : 6 : M2ALU_ConvertToInt ();
3502 : 6 : if (M2ALU_Less (tokenno))
3503 : : {
3504 : : return a;
3505 : : }
3506 : : else
3507 : : {
3508 : 6 : return b;
3509 : : }
3510 : : /* static analysis guarentees a RETURN statement will be used before here. */
3511 : : __builtin_unreachable ();
3512 : : }
3513 : :
3514 : :
3515 : : /*
3516 : : Max - returns the symbol which has the greatest value.
3517 : : */
3518 : :
3519 : 6 : static unsigned int Max (unsigned int tokenno, unsigned int a, unsigned int b)
3520 : : {
3521 : 6 : SymbolTable_PushValue (a);
3522 : 6 : M2ALU_ConvertToInt ();
3523 : 6 : SymbolTable_PushValue (b);
3524 : 6 : M2ALU_ConvertToInt ();
3525 : 6 : if (M2ALU_Gre (tokenno))
3526 : : {
3527 : : return a;
3528 : : }
3529 : : else
3530 : : {
3531 : 6 : return b;
3532 : : }
3533 : : /* static analysis guarentees a RETURN statement will be used before here. */
3534 : : __builtin_unreachable ();
3535 : : }
3536 : :
3537 : :
3538 : : /*
3539 : : IsRangeIntersection - returns TRUE if ranges, r1, and, r2, intersect.
3540 : : */
3541 : :
3542 : 6 : static bool IsRangeIntersection (unsigned int tokenno, M2ALU_listOfRange r1, M2ALU_listOfRange r2)
3543 : : {
3544 : 6 : if ((r1 == NULL) || (r2 == NULL))
3545 : : {
3546 : : return false;
3547 : : }
3548 : : else
3549 : : {
3550 : : /* easier to prove NOT outside limits */
3551 : 6 : SymbolTable_PushValue (r1->low);
3552 : 6 : M2ALU_ConvertToInt ();
3553 : 6 : SymbolTable_PushValue (r2->high);
3554 : 6 : M2ALU_ConvertToInt ();
3555 : 6 : if (M2ALU_Gre (tokenno))
3556 : : {
3557 : : return false;
3558 : : }
3559 : : else
3560 : : {
3561 : 6 : SymbolTable_PushValue (r1->high);
3562 : 6 : M2ALU_ConvertToInt ();
3563 : 6 : SymbolTable_PushValue (r2->low);
3564 : 6 : M2ALU_ConvertToInt ();
3565 : 6 : if (M2ALU_Less (tokenno))
3566 : : {
3567 : : return false;
3568 : : }
3569 : : else
3570 : : {
3571 : : return true;
3572 : : }
3573 : : }
3574 : : }
3575 : : /* static analysis guarentees a RETURN statement will be used before here. */
3576 : : __builtin_unreachable ();
3577 : : }
3578 : :
3579 : :
3580 : : /*
3581 : : IsRangeLess - returns TRUE if r1^.low is < r2^.low
3582 : : */
3583 : :
3584 : 0 : static bool IsRangeLess (unsigned int tokenno, M2ALU_listOfRange r1, M2ALU_listOfRange r2)
3585 : : {
3586 : 0 : if ((r1 == NULL) || (r2 == NULL))
3587 : : {
3588 : 0 : M2Error_InternalError ((const char *) "not expecting NIL ranges", 24);
3589 : : }
3590 : 0 : SymbolTable_PushValue (r1->high);
3591 : 0 : M2ALU_ConvertToInt ();
3592 : 0 : SymbolTable_PushValue (r2->low);
3593 : 0 : M2ALU_ConvertToInt ();
3594 : 0 : return M2ALU_Less (tokenno);
3595 : : /* static analysis guarentees a RETURN statement will be used before here. */
3596 : : __builtin_unreachable ();
3597 : : }
3598 : :
3599 : :
3600 : : /*
3601 : : MinTree - returns the tree symbol which has the least value.
3602 : : */
3603 : :
3604 : 9066 : static tree MinTree (unsigned int tokenno, tree a, tree b)
3605 : : {
3606 : 9066 : M2ALU_PushIntegerTree (a);
3607 : 9066 : M2ALU_ConvertToInt ();
3608 : 9066 : M2ALU_PushIntegerTree (b);
3609 : 9066 : M2ALU_ConvertToInt ();
3610 : 9066 : if (M2ALU_Less (tokenno))
3611 : : {
3612 : : return a;
3613 : : }
3614 : : else
3615 : : {
3616 : 1058 : return b;
3617 : : }
3618 : : /* static analysis guarentees a RETURN statement will be used before here. */
3619 : : __builtin_unreachable ();
3620 : : }
3621 : :
3622 : :
3623 : : /*
3624 : : MaxTree - returns the symbol which has the greatest value.
3625 : : */
3626 : :
3627 : 9066 : static tree MaxTree (unsigned int tokenno, tree a, tree b)
3628 : : {
3629 : 9066 : M2ALU_PushIntegerTree (a);
3630 : 9066 : M2ALU_ConvertToInt ();
3631 : 9066 : M2ALU_PushIntegerTree (b);
3632 : 9066 : M2ALU_ConvertToInt ();
3633 : 9066 : if (M2ALU_Gre (tokenno))
3634 : : {
3635 : : return a;
3636 : : }
3637 : : else
3638 : : {
3639 : 1846 : return b;
3640 : : }
3641 : : /* static analysis guarentees a RETURN statement will be used before here. */
3642 : : __builtin_unreachable ();
3643 : : }
3644 : :
3645 : :
3646 : : /*
3647 : : IsIntersectionTree - returns TRUE if ranges, a..b, and, c..d, intersect.
3648 : : */
3649 : :
3650 : 38222 : static bool IsIntersectionTree (unsigned int tokenno, tree a, tree b, tree c, tree d)
3651 : : {
3652 : : /* easier to prove NOT outside limits */
3653 : 38222 : M2ALU_PushIntegerTree (a);
3654 : 38222 : M2ALU_ConvertToInt ();
3655 : 38222 : M2ALU_PushIntegerTree (d);
3656 : 38222 : M2ALU_ConvertToInt ();
3657 : 38222 : if (M2ALU_Gre (tokenno))
3658 : : {
3659 : : return false;
3660 : : }
3661 : : else
3662 : : {
3663 : 33066 : M2ALU_PushIntegerTree (b);
3664 : 33066 : M2ALU_ConvertToInt ();
3665 : 33066 : M2ALU_PushIntegerTree (c);
3666 : 33066 : M2ALU_ConvertToInt ();
3667 : 33066 : if (M2ALU_Less (tokenno))
3668 : : {
3669 : : return false;
3670 : : }
3671 : : else
3672 : : {
3673 : : return true;
3674 : : }
3675 : : }
3676 : : /* static analysis guarentees a RETURN statement will be used before here. */
3677 : : __builtin_unreachable ();
3678 : : }
3679 : :
3680 : :
3681 : : /*
3682 : : SubTree - returns the tree value containing (a-b)
3683 : : */
3684 : :
3685 : 18132 : static tree SubTree (tree a, tree b)
3686 : : {
3687 : 18132 : M2ALU_PushIntegerTree (a);
3688 : 18132 : M2ALU_PushIntegerTree (b);
3689 : 18132 : M2ALU_Sub ();
3690 : 18132 : return M2ALU_PopIntegerTree ();
3691 : : /* static analysis guarentees a RETURN statement will be used before here. */
3692 : : __builtin_unreachable ();
3693 : : }
3694 : :
3695 : :
3696 : : /*
3697 : : PerformAnd - performs a logical AND between the two ranges.
3698 : : The ranges, r1, r2, are unaltered.
3699 : : */
3700 : :
3701 : 6 : static M2ALU_listOfRange PerformAnd (unsigned int tokenno, M2ALU_listOfRange r1, M2ALU_listOfRange r2)
3702 : : {
3703 : 6 : M2ALU_listOfRange r;
3704 : :
3705 : 6 : r = NULL;
3706 : 12 : while ((r1 != NULL) && (r2 != NULL))
3707 : : {
3708 : 6 : if (IsRangeIntersection (tokenno, r1, r2))
3709 : : {
3710 : 6 : r = AddRange (r, Max (tokenno, r1->low, r2->low), Min (tokenno, r1->high, r2->high));
3711 : 6 : if (r->high == r1->high)
3712 : : {
3713 : 0 : r1 = r1->next;
3714 : : }
3715 : : else
3716 : : {
3717 : 6 : r2 = r2->next;
3718 : : }
3719 : : }
3720 : 0 : else if (IsRangeLess (tokenno, r1, r2))
3721 : : {
3722 : : /* avoid dangling else. */
3723 : : /* move r1 onto the next range */
3724 : 0 : r1 = r1->next;
3725 : : }
3726 : : else
3727 : : {
3728 : : /* avoid dangling else. */
3729 : : /* move r2 onto the next range */
3730 : 0 : r2 = r2->next;
3731 : : }
3732 : : }
3733 : 6 : return r;
3734 : : /* static analysis guarentees a RETURN statement will be used before here. */
3735 : : __builtin_unreachable ();
3736 : : }
3737 : :
3738 : :
3739 : : /*
3740 : : BuildStructBitset - v is the PtrToValue.
3741 : : low and high are the limits of the subrange.
3742 : : */
3743 : :
3744 : 1688 : static tree BuildStructBitset (unsigned int tokenno, M2ALU_PtrToValue__opaque v, tree low, tree high)
3745 : : {
3746 : 1688 : tree BitsInSet;
3747 : 1688 : unsigned int bpw;
3748 : 1688 : m2type_Constructor cons;
3749 : :
3750 : 1688 : M2ALU_PushIntegerTree (low);
3751 : 1688 : M2ALU_ConvertToInt ();
3752 : 1688 : low = M2ALU_PopIntegerTree ();
3753 : 1688 : M2ALU_PushIntegerTree (high);
3754 : 1688 : M2ALU_ConvertToInt ();
3755 : 1688 : high = M2ALU_PopIntegerTree ();
3756 : 1688 : bpw = m2decl_GetBitsPerBitset ();
3757 : 1688 : M2ALU_PushIntegerTree (high);
3758 : 1688 : M2ALU_PushIntegerTree (low);
3759 : 1688 : M2ALU_Sub ();
3760 : 1688 : M2ALU_PushCard (1);
3761 : 1688 : M2ALU_Addn ();
3762 : 1688 : BitsInSet = M2ALU_PopIntegerTree ();
3763 : 1688 : cons = m2type_BuildStartSetConstructor (SymbolConversion_Mod2Gcc (v->constructorType));
3764 : 1688 : M2ALU_PushIntegerTree (BitsInSet);
3765 : 1688 : M2ALU_PushCard (0);
3766 : 21506 : while (M2ALU_Gre (tokenno))
3767 : : {
3768 : 18130 : M2ALU_PushIntegerTree (BitsInSet);
3769 : 18130 : M2ALU_PushCard (bpw-1);
3770 : 18130 : if (M2ALU_GreEqu (tokenno))
3771 : : {
3772 : 17992 : M2ALU_PushIntegerTree (low);
3773 : 17992 : M2ALU_PushCard (bpw-1);
3774 : 17992 : M2ALU_Addn ();
3775 : 17992 : m2type_BuildSetConstructorElement (cons, BuildBitset (tokenno, v, low, M2ALU_PopIntegerTree ()));
3776 : 17992 : M2ALU_PushIntegerTree (low);
3777 : 17992 : M2ALU_PushCard (bpw);
3778 : 17992 : M2ALU_Addn ();
3779 : 17992 : low = M2ALU_PopIntegerTree ();
3780 : 17992 : M2ALU_PushIntegerTree (BitsInSet);
3781 : 17992 : M2ALU_PushCard (bpw);
3782 : 17992 : M2ALU_Sub ();
3783 : 17992 : BitsInSet = M2ALU_PopIntegerTree ();
3784 : : }
3785 : : else
3786 : : {
3787 : : /* printf2('range is %a..%a
3788 : : ', GetSymName(low), GetSymName(high)) ; */
3789 : 138 : m2type_BuildSetConstructorElement (cons, BuildBitset (tokenno, v, low, high));
3790 : 138 : M2ALU_PushCard (0);
3791 : 138 : BitsInSet = M2ALU_PopIntegerTree ();
3792 : : }
3793 : 18130 : M2ALU_PushIntegerTree (BitsInSet);
3794 : 18130 : M2ALU_PushCard (0);
3795 : : }
3796 : 1688 : return m2type_BuildEndSetConstructor (cons);
3797 : : /* static analysis guarentees a RETURN statement will be used before here. */
3798 : : __builtin_unreachable ();
3799 : : }
3800 : :
3801 : :
3802 : : /*
3803 : : ConstructLargeOrSmallSet - generates a constant representing the set value of the symbol, sym.
3804 : : We manufacture the constant by using a initialization
3805 : : structure of cardinals.
3806 : :
3807 : : { (cardinal), (cardinal) etc }
3808 : : */
3809 : :
3810 : 7896 : static tree ConstructLargeOrSmallSet (unsigned int tokenno, M2ALU_PtrToValue__opaque v, unsigned int low, unsigned int high)
3811 : : {
3812 : 7896 : SymbolTable_PushValue (high);
3813 : 7896 : M2ALU_ConvertToInt ();
3814 : 7896 : SymbolTable_PushValue (low);
3815 : 7896 : M2ALU_ConvertToInt ();
3816 : 7896 : M2ALU_Sub ();
3817 : 7896 : M2ALU_PushCard (static_cast<unsigned int> (m2decl_GetBitsPerBitset ()));
3818 : 7896 : if (M2ALU_Less (tokenno))
3819 : : {
3820 : : /* small set */
3821 : 6208 : return BuildBitset (tokenno, v, SymbolConversion_Mod2Gcc (low), SymbolConversion_Mod2Gcc (high));
3822 : : }
3823 : : else
3824 : : {
3825 : : /* large set */
3826 : 1688 : return BuildStructBitset (tokenno, v, SymbolConversion_Mod2Gcc (low), SymbolConversion_Mod2Gcc (high));
3827 : : }
3828 : : /* static analysis guarentees a RETURN statement will be used before here. */
3829 : : __builtin_unreachable ();
3830 : : }
3831 : :
3832 : :
3833 : : /*
3834 : : ConvertConstToType - returns a Tree containing an initialiser,
3835 : : init, ready to be assigned to a record or
3836 : : array constructor.
3837 : : */
3838 : :
3839 : 9624 : static tree ConvertConstToType (unsigned int tokenno, unsigned int field, unsigned int init)
3840 : : {
3841 : 9624 : tree initT;
3842 : 9624 : tree nBytes;
3843 : :
3844 : 9624 : if (((SymbolTable_IsConstString (init)) && (SymbolTable_IsArray (SymbolTable_SkipType (SymbolTable_GetType (field))))) && ((SymbolTable_SkipTypeAndSubrange (SymbolTable_GetType (SymbolTable_GetType (field)))) == M2Base_Char))
3845 : : {
3846 : 2700 : if (! (M2GenGCC_PrepareCopyString (tokenno, &nBytes, &initT, init, SymbolTable_GetType (field))))
3847 : : {
3848 : 0 : M2MetaError_MetaErrorT2 (tokenno, (const char *) "string constant {%1Ea} is too large to be assigned to the {%2d} {%2a}", 69, init, field);
3849 : : }
3850 : 2700 : return initT;
3851 : : }
3852 : : else
3853 : : {
3854 : 6924 : return m2convert_ConvertConstantAndCheck (M2LexBuf_TokenToLocation (tokenno), SymbolConversion_Mod2Gcc (SymbolTable_GetType (field)), SymbolConversion_Mod2Gcc (init));
3855 : : }
3856 : : /* static analysis guarentees a RETURN statement will be used before here. */
3857 : : __builtin_unreachable ();
3858 : : }
3859 : :
3860 : :
3861 : : /*
3862 : : ConstructRecordConstant - builds a struct initializer, as defined by, v.
3863 : : */
3864 : :
3865 : 2332 : static tree ConstructRecordConstant (unsigned int tokenno, M2ALU_PtrToValue__opaque v)
3866 : : {
3867 : 2332 : NameKey_Name n1;
3868 : 2332 : NameKey_Name n2;
3869 : 2332 : unsigned int i;
3870 : 2332 : unsigned int Field;
3871 : 2332 : unsigned int baseType;
3872 : 2332 : m2type_Constructor cons;
3873 : :
3874 : 2332 : if (v->constructorType == SymbolTable_NulSym)
3875 : : {
3876 : 0 : M2Error_InternalError ((const char *) "record type must be known in order to generate a constant", 57);
3877 : : }
3878 : : else
3879 : : {
3880 : 2332 : baseType = SymbolTable_SkipType (v->constructorType);
3881 : 2332 : if (Debugging)
3882 : : {
3883 : : n1 = SymbolTable_GetSymName (v->constructorType);
3884 : : n2 = SymbolTable_GetSymName (baseType);
3885 : : M2Printf_printf2 ((const char *) "ConstructRecordConstant of type %a and baseType %a\\n", 52, (const unsigned char *) &n1, (sizeof (n1)-1), (const unsigned char *) &n2, (sizeof (n2)-1));
3886 : : }
3887 : 2332 : cons = m2type_BuildStartRecordConstructor (SymbolConversion_Mod2Gcc (baseType));
3888 : 2332 : i = 1;
3889 : 11956 : do {
3890 : 11956 : Field = SymbolTable_GetNth (baseType, i);
3891 : 11956 : if (Field != SymbolTable_NulSym)
3892 : : {
3893 : : /* avoid gcc warning by using compound statement even if not strictly necessary. */
3894 : 9624 : if (SymbolConversion_GccKnowsAbout (SymbolTable_GetType (Field)))
3895 : : {
3896 : 9624 : m2type_BuildRecordConstructorElement (cons, ConvertConstToType (tokenno, Field, GetConstructorField (v, i)));
3897 : : }
3898 : : else
3899 : : {
3900 : 0 : M2MetaError_MetaErrorT0 (tokenno, (const char *) "trying to construct a compound literal and using a record field which does not exist", 84);
3901 : : }
3902 : : }
3903 : 11956 : i += 1;
3904 : 11956 : } while (! (Field == SymbolTable_NulSym));
3905 : 2332 : return m2type_BuildEndRecordConstructor (cons);
3906 : : }
3907 : : ReturnException ("/home/worker/buildworker/tiber-lcov/build/gcc/m2/gm2-compiler/M2ALU.def", 20, 1);
3908 : : __builtin_unreachable ();
3909 : : }
3910 : :
3911 : :
3912 : : /*
3913 : : GetConstructorField - returns a symbol containing the constructor field, i.
3914 : : */
3915 : :
3916 : 9624 : static unsigned int GetConstructorField (M2ALU_PtrToValue__opaque v, unsigned int i)
3917 : : {
3918 : 9624 : unsigned int j;
3919 : 9624 : M2ALU_listOfFields f;
3920 : :
3921 : 9624 : if (v->type != M2ALU_record)
3922 : : {
3923 : 0 : M2Error_InternalError ((const char *) "constructor type must be a record in order to push a field", 58);
3924 : : }
3925 : : else
3926 : : {
3927 : 9624 : if (v->constructorType == SymbolTable_NulSym)
3928 : : {
3929 : 0 : M2Error_InternalError ((const char *) "constructor type must be a record in order to push a field", 58);
3930 : : }
3931 : : else
3932 : : {
3933 : 9624 : j = 1;
3934 : 9624 : f = v->fieldValues;
3935 : 26052 : while ((j < i) && (f != NULL))
3936 : : {
3937 : 16428 : f = f->next;
3938 : 16428 : j += 1;
3939 : : }
3940 : 9624 : if (f == NULL)
3941 : : {
3942 : 0 : M2MetaError_MetaError1 ((const char *) "the {%1EN} element does not exist in the constant compound literal", 66, i);
3943 : 0 : return SymbolTable_NulSym;
3944 : : }
3945 : : else
3946 : : {
3947 : 9624 : return f->field;
3948 : : }
3949 : : }
3950 : : }
3951 : : ReturnException ("/home/worker/buildworker/tiber-lcov/build/gcc/m2/gm2-compiler/M2ALU.def", 20, 1);
3952 : : __builtin_unreachable ();
3953 : : }
3954 : :
3955 : :
3956 : : /*
3957 : : GetConstructorElement - returns a symbol containing the array constructor element, i.
3958 : : */
3959 : :
3960 : 305394 : static unsigned int GetConstructorElement (unsigned int tokenno, M2ALU_PtrToValue__opaque v, unsigned int i)
3961 : : {
3962 : 305394 : tree j;
3963 : 305394 : M2ALU_listOfElements e;
3964 : :
3965 : 305394 : if (v->type != M2ALU_array)
3966 : : {
3967 : 0 : M2Error_InternalError ((const char *) "constructor type must be an array", 33);
3968 : : }
3969 : : else
3970 : : {
3971 : 305394 : if (v->constructorType == SymbolTable_NulSym)
3972 : : {
3973 : 0 : M2Error_InternalError ((const char *) "constructor type must be an array", 33);
3974 : : }
3975 : : else
3976 : : {
3977 : 305394 : M2ALU_PushCard (i);
3978 : 305394 : j = M2ALU_PopIntegerTree ();
3979 : 305394 : e = v->arrayValues;
3980 : 687016 : while (e != NULL)
3981 : : {
3982 : 570292 : SymbolTable_PushValue (e->by);
3983 : 570292 : M2ALU_PushIntegerTree (j);
3984 : 570292 : if (M2ALU_GreEqu (tokenno))
3985 : : {
3986 : 188670 : return e->element;
3987 : : }
3988 : 381622 : M2ALU_PushIntegerTree (j);
3989 : 381622 : M2ALU_ConvertToInt ();
3990 : 381622 : SymbolTable_PushValue (e->by);
3991 : 381622 : M2ALU_ConvertToInt ();
3992 : 381622 : M2ALU_Sub ();
3993 : 381622 : j = M2ALU_PopIntegerTree ();
3994 : 381622 : e = e->next;
3995 : : }
3996 : 116724 : if (e == NULL)
3997 : : {
3998 : : /* avoid gcc warning by using compound statement even if not strictly necessary. */
3999 : 116724 : if ((SymbolTable_IsArray (SymbolTable_SkipType (v->constructorType))) && ((SymbolTable_GetType (SymbolTable_SkipType (v->constructorType))) == M2Base_Char))
4000 : : {
4001 : 116724 : return SymbolTable_MakeConstLit (tokenno, NameKey_MakeKey ((const char *) "0", 1), M2Base_Char);
4002 : : }
4003 : : else
4004 : : {
4005 : 0 : M2MetaError_MetaErrorT2 (tokenno, (const char *) "the {%1EN} element does not exist in the {%2ad} array declaration used by the compound literal", 94, i, v->constructorType);
4006 : : }
4007 : : }
4008 : : }
4009 : : }
4010 : 0 : return SymbolTable_NulSym;
4011 : : /* static analysis guarentees a RETURN statement will be used before here. */
4012 : : __builtin_unreachable ();
4013 : : }
4014 : :
4015 : :
4016 : : /*
4017 : : IsString - returns TRUE if sym is an ARRAY [..] OF CHAR
4018 : : */
4019 : :
4020 : 4448 : static bool IsString (unsigned int sym)
4021 : : {
4022 : 4448 : return (((SymbolTable_IsArray (sym)) && ((SymbolTable_SkipType (SymbolTable_GetType (sym))) == M2Base_Char)) || (SymbolTable_IsConstString (sym))) || ((SymbolTable_IsConst (sym)) && ((SymbolTable_SkipType (SymbolTable_GetType (sym))) == M2Base_Char));
4023 : : /* static analysis guarentees a RETURN statement will be used before here. */
4024 : : __builtin_unreachable ();
4025 : : }
4026 : :
4027 : :
4028 : : /*
4029 : : StringFitsArray -
4030 : : */
4031 : :
4032 : 456 : static bool StringFitsArray (unsigned int arrayType, unsigned int el, unsigned int tokenno)
4033 : : {
4034 : 456 : location_t location;
4035 : :
4036 : 456 : location = M2LexBuf_TokenToLocation (tokenno);
4037 : 456 : M2ALU_PushIntegerTree (m2type_BuildNumberOfArrayElements (location, SymbolConversion_Mod2Gcc (arrayType)));
4038 : 456 : if (SymbolTable_IsConstString (el))
4039 : : {
4040 : 456 : M2ALU_PushCard (SymbolTable_GetStringLength (tokenno, el));
4041 : : }
4042 : 0 : else if (((SymbolTable_IsConst (el)) && ((SymbolTable_SkipType (SymbolTable_GetType (el))) == M2Base_Char)) && (SymbolTable_IsValueSolved (el)))
4043 : : {
4044 : : /* avoid dangling else. */
4045 : 0 : M2ALU_PushCard (1);
4046 : : }
4047 : : else
4048 : : {
4049 : : /* avoid dangling else. */
4050 : 0 : M2ALU_PushCard (0);
4051 : 0 : M2MetaError_MetaError1 ((const char *) "cannot build a string using {%1Ead}", 35, el);
4052 : : }
4053 : 456 : return M2ALU_GreEqu (tokenno);
4054 : : /* static analysis guarentees a RETURN statement will be used before here. */
4055 : : __builtin_unreachable ();
4056 : : }
4057 : :
4058 : :
4059 : : /*
4060 : : GetArrayLimits -
4061 : : */
4062 : :
4063 : 1180 : static void GetArrayLimits (unsigned int array, unsigned int *low, unsigned int *high)
4064 : : {
4065 : 1180 : unsigned int Subscript;
4066 : 1180 : unsigned int Subrange;
4067 : :
4068 : 1180 : Subscript = SymbolTable_GetArraySubscript (array);
4069 : 1180 : Subrange = SymbolTable_SkipType (SymbolTable_GetType (Subscript));
4070 : 1180 : if (SymbolTable_IsEnumeration (Subrange))
4071 : : {
4072 : 32 : M2Base_GetBaseTypeMinMax (Subrange, low, high);
4073 : : }
4074 : : else
4075 : : {
4076 : 1148 : SymbolTable_GetSubrange (Subrange, high, low);
4077 : : }
4078 : 1180 : }
4079 : :
4080 : :
4081 : : /*
4082 : : InitialiseArrayOfCharWithString -
4083 : : */
4084 : :
4085 : 456 : static tree InitialiseArrayOfCharWithString (unsigned int tokenno, void * cons, unsigned int el, unsigned int baseType, unsigned int arrayType)
4086 : : {
4087 : 456 : bool isChar;
4088 : 456 : DynamicStrings_String s;
4089 : 456 : DynamicStrings_String letter;
4090 : 456 : unsigned int i;
4091 : 456 : unsigned int l;
4092 : 456 : unsigned int high;
4093 : 456 : unsigned int low;
4094 : 456 : tree value;
4095 : 456 : tree indice;
4096 : 456 : location_t location;
4097 : :
4098 : 456 : location = M2LexBuf_TokenToLocation (tokenno);
4099 : 456 : GetArrayLimits (baseType, &low, &high);
4100 : 456 : l = 0;
4101 : 456 : s = static_cast<DynamicStrings_String> (NULL);
4102 : 456 : if (SymbolTable_IsConstString (el))
4103 : : {
4104 : 456 : isChar = false;
4105 : 456 : s = DynamicStrings_InitStringCharStar (NameKey_KeyToCharStar (SymbolTable_GetString (el)));
4106 : 456 : l = SymbolTable_GetStringLength (tokenno, el);
4107 : : }
4108 : 0 : else if (((SymbolTable_IsConst (el)) && ((SymbolTable_SkipType (SymbolTable_GetType (el))) == M2Base_Char)) && (SymbolTable_IsValueSolved (el)))
4109 : : {
4110 : : /* avoid dangling else. */
4111 : : isChar = true;
4112 : : }
4113 : : else
4114 : : {
4115 : : /* avoid dangling else. */
4116 : 0 : M2MetaError_MetaError1 ((const char *) "cannot build a string using {%1Ead}", 35, el);
4117 : 0 : isChar = false;
4118 : : }
4119 : 456 : i = 0;
4120 : 1824 : do {
4121 : 1824 : SymbolTable_PushValue (low);
4122 : 1824 : M2ALU_PushCard (i);
4123 : 1824 : M2ALU_Addn ();
4124 : 1824 : indice = M2ALU_PopIntegerTree ();
4125 : 1824 : letter = static_cast<DynamicStrings_String> (NULL);
4126 : 1824 : if (isChar)
4127 : : {
4128 : 0 : isChar = false;
4129 : 0 : SymbolTable_PushValue (el);
4130 : 0 : value = M2ALU_PopIntegerTree ();
4131 : : }
4132 : 1824 : else if (i < l)
4133 : : {
4134 : : /* avoid dangling else. */
4135 : 1368 : if ((i+1) < l)
4136 : : {
4137 : 912 : letter = DynamicStrings_Slice (s, static_cast<int> (i), static_cast<int> (i+1));
4138 : : }
4139 : : else
4140 : : {
4141 : 456 : letter = DynamicStrings_Slice (s, static_cast<int> (i), 0);
4142 : : }
4143 : 1368 : value = m2type_BuildCharConstant (location, const_cast <const char * > (static_cast <char * > (DynamicStrings_string (letter))));
4144 : : }
4145 : : else
4146 : : {
4147 : : /* avoid dangling else. */
4148 : 456 : letter = DynamicStrings_InitStringChar (ASCII_nul);
4149 : 456 : value = m2type_BuildCharConstant (location, const_cast <const char * > (static_cast <char * > (DynamicStrings_string (letter))));
4150 : : }
4151 : 1824 : value = m2convert_ConvertConstantAndCheck (location, SymbolConversion_Mod2Gcc (arrayType), value);
4152 : 1824 : letter = DynamicStrings_KillString (letter);
4153 : 1824 : m2type_BuildArrayConstructorElement (cons, value, indice);
4154 : 1824 : SymbolTable_PushValue (low);
4155 : 1824 : M2ALU_PushCard (i);
4156 : 1824 : M2ALU_Addn ();
4157 : 1824 : SymbolTable_PushValue (high);
4158 : 1824 : i += 1;
4159 : 1824 : } while (! (M2ALU_GreEqu (tokenno)));
4160 : 456 : s = DynamicStrings_KillString (s);
4161 : 456 : if (! (StringFitsArray (baseType, el, tokenno)))
4162 : : {
4163 : 0 : M2MetaError_MetaError2 ((const char *) "string {%1Ea} is too large to fit into array {%2ad}", 51, el, baseType);
4164 : : }
4165 : : /*
4166 : : IF v#NIL
4167 : : THEN
4168 : : el := GetConstructorElement(tokenno, v, 2) ;
4169 : : IF el#NulSym
4170 : : THEN
4171 : : MetaError1('not allowed to have multiple strings to initialise an array of characters {%1Ua}', el)
4172 : : END
4173 : : END ;
4174 : : */
4175 : 456 : return m2type_BuildEndArrayConstructor (cons);
4176 : : /* static analysis guarentees a RETURN statement will be used before here. */
4177 : : __builtin_unreachable ();
4178 : : }
4179 : :
4180 : :
4181 : : /*
4182 : : CheckElementString -
4183 : : */
4184 : :
4185 : 3992 : static tree CheckElementString (unsigned int el, unsigned int arrayType, unsigned int tokenno)
4186 : : {
4187 : 3992 : void * cons;
4188 : :
4189 : 3992 : if ((IsString (arrayType)) && (IsString (el)))
4190 : : {
4191 : 456 : cons = m2type_BuildStartArrayConstructor (SymbolConversion_Mod2Gcc (arrayType));
4192 : 456 : return InitialiseArrayOfCharWithString (tokenno, cons, el, arrayType, SymbolTable_SkipType (SymbolTable_GetType (arrayType)));
4193 : : }
4194 : : else
4195 : : {
4196 : 3536 : return SymbolConversion_Mod2Gcc (el);
4197 : : }
4198 : : /* static analysis guarentees a RETURN statement will be used before here. */
4199 : : __builtin_unreachable ();
4200 : : }
4201 : :
4202 : :
4203 : : /*
4204 : : InitialiseArrayWith -
4205 : : */
4206 : :
4207 : 514 : static tree InitialiseArrayWith (unsigned int tokenno, void * cons, M2ALU_PtrToValue__opaque v, unsigned int el, unsigned int high, unsigned int low, unsigned int arrayType)
4208 : : {
4209 : 514 : location_t location;
4210 : 514 : unsigned int i;
4211 : 514 : tree indice;
4212 : 514 : tree value;
4213 : :
4214 : 514 : location = M2LexBuf_TokenToLocation (tokenno);
4215 : 514 : i = 0;
4216 : 4506 : while (el != SymbolTable_NulSym)
4217 : : {
4218 : 3992 : SymbolTable_PushValue (low);
4219 : 3992 : M2ALU_ConvertToInt ();
4220 : 3992 : M2ALU_PushInt (static_cast<int> (i));
4221 : 3992 : M2ALU_Addn ();
4222 : 3992 : indice = M2ALU_PopIntegerTree ();
4223 : 3992 : value = CheckElementString (el, arrayType, tokenno);
4224 : 3992 : if (value == NULL)
4225 : : {
4226 : 0 : M2MetaError_MetaErrorT0 (tokenno, (const char *) "{%W}too few characters found when trying to construct a compound literal array", 78);
4227 : 0 : value = m2expr_GetCardinalZero (location);
4228 : : }
4229 : 3992 : value = m2convert_ConvertConstantAndCheck (location, SymbolConversion_Mod2Gcc (arrayType), value);
4230 : 3992 : m2type_BuildArrayConstructorElement (cons, value, indice);
4231 : 3992 : SymbolTable_PushValue (low);
4232 : 3992 : M2ALU_ConvertToInt ();
4233 : 3992 : M2ALU_PushInt (static_cast<int> (i));
4234 : 3992 : M2ALU_Addn ();
4235 : 3992 : SymbolTable_PushValue (high);
4236 : 3992 : M2ALU_ConvertToInt ();
4237 : 3992 : if (M2ALU_GreEqu (tokenno))
4238 : : {
4239 : 514 : return m2type_BuildEndArrayConstructor (cons);
4240 : : }
4241 : 3478 : i += 1;
4242 : 3478 : el = GetConstructorElement (tokenno, v, i+1);
4243 : : }
4244 : 0 : return m2type_BuildEndArrayConstructor (cons);
4245 : : /* static analysis guarentees a RETURN statement will be used before here. */
4246 : : __builtin_unreachable ();
4247 : : }
4248 : :
4249 : :
4250 : : /*
4251 : : CheckGetCharFromString - return TRUE if a char from the position arrayIndex in the list of
4252 : : constDecl elements can be extracted. The character is returned
4253 : : in value.
4254 : : */
4255 : :
4256 : 6792 : static bool CheckGetCharFromString (location_t location, unsigned int tokenno, M2ALU_PtrToValue__opaque constDecl, unsigned int consType, unsigned int arrayIndex, tree *value)
4257 : : {
4258 : 6792 : unsigned int elementIndex;
4259 : 6792 : unsigned int element;
4260 : 6792 : unsigned int offset;
4261 : 6792 : unsigned int totalLength;
4262 : 6792 : NameKey_Name key;
4263 : :
4264 : 6792 : totalLength = 0;
4265 : 6792 : elementIndex = 1;
4266 : 300468 : do {
4267 : 300468 : element = GetConstructorElement (tokenno, constDecl, elementIndex);
4268 : 300468 : offset = totalLength;
4269 : 300468 : if (SymbolTable_IsConstString (element))
4270 : : {
4271 : : /* avoid dangling else. */
4272 : 183744 : totalLength += SymbolTable_GetStringLength (tokenno, element);
4273 : 183744 : if (totalLength > arrayIndex)
4274 : : {
4275 : 3864 : key = SymbolTable_GetString (element);
4276 : 3864 : arrayIndex -= offset;
4277 : 3864 : (*value) = m2type_BuildCharConstantChar (location, NameKey_CharKey (key, arrayIndex));
4278 : 3864 : return true;
4279 : : }
4280 : : }
4281 : 116724 : else if (((SymbolTable_IsConst (element)) && ((SymbolTable_SkipType (SymbolTable_GetType (element))) == M2Base_Char)) && (SymbolTable_IsValueSolved (element)))
4282 : : {
4283 : : /* avoid dangling else. */
4284 : 116664 : totalLength += 1;
4285 : 116664 : if (totalLength > arrayIndex)
4286 : : {
4287 : 2904 : SymbolTable_PushValue (element);
4288 : 2904 : (*value) = m2convert_ConvertConstantAndCheck (location, m2type_GetM2CharType (), M2ALU_PopIntegerTree ());
4289 : 2904 : return true;
4290 : : }
4291 : : }
4292 : : else
4293 : : {
4294 : : /* avoid dangling else. */
4295 : 60 : totalLength += 1;
4296 : 60 : if (totalLength > arrayIndex)
4297 : : {
4298 : 24 : M2MetaError_MetaErrorT3 (tokenno, (const char *) "expecting {%kCHAR} datatype and not {%1Ea} a {%1tad} in the {%2N} component of the {%3a} {%3d}", 94, element, arrayIndex, consType);
4299 : 24 : (*value) = m2expr_GetCardinalZero (location);
4300 : 24 : return false;
4301 : : }
4302 : : }
4303 : 293676 : elementIndex += 1;
4304 : 293676 : } while (! (element == SymbolTable_NulSym));
4305 : 0 : (*value) = m2expr_GetCardinalZero (location);
4306 : 0 : M2MetaError_MetaErrorT2 (tokenno, (const char *) "unable to obtain a {%kCHAR} at the {%1EN} position in {%2ad}", 60, arrayIndex, consType);
4307 : 0 : return false;
4308 : : /* static analysis guarentees a RETURN statement will be used before here. */
4309 : : __builtin_unreachable ();
4310 : : }
4311 : :
4312 : :
4313 : : /*
4314 : : InitialiseArrayOfCharWith -
4315 : : */
4316 : :
4317 : 210 : static tree InitialiseArrayOfCharWith (unsigned int tokenno, void * cons, M2ALU_PtrToValue__opaque constDecl, unsigned int el, unsigned int high, unsigned int low, unsigned int consType, unsigned int arrayType)
4318 : : {
4319 : 210 : location_t location;
4320 : 210 : unsigned int arrayIndex;
4321 : 210 : tree indice;
4322 : 210 : tree value;
4323 : :
4324 : 210 : location = M2LexBuf_TokenToLocation (tokenno); /* arrayIndex is the char position index of the final string. */
4325 : 210 : arrayIndex = 0;
4326 : 7002 : while (el != SymbolTable_NulSym)
4327 : : {
4328 : 6792 : SymbolTable_PushValue (low);
4329 : 6792 : M2ALU_ConvertToInt ();
4330 : 6792 : M2ALU_PushInt (static_cast<int> (arrayIndex));
4331 : 6792 : M2ALU_Addn ();
4332 : 6792 : indice = M2ALU_PopIntegerTree ();
4333 : 6792 : if (! (CheckGetCharFromString (location, tokenno, constDecl, consType, arrayIndex, &value)))
4334 : : {} /* empty. */
4335 : : /*
4336 : : MetaErrorT2 (tokenno,
4337 : : 'unable to obtain a {%kCHAR} at the {%1EN} position in {%2ad}',
4338 : : arrayIndex, consType) ;
4339 : : */
4340 : 6792 : value = m2convert_ConvertConstantAndCheck (location, SymbolConversion_Mod2Gcc (arrayType), value);
4341 : 6792 : m2type_BuildArrayConstructorElement (cons, value, indice);
4342 : 6792 : SymbolTable_PushValue (low);
4343 : 6792 : M2ALU_ConvertToInt ();
4344 : 6792 : M2ALU_PushInt (static_cast<int> (arrayIndex));
4345 : 6792 : M2ALU_Addn ();
4346 : 6792 : SymbolTable_PushValue (high);
4347 : 6792 : M2ALU_ConvertToInt ();
4348 : 6792 : if (M2ALU_GreEqu (tokenno))
4349 : : {
4350 : 210 : return m2type_BuildEndArrayConstructor (cons);
4351 : : }
4352 : 6582 : arrayIndex += 1;
4353 : : }
4354 : 0 : return m2type_BuildEndArrayConstructor (cons);
4355 : : /* static analysis guarentees a RETURN statement will be used before here. */
4356 : : __builtin_unreachable ();
4357 : : }
4358 : :
4359 : :
4360 : : /*
4361 : : ConstructArrayConstant - builds a struct initializer, as defined by, v.
4362 : : */
4363 : :
4364 : 724 : static tree ConstructArrayConstant (unsigned int tokenno, M2ALU_PtrToValue__opaque v)
4365 : : {
4366 : 724 : NameKey_Name n1;
4367 : 724 : NameKey_Name n2;
4368 : 724 : unsigned int el1;
4369 : 724 : unsigned int el2;
4370 : 724 : unsigned int baseType;
4371 : 724 : unsigned int arrayType;
4372 : 724 : unsigned int high;
4373 : 724 : unsigned int low;
4374 : 724 : void * cons;
4375 : :
4376 : 724 : if (v->constructorType == SymbolTable_NulSym)
4377 : : {
4378 : 0 : M2Error_InternalError ((const char *) "array type must be known in order to generate a constant", 56);
4379 : : }
4380 : : else
4381 : : {
4382 : 724 : baseType = SymbolTable_SkipType (v->constructorType);
4383 : 724 : if (Debugging)
4384 : : {
4385 : : n1 = SymbolTable_GetSymName (v->constructorType);
4386 : : n2 = SymbolTable_GetSymName (baseType);
4387 : : M2Printf_printf2 ((const char *) "ConstructArrayConstant of type %a and baseType %a\\n", 51, (const unsigned char *) &n1, (sizeof (n1)-1), (const unsigned char *) &n2, (sizeof (n2)-1));
4388 : : }
4389 : 724 : cons = m2type_BuildStartArrayConstructor (SymbolConversion_Mod2Gcc (baseType));
4390 : 724 : GetArrayLimits (baseType, &low, &high);
4391 : 724 : arrayType = SymbolTable_GetType (baseType);
4392 : 724 : el1 = GetConstructorElement (tokenno, v, 1);
4393 : 724 : el2 = GetConstructorElement (tokenno, v, 2);
4394 : 724 : if (((el2 == SymbolTable_NulSym) && (IsString (baseType))) && (IsString (el1)))
4395 : : {
4396 : : /* constructorType is ARRAY [low..high] OF CHAR and using a string to initialise it */
4397 : 0 : return InitialiseArrayOfCharWithString (tokenno, cons, el1, baseType, arrayType);
4398 : : }
4399 : 724 : else if ((SymbolTable_SkipType (arrayType)) == M2Base_Char)
4400 : : {
4401 : : /* avoid dangling else. */
4402 : 210 : return InitialiseArrayOfCharWith (tokenno, cons, v, el1, high, low, baseType, arrayType);
4403 : : }
4404 : : else
4405 : : {
4406 : : /* avoid dangling else. */
4407 : 514 : return InitialiseArrayWith (tokenno, cons, v, el1, high, low, arrayType);
4408 : : }
4409 : : }
4410 : : ReturnException ("/home/worker/buildworker/tiber-lcov/build/gcc/m2/gm2-compiler/M2ALU.def", 20, 1);
4411 : : __builtin_unreachable ();
4412 : : }
4413 : :
4414 : :
4415 : : /*
4416 : : BuildBitset - given a set, v, construct the bitmask for its
4417 : : constant value which lie in the range low..high.
4418 : : */
4419 : :
4420 : 24338 : static tree BuildBitset (unsigned int tokenno, M2ALU_PtrToValue__opaque v, tree low, tree high)
4421 : : {
4422 : 24338 : tree tl;
4423 : 24338 : tree th;
4424 : 24338 : tree t;
4425 : 24338 : unsigned int n;
4426 : 24338 : unsigned int r1;
4427 : 24338 : unsigned int r2;
4428 : 24338 : location_t location;
4429 : :
4430 : 24338 : location = M2LexBuf_TokenToLocation (tokenno);
4431 : 24338 : low = m2convert_ToInteger (location, low);
4432 : 24338 : high = m2convert_ToInteger (location, high);
4433 : 24338 : n = 1;
4434 : 24338 : t = m2expr_GetCardinalZero (location);
4435 : 86898 : while (M2ALU_GetRange (static_cast<M2ALU_PtrToValue> (v), n, &r1, &r2))
4436 : : {
4437 : 38222 : SymbolTable_PushValue (r1);
4438 : 38222 : tl = m2convert_ToInteger (location, M2ALU_PopIntegerTree ());
4439 : 38222 : SymbolTable_PushValue (r2);
4440 : 38222 : th = m2convert_ToInteger (location, M2ALU_PopIntegerTree ());
4441 : 38222 : if (IsIntersectionTree (tokenno, tl, th, low, high))
4442 : : {
4443 : 9066 : tl = m2convert_ToCardinal (location, SubTree (MaxTree (tokenno, tl, low), low));
4444 : 9066 : th = m2convert_ToCardinal (location, SubTree (MinTree (tokenno, th, high), low));
4445 : 9066 : t = m2expr_BuildLogicalOr (location, t, M2ALU_BuildRange (tokenno, tl, th), false);
4446 : : }
4447 : 38222 : n += 1;
4448 : : }
4449 : 24338 : return m2convert_ToBitset (location, t);
4450 : : /* static analysis guarentees a RETURN statement will be used before here. */
4451 : : __builtin_unreachable ();
4452 : : }
4453 : :
4454 : :
4455 : : /*
4456 : : CheckOverflow - tests to see whether the tree, t, has caused
4457 : : an overflow error and if so it generates an
4458 : : error message.
4459 : : */
4460 : :
4461 : 318873 : static void CheckOverflow (unsigned int tokenno, tree t)
4462 : : {
4463 : 318873 : if (m2expr_TreeOverflow (t))
4464 : : {
4465 : 12 : M2MetaError_MetaErrorT0 (tokenno, (const char *) "constant overflow error", 23);
4466 : 12 : M2Error_FlushErrors ();
4467 : : }
4468 : 318861 : }
4469 : :
4470 : :
4471 : : /*
4472 : : PushGCCArrayTree - pushes a gcc tree value onto the ALU stack.
4473 : : */
4474 : :
4475 : 0 : static void PushGCCArrayTree (tree gcc, unsigned int t)
4476 : : {
4477 : 0 : M2ALU_PtrToValue__opaque v;
4478 : :
4479 : 0 : v = New ();
4480 : 0 : v->constructorType = t;
4481 : 0 : v->type = M2ALU_array;
4482 : 0 : v->numberValue = gcc;
4483 : 0 : v->arrayValues = NULL;
4484 : 0 : v->areAllConstants = true;
4485 : 0 : v->solved = true;
4486 : 0 : Push (v);
4487 : 0 : }
4488 : :
4489 : :
4490 : : /*
4491 : : PushGCCSetTree - pushes a gcc tree value onto the ALU stack.
4492 : : */
4493 : :
4494 : 18 : static void PushGCCSetTree (tree gcc, unsigned int t)
4495 : : {
4496 : 18 : M2ALU_PtrToValue__opaque v;
4497 : :
4498 : 18 : v = New ();
4499 : 18 : v->constructorType = t;
4500 : 18 : v->type = M2ALU_set;
4501 : 18 : v->numberValue = gcc;
4502 : 18 : v->setValue = NULL;
4503 : 18 : v->areAllConstants = true;
4504 : 18 : v->solved = true;
4505 : 18 : Push (v);
4506 : 18 : }
4507 : :
4508 : :
4509 : : /*
4510 : : PushGCCRecordTree - pushes a gcc tree value onto the ALU stack.
4511 : : */
4512 : :
4513 : 0 : static void PushGCCRecordTree (tree gcc, unsigned int t)
4514 : : {
4515 : 0 : M2ALU_PtrToValue__opaque v;
4516 : :
4517 : 0 : v = New ();
4518 : 0 : v->constructorType = t;
4519 : 0 : v->type = M2ALU_record;
4520 : 0 : v->numberValue = gcc;
4521 : 0 : v->fieldValues = NULL;
4522 : 0 : v->areAllConstants = true;
4523 : 0 : v->solved = true;
4524 : 0 : Push (v);
4525 : 0 : }
4526 : :
4527 : :
4528 : : /*
4529 : : Init - initialises the stack and the free list.
4530 : : */
4531 : :
4532 : 14232 : static void Init (void)
4533 : : {
4534 : 14232 : FreeList = static_cast<M2ALU_PtrToValue__opaque> (NULL);
4535 : 14232 : TopOfStack = static_cast<M2ALU_PtrToValue__opaque> (NULL);
4536 : 14232 : RangeFreeList = NULL;
4537 : 14232 : FieldFreeList = NULL;
4538 : 14232 : ElementFreeList = NULL;
4539 : 0 : }
4540 : :
4541 : :
4542 : : /*
4543 : : InitValue - initializes and returns a memory cell.
4544 : : */
4545 : :
4546 : 39134900 : extern "C" M2ALU_PtrToValue M2ALU_InitValue (void)
4547 : : {
4548 : 39134900 : M2ALU_PtrToValue__opaque v;
4549 : :
4550 : 39134900 : v = New ();
4551 : 39134900 : if (v == NULL)
4552 : : {
4553 : : M2Error_InternalError ((const char *) "out of memory error", 19);
4554 : : }
4555 : : else
4556 : : {
4557 : 39134900 : v->location = m2linemap_UnknownLocation ();
4558 : 39134900 : v->type = M2ALU_none;
4559 : 39134900 : v->areAllConstants = true;
4560 : 39134900 : v->solved = false;
4561 : 39134900 : v->next = static_cast<M2ALU_PtrToValue__opaque> (NULL);
4562 : 39134900 : v->constructorType = SymbolTable_NulSym;
4563 : 39134900 : return static_cast<M2ALU_PtrToValue> (v);
4564 : : }
4565 : : ReturnException ("/home/worker/buildworker/tiber-lcov/build/gcc/m2/gm2-compiler/M2ALU.def", 20, 1);
4566 : : __builtin_unreachable ();
4567 : : }
4568 : :
4569 : :
4570 : : /*
4571 : : IsValueTypeNone - returns TRUE if the value on the top stack has no value.
4572 : : */
4573 : :
4574 : 785970 : extern "C" bool M2ALU_IsValueTypeNone (void)
4575 : : {
4576 : 785970 : M2ALU_PtrToValue__opaque v;
4577 : :
4578 : 785970 : v = Pop ();
4579 : 785970 : if (v->type == M2ALU_none)
4580 : : {
4581 : 32684 : Push (v);
4582 : 32684 : return true;
4583 : : }
4584 : : else
4585 : : {
4586 : 753286 : Push (v);
4587 : 753286 : return false;
4588 : : }
4589 : : /* static analysis guarentees a RETURN statement will be used before here. */
4590 : : __builtin_unreachable ();
4591 : : }
4592 : :
4593 : :
4594 : : /*
4595 : : IsValueTypeInteger - returns TRUE if the value on the top stack is an integer.
4596 : : */
4597 : :
4598 : 0 : extern "C" bool M2ALU_IsValueTypeInteger (void)
4599 : : {
4600 : 0 : M2ALU_PtrToValue__opaque v;
4601 : :
4602 : 0 : v = Pop ();
4603 : 0 : if (v->type == M2ALU_integer)
4604 : : {
4605 : 0 : Push (v);
4606 : 0 : return true;
4607 : : }
4608 : : else
4609 : : {
4610 : 0 : Push (v);
4611 : 0 : return false;
4612 : : }
4613 : : /* static analysis guarentees a RETURN statement will be used before here. */
4614 : : __builtin_unreachable ();
4615 : : }
4616 : :
4617 : :
4618 : : /*
4619 : : IsValueTypeReal - returns TRUE if the value on the top stack is a real.
4620 : : */
4621 : :
4622 : 235021 : extern "C" bool M2ALU_IsValueTypeReal (void)
4623 : : {
4624 : 235021 : M2ALU_PtrToValue__opaque v;
4625 : :
4626 : 235021 : v = Pop ();
4627 : 235021 : if (v->type == M2ALU_real)
4628 : : {
4629 : 492 : Push (v);
4630 : 492 : return true;
4631 : : }
4632 : : else
4633 : : {
4634 : 234529 : Push (v);
4635 : 234529 : return false;
4636 : : }
4637 : : /* static analysis guarentees a RETURN statement will be used before here. */
4638 : : __builtin_unreachable ();
4639 : : }
4640 : :
4641 : :
4642 : : /*
4643 : : IsValueTypeComplex - returns TRUE if the value on the top stack is a complex.
4644 : : */
4645 : :
4646 : 230573 : extern "C" bool M2ALU_IsValueTypeComplex (void)
4647 : : {
4648 : 230573 : M2ALU_PtrToValue__opaque v;
4649 : :
4650 : 230573 : v = Pop ();
4651 : 230573 : if (v->type == M2ALU_complex)
4652 : : {
4653 : 330 : Push (v);
4654 : 330 : return true;
4655 : : }
4656 : : else
4657 : : {
4658 : 230243 : Push (v);
4659 : 230243 : return false;
4660 : : }
4661 : : /* static analysis guarentees a RETURN statement will be used before here. */
4662 : : __builtin_unreachable ();
4663 : : }
4664 : :
4665 : :
4666 : : /*
4667 : : IsValueTypeSet - returns TRUE if the value on the top stack is a set.
4668 : : */
4669 : :
4670 : 263949 : extern "C" bool M2ALU_IsValueTypeSet (void)
4671 : : {
4672 : 263949 : M2ALU_PtrToValue__opaque v;
4673 : :
4674 : 263949 : v = Pop ();
4675 : 263949 : if (v->type == M2ALU_set)
4676 : : {
4677 : 9132 : Push (v);
4678 : 9132 : return true;
4679 : : }
4680 : : else
4681 : : {
4682 : 254817 : Push (v);
4683 : 254817 : return false;
4684 : : }
4685 : : /* static analysis guarentees a RETURN statement will be used before here. */
4686 : : __builtin_unreachable ();
4687 : : }
4688 : :
4689 : :
4690 : : /*
4691 : : IsValueTypeConstructor - returns TRUE if the value on the top
4692 : : stack is a constructor.
4693 : : */
4694 : :
4695 : 260367 : extern "C" bool M2ALU_IsValueTypeConstructor (void)
4696 : : {
4697 : 260367 : M2ALU_PtrToValue__opaque v;
4698 : :
4699 : 260367 : v = Pop ();
4700 : 260367 : if (v->type == M2ALU_constructor)
4701 : : {
4702 : 0 : Push (v);
4703 : 0 : return true;
4704 : : }
4705 : : else
4706 : : {
4707 : 260367 : Push (v);
4708 : 260367 : return false;
4709 : : }
4710 : : /* static analysis guarentees a RETURN statement will be used before here. */
4711 : : __builtin_unreachable ();
4712 : : }
4713 : :
4714 : :
4715 : : /*
4716 : : IsValueTypeArray - returns TRUE if the value on the top stack is
4717 : : an array.
4718 : : */
4719 : :
4720 : 254817 : extern "C" bool M2ALU_IsValueTypeArray (void)
4721 : : {
4722 : 254817 : M2ALU_PtrToValue__opaque v;
4723 : :
4724 : 254817 : v = Pop ();
4725 : 254817 : if (v->type == M2ALU_array)
4726 : : {
4727 : 718 : Push (v);
4728 : 718 : return true;
4729 : : }
4730 : : else
4731 : : {
4732 : 254099 : Push (v);
4733 : 254099 : return false;
4734 : : }
4735 : : /* static analysis guarentees a RETURN statement will be used before here. */
4736 : : __builtin_unreachable ();
4737 : : }
4738 : :
4739 : :
4740 : : /*
4741 : : IsValueTypeRecord - returns TRUE if the value on the top stack is
4742 : : a record.
4743 : : */
4744 : :
4745 : 254099 : extern "C" bool M2ALU_IsValueTypeRecord (void)
4746 : : {
4747 : 254099 : M2ALU_PtrToValue__opaque v;
4748 : :
4749 : 254099 : v = Pop ();
4750 : 254099 : if (v->type == M2ALU_record)
4751 : : {
4752 : 2236 : Push (v);
4753 : 2236 : return true;
4754 : : }
4755 : : else
4756 : : {
4757 : 251863 : Push (v);
4758 : 251863 : return false;
4759 : : }
4760 : : /* static analysis guarentees a RETURN statement will be used before here. */
4761 : : __builtin_unreachable ();
4762 : : }
4763 : :
4764 : :
4765 : : /*
4766 : : GetSetValueType - returns the set type on top of the ALU stack.
4767 : : */
4768 : :
4769 : 0 : extern "C" unsigned int M2ALU_GetSetValueType (void)
4770 : : {
4771 : 0 : M2ALU_PtrToValue__opaque v;
4772 : :
4773 : 0 : v = Pop ();
4774 : 0 : Push (v);
4775 : 0 : if (v->type == M2ALU_set)
4776 : : {
4777 : 0 : return v->constructorType;
4778 : : }
4779 : : else
4780 : : {
4781 : 0 : M2Error_InternalError ((const char *) "expecting set type", 18);
4782 : : }
4783 : : ReturnException ("/home/worker/buildworker/tiber-lcov/build/gcc/m2/gm2-compiler/M2ALU.def", 20, 1);
4784 : : __builtin_unreachable ();
4785 : : }
4786 : :
4787 : :
4788 : : /*
4789 : : PushIntegerTree - pushes a gcc tree value onto the ALU stack.
4790 : : */
4791 : :
4792 : 7357112 : extern "C" void M2ALU_PushIntegerTree (tree t)
4793 : : {
4794 : 7357112 : M2ALU_PtrToValue__opaque v;
4795 : :
4796 : 7357112 : v = static_cast<M2ALU_PtrToValue__opaque> (M2ALU_InitValue ());
4797 : 7357112 : v->type = M2ALU_integer;
4798 : 7357112 : v->numberValue = t;
4799 : 7357112 : v->areAllConstants = true;
4800 : 7357112 : v->solved = true;
4801 : 7357112 : Push (v);
4802 : 7357112 : }
4803 : :
4804 : :
4805 : : /*
4806 : : PopIntegerTree - pops a gcc tree value from the ALU stack.
4807 : : */
4808 : :
4809 : 2330805 : extern "C" tree M2ALU_PopIntegerTree (void)
4810 : : {
4811 : 2330805 : M2ALU_PtrToValue__opaque v;
4812 : 2330805 : tree t;
4813 : :
4814 : 2330805 : v = Pop ();
4815 : 2330805 : if (v->type == M2ALU_integer)
4816 : : {
4817 : 2330805 : t = v->numberValue;
4818 : : }
4819 : : else
4820 : : {
4821 : 0 : M2Error_InternalError ((const char *) "expecting type of constant to be a whole number", 47);
4822 : : }
4823 : 2330805 : Dispose (v);
4824 : 2330805 : return t;
4825 : : /* static analysis guarentees a RETURN statement will be used before here. */
4826 : : __builtin_unreachable ();
4827 : : }
4828 : :
4829 : :
4830 : : /*
4831 : : PushRealTree - pushes a gcc tree value onto the ALU stack.
4832 : : */
4833 : :
4834 : 93058 : extern "C" void M2ALU_PushRealTree (tree t)
4835 : : {
4836 : 93058 : M2ALU_PtrToValue__opaque v;
4837 : :
4838 : 93058 : v = New ();
4839 : 93058 : v->type = M2ALU_real;
4840 : 93058 : v->numberValue = t;
4841 : 93058 : v->areAllConstants = true;
4842 : 93058 : v->solved = true;
4843 : 93058 : Push (v);
4844 : 93058 : }
4845 : :
4846 : :
4847 : : /*
4848 : : PopRealTree - pops a gcc tree value from the ALU stack.
4849 : : */
4850 : :
4851 : 7408 : extern "C" tree M2ALU_PopRealTree (void)
4852 : : {
4853 : 7408 : M2ALU_PtrToValue__opaque v;
4854 : 7408 : tree t;
4855 : :
4856 : 7408 : v = Pop ();
4857 : 7408 : if (v->type == M2ALU_real)
4858 : : {
4859 : 7408 : t = v->numberValue;
4860 : : }
4861 : : else
4862 : : {
4863 : 0 : M2Error_InternalError ((const char *) "expecting type of constant to be a real number", 46);
4864 : : }
4865 : 7408 : Dispose (v);
4866 : 7408 : return t;
4867 : : /* static analysis guarentees a RETURN statement will be used before here. */
4868 : : __builtin_unreachable ();
4869 : : }
4870 : :
4871 : :
4872 : : /*
4873 : : PushComplexTree - pushes a gcc tree value onto the ALU stack.
4874 : : */
4875 : :
4876 : 708 : extern "C" void M2ALU_PushComplexTree (tree t)
4877 : : {
4878 : 708 : M2ALU_PtrToValue__opaque v;
4879 : :
4880 : 708 : v = New ();
4881 : 708 : v->type = M2ALU_complex;
4882 : 708 : v->numberValue = t;
4883 : 708 : v->areAllConstants = true;
4884 : 708 : v->solved = true;
4885 : 708 : Push (v);
4886 : 708 : }
4887 : :
4888 : :
4889 : : /*
4890 : : PopComplexTree - pops a gcc tree value from the ALU stack.
4891 : : */
4892 : :
4893 : 660 : extern "C" tree M2ALU_PopComplexTree (void)
4894 : : {
4895 : 660 : M2ALU_PtrToValue__opaque v;
4896 : 660 : tree t;
4897 : :
4898 : 660 : v = Pop ();
4899 : 660 : if (v->type == M2ALU_complex)
4900 : : {
4901 : 660 : t = v->numberValue;
4902 : : }
4903 : : else
4904 : : {
4905 : 0 : M2Error_InternalError ((const char *) "expecting type of constant to be a complex number", 49);
4906 : : }
4907 : 660 : Dispose (v);
4908 : 660 : return t;
4909 : : /* static analysis guarentees a RETURN statement will be used before here. */
4910 : : __builtin_unreachable ();
4911 : : }
4912 : :
4913 : :
4914 : : /*
4915 : : PushSetTree - pushes a gcc tree onto the ALU stack.
4916 : : The tree, t, is expected to contain a
4917 : : word value. It is converted into a set
4918 : : type (sym). Bit 0 maps onto MIN(sym).
4919 : : */
4920 : :
4921 : 0 : extern "C" void M2ALU_PushSetTree (unsigned int tokenno, tree t, unsigned int sym)
4922 : : {
4923 : 0 : M2ALU_PtrToValue__opaque v;
4924 : 0 : int c;
4925 : 0 : int i;
4926 : 0 : M2ALU_listOfRange r;
4927 : 0 : location_t l;
4928 : :
4929 : 0 : l = M2LexBuf_TokenToLocation (tokenno);
4930 : 0 : r = NULL;
4931 : 0 : i = 0;
4932 : 0 : while ((i < (m2decl_GetBitsPerBitset ())) && ((m2expr_CompareTrees (m2expr_GetIntegerZero (l), t)) != 0))
4933 : : {
4934 : 0 : if ((m2expr_CompareTrees (m2expr_GetIntegerOne (l), m2expr_BuildLogicalAnd (l, t, m2expr_GetIntegerOne (l), false))) == 0)
4935 : : {
4936 : 0 : M2ALU_PushCard (static_cast<unsigned int> (i));
4937 : 0 : c = Val (tokenno, SymbolTable_SkipType (sym), M2ALU_PopIntegerTree ());
4938 : 0 : M2GCCDeclare_DeclareConstant (tokenno, static_cast<unsigned int> (c));
4939 : 0 : r = AddRange (r, static_cast<unsigned int> (c), static_cast<unsigned int> (c));
4940 : : }
4941 : 0 : t = m2expr_BuildLSR (l, t, m2expr_GetIntegerOne (l), false);
4942 : 0 : i += 1;
4943 : : }
4944 : 0 : SortElements (tokenno, r);
4945 : 0 : CombineElements (tokenno, r);
4946 : 0 : v = New ();
4947 : 0 : v->location = l;
4948 : 0 : v->type = M2ALU_set;
4949 : 0 : v->constructorType = sym;
4950 : 0 : v->areAllConstants = false;
4951 : 0 : v->solved = false;
4952 : 0 : v->setValue = r;
4953 : 0 : Eval (tokenno, v);
4954 : 0 : Push (v);
4955 : 0 : }
4956 : :
4957 : :
4958 : : /*
4959 : : PopSetTree - pops a gcc tree from the ALU stack.
4960 : : */
4961 : :
4962 : 5934 : extern "C" tree M2ALU_PopSetTree (unsigned int tokenno)
4963 : : {
4964 : 5934 : M2ALU_PtrToValue__opaque v;
4965 : 5934 : tree t;
4966 : :
4967 : 5934 : v = Pop ();
4968 : 5934 : if (v->type == M2ALU_set)
4969 : : {
4970 : 5934 : Eval (tokenno, v);
4971 : 5934 : if (! v->solved)
4972 : : {
4973 : 0 : M2Error_InternalError ((const char *) "the set has not been resolved", 29);
4974 : : }
4975 : 5934 : if (! v->areAllConstants)
4976 : : {
4977 : 0 : M2Error_InternalError ((const char *) "the set must only contain constants", 35);
4978 : : }
4979 : 5934 : t = M2ALU_ConstructSetConstant (tokenno, static_cast<M2ALU_PtrToValue> (v));
4980 : : }
4981 : : else
4982 : : {
4983 : 0 : M2Error_InternalError ((const char *) "expecting type of constant to be a set", 38);
4984 : : }
4985 : 5934 : Dispose (v);
4986 : 5934 : return t;
4987 : : /* static analysis guarentees a RETURN statement will be used before here. */
4988 : : __builtin_unreachable ();
4989 : : }
4990 : :
4991 : :
4992 : : /*
4993 : : PopConstructorTree - returns a tree containing the compound literal.
4994 : : */
4995 : :
4996 : 5018 : extern "C" tree M2ALU_PopConstructorTree (unsigned int tokenno)
4997 : : {
4998 : 5018 : M2ALU_PtrToValue__opaque v;
4999 : 5018 : tree t;
5000 : :
5001 : 5018 : v = Pop ();
5002 : 5018 : Eval (tokenno, v);
5003 : 5018 : if (! v->solved)
5004 : : {
5005 : 0 : M2Error_InternalError ((const char *) "the constructor has not been resolved", 37);
5006 : : }
5007 : 5018 : switch (v->type)
5008 : : {
5009 : 0 : case M2ALU_constructor:
5010 : 0 : M2Error_InternalError ((const char *) "expecting constructor to be resolved into specific type", 55);
5011 : 724 : break;
5012 : :
5013 : 724 : case M2ALU_array:
5014 : 724 : t = ConstructArrayConstant (tokenno, v);
5015 : 724 : break;
5016 : :
5017 : 2332 : case M2ALU_record:
5018 : 2332 : t = ConstructRecordConstant (tokenno, v);
5019 : 2332 : break;
5020 : :
5021 : 1962 : case M2ALU_set:
5022 : 1962 : t = M2ALU_ConstructSetConstant (tokenno, static_cast<M2ALU_PtrToValue> (v));
5023 : 1962 : break;
5024 : :
5025 : :
5026 : 0 : default:
5027 : 0 : M2Error_InternalError ((const char *) "expecting type to be a constructor", 34);
5028 : 5018 : break;
5029 : : }
5030 : 5018 : Dispose (v);
5031 : 5018 : return t;
5032 : : /* static analysis guarentees a RETURN statement will be used before here. */
5033 : : __builtin_unreachable ();
5034 : : }
5035 : :
5036 : :
5037 : : /*
5038 : : PushFrom - pushes a copy of the contents of, v, onto stack.
5039 : : */
5040 : :
5041 : 13967535 : extern "C" void M2ALU_PushFrom (M2ALU_PtrToValue v)
5042 : : {
5043 : 13967535 : M2ALU_PtrToValue__opaque t;
5044 : :
5045 : 13967535 : CheckNotAlreadyOnFreeList (static_cast<M2ALU_PtrToValue__opaque> (v));
5046 : 13967535 : t = New (); /* as it is a copy */
5047 : 13967535 : (*t) = (*static_cast<M2ALU_PtrToValue__opaque> (v)); /* as it is a copy */
5048 : 13967535 : switch (static_cast<M2ALU_PtrToValue__opaque> (v)->type)
5049 : : {
5050 : 298660 : case M2ALU_set:
5051 : 298660 : t->setValue = DupRange (static_cast<M2ALU_PtrToValue__opaque> (v)->setValue);
5052 : 298660 : break;
5053 : :
5054 : 457900 : case M2ALU_constructor:
5055 : 457900 : case M2ALU_record:
5056 : 457900 : t->fieldValues = DupFields (static_cast<M2ALU_PtrToValue__opaque> (v)->fieldValues);
5057 : 457900 : break;
5058 : :
5059 : 97460 : case M2ALU_array:
5060 : 97460 : t->arrayValues = DupElements (static_cast<M2ALU_PtrToValue__opaque> (v)->arrayValues);
5061 : 97460 : break;
5062 : :
5063 : :
5064 : : default:
5065 : : break;
5066 : : }
5067 : 13967535 : Push (t);
5068 : 13967535 : }
5069 : :
5070 : :
5071 : : /*
5072 : : PopInto - pops the top element from the stack and places it into, v.
5073 : : */
5074 : :
5075 : 2719132 : extern "C" void M2ALU_PopInto (M2ALU_PtrToValue v)
5076 : : {
5077 : 2719132 : M2ALU_PtrToValue__opaque t;
5078 : :
5079 : 2719132 : t = Pop ();
5080 : 2719132 : (*static_cast<M2ALU_PtrToValue__opaque> (v)) = (*t);
5081 : 2719132 : switch (static_cast<M2ALU_PtrToValue__opaque> (v)->type)
5082 : : {
5083 : 56856 : case M2ALU_set:
5084 : 56856 : t->setValue = NULL;
5085 : 56856 : break;
5086 : :
5087 : 32792 : case M2ALU_record:
5088 : 32792 : case M2ALU_constructor:
5089 : 32792 : t->fieldValues = NULL;
5090 : 32792 : break;
5091 : :
5092 : 7382 : case M2ALU_array:
5093 : 7382 : t->arrayValues = NULL;
5094 : 7382 : break;
5095 : :
5096 : 2622102 : case M2ALU_none:
5097 : 2622102 : case M2ALU_integer:
5098 : 2622102 : case M2ALU_real:
5099 : 2622102 : case M2ALU_complex:
5100 : 2622102 : static_cast<M2ALU_PtrToValue__opaque> (v)->numberValue = m2block_RememberConstant (m2expr_FoldAndStrip (t->numberValue));
5101 : 2622102 : break;
5102 : :
5103 : :
5104 : 0 : default:
5105 : 0 : M2Error_InternalError ((const char *) "not expecting this value", 24);
5106 : 2719132 : break;
5107 : : }
5108 : 2719132 : Dispose (t);
5109 : 2719132 : }
5110 : :
5111 : :
5112 : : /*
5113 : : PushCard - pushes a cardinal onto the stack.
5114 : : */
5115 : :
5116 : 1010084 : extern "C" void M2ALU_PushCard (unsigned int c)
5117 : : {
5118 : 1010084 : M2ALU_PtrToValue__opaque v;
5119 : :
5120 : 1010084 : v = New ();
5121 : 1010084 : v->type = M2ALU_integer;
5122 : 1010084 : v->numberValue = m2decl_BuildIntegerConstant ((int ) (c));
5123 : 1010084 : v->areAllConstants = true;
5124 : 1010084 : v->solved = true;
5125 : 1010084 : Push (v);
5126 : 1010084 : }
5127 : :
5128 : :
5129 : : /*
5130 : : PushInt - pushes an integer onto the stack.
5131 : : */
5132 : :
5133 : 24340 : extern "C" void M2ALU_PushInt (int i)
5134 : : {
5135 : 24340 : M2ALU_PtrToValue__opaque v;
5136 : :
5137 : 24340 : v = New ();
5138 : 24340 : v->type = M2ALU_integer;
5139 : 24340 : v->numberValue = m2decl_BuildIntegerConstant (i);
5140 : 24340 : v->areAllConstants = true;
5141 : 24340 : v->solved = true;
5142 : 24340 : Push (v);
5143 : 24340 : }
5144 : :
5145 : :
5146 : : /*
5147 : : PushChar - pushes a char onto the stack.
5148 : : */
5149 : :
5150 : 11984 : extern "C" void M2ALU_PushChar (char c)
5151 : : {
5152 : 11984 : M2ALU_PtrToValue__opaque v;
5153 : :
5154 : 11984 : v = New ();
5155 : 11984 : v->type = M2ALU_integer;
5156 : 11984 : v->numberValue = m2decl_BuildIntegerConstant (static_cast<int> ( ((unsigned int) (c))));
5157 : 11984 : v->areAllConstants = true;
5158 : 11984 : v->solved = true;
5159 : 11984 : Push (v);
5160 : 11984 : }
5161 : :
5162 : :
5163 : : /*
5164 : : PopChar - pops a char from the stack.
5165 : : */
5166 : :
5167 : 1552 : extern "C" char M2ALU_PopChar (unsigned int tokenno)
5168 : : {
5169 : 1552 : M2ALU_PtrToValue__opaque v;
5170 : 1552 : char ch;
5171 : :
5172 : 1552 : v = Pop ();
5173 : 1552 : ch = (char) 0;
5174 : 1552 : if (v->type == M2ALU_integer)
5175 : : {
5176 : 1552 : ch = (char ) (m2expr_GetCstInteger (v->numberValue));
5177 : : }
5178 : : else
5179 : : {
5180 : 0 : M2MetaError_MetaErrorT0 (tokenno, (const char *) "{%E}cannot convert constant to a CHAR", 37);
5181 : : }
5182 : 1552 : Push (v);
5183 : 1552 : return ch;
5184 : : /* static analysis guarentees a RETURN statement will be used before here. */
5185 : : __builtin_unreachable ();
5186 : : }
5187 : :
5188 : :
5189 : : /*
5190 : : PushString - pushes the numerical value of the string onto the stack.
5191 : : */
5192 : :
5193 : 515008 : extern "C" void M2ALU_PushString (unsigned int tokenno, NameKey_Name s, bool issueError)
5194 : : {
5195 : 515008 : char ch;
5196 : 515008 : DynamicStrings_String a;
5197 : 515008 : DynamicStrings_String b;
5198 : 515008 : unsigned int length;
5199 : 515008 : location_t location;
5200 : :
5201 : 515008 : a = DynamicStrings_InitStringCharStar (NameKey_KeyToCharStar (s));
5202 : 515008 : b = static_cast<DynamicStrings_String> (NULL);
5203 : 515008 : length = DynamicStrings_Length (a);
5204 : 515008 : if (length > 0)
5205 : : {
5206 : 515008 : length -= 1;
5207 : 515008 : ch = DynamicStrings_char (a, static_cast<int> (length));
5208 : 515008 : location = M2LexBuf_TokenToLocation (tokenno);
5209 : 515008 : switch (ch)
5210 : : {
5211 : 690 : case 'H':
5212 : 690 : b = DynamicStrings_Slice (a, 0, -1); /* hexadecimal */
5213 : 690 : M2ALU_PushIntegerTree (m2decl_BuildConstLiteralNumber (location, const_cast <const char * > (static_cast <char * > (DynamicStrings_string (b))), 16, issueError));
5214 : 690 : break;
5215 : :
5216 : 24 : case 'A':
5217 : 24 : b = DynamicStrings_Slice (a, 0, -1); /* binary */
5218 : 24 : M2ALU_PushIntegerTree (m2decl_BuildConstLiteralNumber (location, const_cast <const char * > (static_cast <char * > (DynamicStrings_string (b))), 2, issueError));
5219 : 24 : break;
5220 : :
5221 : 115928 : case 'C':
5222 : 115928 : case 'B':
5223 : 115928 : b = DynamicStrings_Slice (a, 0, -1); /* octal */
5224 : 115928 : M2ALU_PushIntegerTree (m2decl_BuildConstLiteralNumber (location, const_cast <const char * > (static_cast <char * > (DynamicStrings_string (b))), 8, issueError));
5225 : 115928 : break;
5226 : :
5227 : :
5228 : 398366 : default:
5229 : 398366 : if (IsReal (a))
5230 : : {
5231 : 6472 : M2ALU_PushRealTree (m2type_RealToTree (reinterpret_cast <char * > (NameKey_KeyToCharStar (s))));
5232 : : }
5233 : : else
5234 : : {
5235 : 391894 : M2ALU_PushIntegerTree (m2decl_BuildConstLiteralNumber (location, const_cast <const char * > (static_cast <char * > (NameKey_KeyToCharStar (s))), 10, issueError));
5236 : : }
5237 : : break;
5238 : : }
5239 : : }
5240 : : else
5241 : : {
5242 : 0 : M2Error_InternalError ((const char *) "expecting constant literal", 26);
5243 : : }
5244 : 515008 : a = DynamicStrings_KillString (a);
5245 : 515008 : b = DynamicStrings_KillString (b);
5246 : 515008 : }
5247 : :
5248 : :
5249 : : /*
5250 : : CoerseLongRealToCard - performs a coersion between a REAL to a CARDINAL
5251 : : */
5252 : :
5253 : 0 : extern "C" void M2ALU_CoerseLongRealToCard (void)
5254 : : {
5255 : 0 : M2ALU_PtrToValue__opaque v;
5256 : :
5257 : 0 : v = Pop ();
5258 : 0 : if (v->type == M2ALU_real)
5259 : : {
5260 : 0 : v->numberValue = m2convert_ConvertConstantAndCheck (v->location, m2type_GetIntegerType (), v->numberValue);
5261 : 0 : v->type = M2ALU_integer;
5262 : 0 : v->areAllConstants = true;
5263 : 0 : v->solved = true;
5264 : : }
5265 : : else
5266 : : {
5267 : 0 : M2Error_InternalError ((const char *) "expecting a REAL number", 23);
5268 : : }
5269 : 0 : Push (v);
5270 : 0 : }
5271 : :
5272 : :
5273 : : /*
5274 : : ConvertRealToInt - converts a REAL into an INTEGER
5275 : : */
5276 : :
5277 : 0 : extern "C" void M2ALU_ConvertRealToInt (void)
5278 : : {
5279 : 0 : M2ALU_PtrToValue__opaque v;
5280 : :
5281 : 0 : v = Pop ();
5282 : 0 : if (v->type == M2ALU_real)
5283 : : {
5284 : 0 : v->numberValue = m2convert_ConvertConstantAndCheck (v->location, m2type_GetIntegerType (), v->numberValue);
5285 : 0 : v->type = M2ALU_integer;
5286 : 0 : v->areAllConstants = true;
5287 : 0 : v->solved = true;
5288 : : }
5289 : : else
5290 : : {
5291 : 0 : M2Error_InternalError ((const char *) "expecting a REAL number", 23);
5292 : : }
5293 : 0 : Push (v);
5294 : 0 : }
5295 : :
5296 : :
5297 : : /*
5298 : : ConvertToInt - converts the value into an INTEGER. This should be used
5299 : : if we are computing the number of elements in a char set to
5300 : : avoid an overflow.
5301 : : */
5302 : :
5303 : 1036412 : extern "C" void M2ALU_ConvertToInt (void)
5304 : : {
5305 : 1036412 : M2ALU_PtrToValue__opaque v;
5306 : :
5307 : 1036412 : v = Pop ();
5308 : 1036412 : if (v->type == M2ALU_integer)
5309 : : {
5310 : 1036412 : v->numberValue = m2convert_ConvertConstantAndCheck (v->location, m2type_GetIntegerType (), v->numberValue);
5311 : 1036412 : v->solved = true;
5312 : 1036412 : v->areAllConstants = true;
5313 : : }
5314 : : else
5315 : : {
5316 : 0 : M2Error_InternalError ((const char *) "expecting an INTEGER number", 27);
5317 : : }
5318 : 1036412 : Push (v);
5319 : 1036412 : }
5320 : :
5321 : :
5322 : : /*
5323 : : ConvertToType - converts the top of stack to type, t.
5324 : : */
5325 : :
5326 : 8072 : extern "C" void M2ALU_ConvertToType (unsigned int t)
5327 : : {
5328 : 8072 : M2ALU_PtrToValue__opaque v;
5329 : :
5330 : 8072 : v = Pop ();
5331 : 8072 : if (t != SymbolTable_NulSym)
5332 : : {
5333 : 8072 : if (v->type == M2ALU_integer)
5334 : : {
5335 : 8072 : v->numberValue = m2convert_ConvertConstantAndCheck (v->location, SymbolConversion_Mod2Gcc (t), v->numberValue);
5336 : 8072 : v->solved = true;
5337 : 8072 : v->areAllConstants = true;
5338 : : }
5339 : : else
5340 : : {
5341 : 0 : M2Error_InternalError ((const char *) "expecting an INTEGER number", 27);
5342 : : }
5343 : : }
5344 : 8072 : Push (v);
5345 : 8072 : }
5346 : :
5347 : :
5348 : : /*
5349 : : IsSolved - returns true if the memory cell indicated by v
5350 : : has a known value.
5351 : : */
5352 : :
5353 : 2341981 : extern "C" bool M2ALU_IsSolved (M2ALU_PtrToValue v)
5354 : : {
5355 : 2341981 : if (v == NULL)
5356 : : {
5357 : 0 : M2Error_InternalError ((const char *) "uninitialized value", 19);
5358 : : }
5359 : : else
5360 : : {
5361 : 2341981 : return static_cast<M2ALU_PtrToValue__opaque> (v)->solved;
5362 : : }
5363 : : ReturnException ("/home/worker/buildworker/tiber-lcov/build/gcc/m2/gm2-compiler/M2ALU.def", 20, 1);
5364 : : __builtin_unreachable ();
5365 : : }
5366 : :
5367 : :
5368 : : /*
5369 : : PutConstructorSolved - records that this constructor is solved.
5370 : : */
5371 : :
5372 : 8130 : extern "C" void M2ALU_PutConstructorSolved (unsigned int sym)
5373 : : {
5374 : 8130 : M2ALU_PtrToValue__opaque v;
5375 : :
5376 : 8130 : SymbolTable_PushValue (sym);
5377 : 8130 : v = Pop ();
5378 : 8130 : v->solved = true;
5379 : 8130 : Push (v);
5380 : 8130 : SymbolTable_PopValue (sym);
5381 : 8130 : }
5382 : :
5383 : :
5384 : : /*
5385 : : EvaluateValue - attempts to evaluate the symbol, sym, value.
5386 : : */
5387 : :
5388 : 16332 : extern "C" void M2ALU_EvaluateValue (unsigned int sym)
5389 : : {
5390 : 16332 : M2ALU_PtrToValue__opaque v;
5391 : :
5392 : 16332 : SymbolTable_PushValue (sym);
5393 : 16332 : v = Pop ();
5394 : 16332 : Eval (SymbolTable_GetDeclaredMod (sym), v);
5395 : 16332 : Push (v);
5396 : 16332 : SymbolTable_PopValue (sym);
5397 : 16332 : }
5398 : :
5399 : :
5400 : : /*
5401 : : TryEvaluateValue - attempts to evaluate the symbol, sym, value.
5402 : : */
5403 : :
5404 : 28638 : extern "C" void M2ALU_TryEvaluateValue (unsigned int sym)
5405 : : {
5406 : 28638 : M2ALU_PtrToValue__opaque v;
5407 : :
5408 : 28638 : SymbolTable_PushValue (sym);
5409 : 28638 : v = Pop ();
5410 : 28638 : switch (v->type)
5411 : : {
5412 : 28458 : case M2ALU_set:
5413 : 28458 : case M2ALU_array:
5414 : 28458 : case M2ALU_record:
5415 : 28458 : if (v->constructorType == SymbolTable_NulSym)
5416 : : {
5417 : : /* must wait */
5418 : : return;
5419 : : }
5420 : : else
5421 : : {
5422 : 28458 : Eval (SymbolTable_GetDeclaredMod (sym), v);
5423 : : }
5424 : 28458 : break;
5425 : :
5426 : :
5427 : : default:
5428 : : break;
5429 : : }
5430 : : /* nothing to do */
5431 : 28632 : if (v->solved)
5432 : : {
5433 : 14690 : Push (v);
5434 : 14690 : SymbolTable_PopValue (sym);
5435 : : }
5436 : : }
5437 : :
5438 : 137138 : extern "C" void M2ALU_Addn (void)
5439 : : {
5440 : 137138 : M2ALU_PtrToValue__opaque Temp;
5441 : 137138 : M2ALU_PtrToValue__opaque Op1;
5442 : 137138 : M2ALU_PtrToValue__opaque Op2;
5443 : :
5444 : : /*
5445 : : Add - adds the top two elements on the stack.
5446 : :
5447 : : The Stack:
5448 : :
5449 : : Entry Exit
5450 : :
5451 : : Ptr ->
5452 : : +------------+
5453 : : | Op1 | <- Ptr
5454 : : |------------| +------------+
5455 : : | Op2 | | Op2 + Op1 |
5456 : : |------------| |------------|
5457 : : */
5458 : 137138 : Op1 = Pop ();
5459 : 137138 : Op2 = Pop ();
5460 : 137138 : if (EitherReal (Op1, Op2))
5461 : : {
5462 : 0 : RealAdd (Op1, Op2);
5463 : : }
5464 : 137138 : else if (EitherComplex (Op1, Op2))
5465 : : {
5466 : : /* avoid dangling else. */
5467 : 0 : ComplexAdd (Op1, Op2);
5468 : : }
5469 : : else
5470 : : {
5471 : : /* avoid dangling else. */
5472 : 137138 : Temp = New (); /* as it is a temp */
5473 : 137138 : Temp->location = Op1->location; /* as it is a temp */
5474 : 137138 : Temp->type = M2ALU_integer;
5475 : 137138 : Temp->numberValue = m2expr_BuildAdd (Temp->location, Op1->numberValue, Op2->numberValue, false);
5476 : 137138 : Temp->solved = true;
5477 : 137138 : Push (Temp);
5478 : : }
5479 : 137138 : Dispose (Op1);
5480 : 137138 : Dispose (Op2);
5481 : 137138 : }
5482 : :
5483 : :
5484 : : /*
5485 : : Sub - subtracts the top two elements on the stack.
5486 : :
5487 : : The Stack:
5488 : :
5489 : : Entry Exit
5490 : :
5491 : : Ptr ->
5492 : : +------------+
5493 : : | Op1 | <- Ptr
5494 : : |------------| +------------+
5495 : : | Op2 | | Op2 - Op1 |
5496 : : |------------| |------------|
5497 : : */
5498 : :
5499 : 457354 : extern "C" void M2ALU_Sub (void)
5500 : : {
5501 : 457354 : M2ALU_PtrToValue__opaque Temp;
5502 : 457354 : M2ALU_PtrToValue__opaque Op1;
5503 : 457354 : M2ALU_PtrToValue__opaque Op2;
5504 : :
5505 : 457354 : Op1 = Pop ();
5506 : 457354 : Op2 = Pop ();
5507 : 457354 : if (EitherReal (Op1, Op2))
5508 : : {
5509 : 0 : RealSub (Op1, Op2);
5510 : : }
5511 : 457354 : else if (EitherComplex (Op1, Op2))
5512 : : {
5513 : : /* avoid dangling else. */
5514 : 0 : ComplexSub (Op1, Op2);
5515 : : }
5516 : : else
5517 : : {
5518 : : /* avoid dangling else. */
5519 : 457354 : Temp = New (); /* as it is a temp */
5520 : 457354 : Temp->location = Op1->location; /* as it is a temp */
5521 : 457354 : Temp->type = M2ALU_integer;
5522 : 457354 : Temp->numberValue = m2expr_BuildSub (Temp->location, Op2->numberValue, Op1->numberValue, true);
5523 : 457354 : Temp->solved = true;
5524 : 457354 : Push (Temp);
5525 : : }
5526 : 457354 : Dispose (Op1);
5527 : 457354 : Dispose (Op2);
5528 : 457354 : }
5529 : :
5530 : 0 : extern "C" void M2ALU_Multn (void)
5531 : : {
5532 : 0 : M2ALU_PtrToValue__opaque Temp;
5533 : 0 : M2ALU_PtrToValue__opaque Op1;
5534 : 0 : M2ALU_PtrToValue__opaque Op2;
5535 : :
5536 : : /*
5537 : : Mult - multiplies the top two elements on the stack.
5538 : :
5539 : : The Stack:
5540 : :
5541 : : Entry Exit
5542 : :
5543 : : Ptr ->
5544 : : +------------+
5545 : : | Op1 | <- Ptr
5546 : : |------------| +------------+
5547 : : | Op2 | | Op2 * Op1 |
5548 : : |------------| |------------|
5549 : : */
5550 : 0 : Op1 = Pop ();
5551 : 0 : Op2 = Pop ();
5552 : 0 : if (EitherReal (Op1, Op2))
5553 : : {
5554 : 0 : RealMult (Op1, Op2);
5555 : : }
5556 : 0 : else if (EitherComplex (Op1, Op2))
5557 : : {
5558 : : /* avoid dangling else. */
5559 : 0 : ComplexMult (Op1, Op2);
5560 : : }
5561 : : else
5562 : : {
5563 : : /* avoid dangling else. */
5564 : 0 : Temp = New (); /* as it is a temp */
5565 : 0 : Temp->location = Op1->location; /* as it is a temp */
5566 : 0 : Temp->type = M2ALU_integer;
5567 : 0 : Temp->numberValue = m2expr_BuildMult (Temp->location, Op2->numberValue, Op1->numberValue, false);
5568 : 0 : Temp->solved = true;
5569 : 0 : Push (Temp);
5570 : : }
5571 : 0 : Dispose (Op1);
5572 : 0 : Dispose (Op2);
5573 : 0 : }
5574 : :
5575 : :
5576 : : /*
5577 : : DivFloor - divides the top two elements on the stack.
5578 : :
5579 : : The Stack:
5580 : :
5581 : : Entry Exit
5582 : :
5583 : : Ptr ->
5584 : : +------------+
5585 : : | Op1 | <- Ptr
5586 : : |------------| +--------------+
5587 : : | Op2 | | Op2 DIV Op1 |
5588 : : |------------| |--------------|
5589 : : */
5590 : :
5591 : 0 : extern "C" void M2ALU_DivFloor (void)
5592 : : {
5593 : 0 : M2ALU_PtrToValue__opaque Temp;
5594 : 0 : M2ALU_PtrToValue__opaque Op1;
5595 : 0 : M2ALU_PtrToValue__opaque Op2;
5596 : :
5597 : 0 : Op1 = Pop ();
5598 : 0 : Op2 = Pop ();
5599 : 0 : if (EitherReal (Op1, Op2))
5600 : : {
5601 : 0 : RealDiv (Op1, Op2);
5602 : : }
5603 : 0 : else if (EitherComplex (Op1, Op2))
5604 : : {
5605 : : /* avoid dangling else. */
5606 : 0 : ComplexDiv (Op1, Op2);
5607 : : }
5608 : : else
5609 : : {
5610 : : /* avoid dangling else. */
5611 : 0 : Temp = New (); /* as it is a temp */
5612 : 0 : Temp->location = Op1->location; /* as it is a temp */
5613 : 0 : Temp->type = M2ALU_integer;
5614 : 0 : Temp->numberValue = m2expr_BuildDivFloor (Temp->location, Op2->numberValue, Op1->numberValue, false);
5615 : 0 : Temp->solved = true;
5616 : 0 : Push (Temp);
5617 : : }
5618 : 0 : Dispose (Op1);
5619 : 0 : Dispose (Op2);
5620 : 0 : }
5621 : :
5622 : :
5623 : : /*
5624 : : ModFloor - modulus of the top two elements on the stack.
5625 : :
5626 : : The Stack:
5627 : :
5628 : : Entry Exit
5629 : :
5630 : : Ptr ->
5631 : : +------------+
5632 : : | Op1 | <- Ptr
5633 : : |------------| +--------------+
5634 : : | Op2 | | Op2 MOD Op1 |
5635 : : |------------| |--------------|
5636 : : */
5637 : :
5638 : 0 : extern "C" void M2ALU_ModFloor (void)
5639 : : {
5640 : 0 : M2ALU_PtrToValue__opaque Temp;
5641 : 0 : M2ALU_PtrToValue__opaque Op1;
5642 : 0 : M2ALU_PtrToValue__opaque Op2;
5643 : :
5644 : 0 : Op1 = Pop ();
5645 : 0 : Op2 = Pop ();
5646 : 0 : if (EitherReal (Op1, Op2))
5647 : : {
5648 : 0 : M2MetaError_MetaError0 ((const char *) "cannot perform {%EkMOD} on REAL types", 37);
5649 : : }
5650 : 0 : else if (EitherComplex (Op1, Op2))
5651 : : {
5652 : : /* avoid dangling else. */
5653 : 0 : M2MetaError_MetaError0 ((const char *) "cannot perform {%EkMOD} on COMPLEX types", 40);
5654 : : }
5655 : : else
5656 : : {
5657 : : /* avoid dangling else. */
5658 : 0 : Temp = New (); /* as it is a temp */
5659 : 0 : Temp->location = Op1->location; /* as it is a temp */
5660 : 0 : Temp->type = M2ALU_integer;
5661 : 0 : Temp->numberValue = m2expr_BuildModFloor (Temp->location, Op2->numberValue, Op1->numberValue, false);
5662 : 0 : Temp->solved = true;
5663 : 0 : Push (Temp);
5664 : : }
5665 : 0 : Dispose (Op1);
5666 : 0 : Dispose (Op2);
5667 : 0 : }
5668 : :
5669 : :
5670 : : /*
5671 : : DivTrunc - divides the top two elements on the stack.
5672 : :
5673 : : The Stack:
5674 : :
5675 : : Entry Exit
5676 : :
5677 : : Ptr ->
5678 : : +------------+
5679 : : | Op1 | <- Ptr
5680 : : |------------| +--------------+
5681 : : | Op2 | | Op2 DIV Op1 |
5682 : : |------------| |--------------|
5683 : : */
5684 : :
5685 : 0 : extern "C" void M2ALU_DivTrunc (void)
5686 : : {
5687 : 0 : M2ALU_PtrToValue__opaque Temp;
5688 : 0 : M2ALU_PtrToValue__opaque Op1;
5689 : 0 : M2ALU_PtrToValue__opaque Op2;
5690 : :
5691 : 0 : Op1 = Pop ();
5692 : 0 : Op2 = Pop ();
5693 : 0 : if (EitherReal (Op1, Op2))
5694 : : {
5695 : 0 : RealDiv (Op1, Op2);
5696 : : }
5697 : 0 : else if (EitherComplex (Op1, Op2))
5698 : : {
5699 : : /* avoid dangling else. */
5700 : 0 : ComplexDiv (Op1, Op2);
5701 : : }
5702 : : else
5703 : : {
5704 : : /* avoid dangling else. */
5705 : 0 : Temp = New (); /* as it is a temp */
5706 : 0 : Temp->location = Op1->location; /* as it is a temp */
5707 : 0 : Temp->type = M2ALU_integer;
5708 : 0 : Temp->numberValue = m2expr_BuildDivTrunc (Temp->location, Op2->numberValue, Op1->numberValue, false);
5709 : 0 : Temp->solved = true;
5710 : 0 : Push (Temp);
5711 : : }
5712 : 0 : Dispose (Op1);
5713 : 0 : Dispose (Op2);
5714 : 0 : }
5715 : :
5716 : :
5717 : : /*
5718 : : ModTrunc - modulus of the top two elements on the stack.
5719 : :
5720 : : The Stack:
5721 : :
5722 : : Entry Exit
5723 : :
5724 : : Ptr ->
5725 : : +------------+
5726 : : | Op1 | <- Ptr
5727 : : |------------| +--------------+
5728 : : | Op2 | | Op2 MOD Op1 |
5729 : : |------------| |--------------|
5730 : : */
5731 : :
5732 : 0 : extern "C" void M2ALU_ModTrunc (void)
5733 : : {
5734 : 0 : M2ALU_PtrToValue__opaque Temp;
5735 : 0 : M2ALU_PtrToValue__opaque Op1;
5736 : 0 : M2ALU_PtrToValue__opaque Op2;
5737 : :
5738 : 0 : Op1 = Pop ();
5739 : 0 : Op2 = Pop ();
5740 : 0 : if (EitherReal (Op1, Op2))
5741 : : {
5742 : 0 : M2MetaError_MetaError0 ((const char *) "cannot perform {%EkMOD} on REAL types", 37);
5743 : : }
5744 : 0 : else if (EitherComplex (Op1, Op2))
5745 : : {
5746 : : /* avoid dangling else. */
5747 : 0 : M2MetaError_MetaError0 ((const char *) "cannot perform {%EkMOD} on COMPLEX types", 40);
5748 : : }
5749 : : else
5750 : : {
5751 : : /* avoid dangling else. */
5752 : 0 : Temp = New (); /* as it is a temp */
5753 : 0 : Temp->location = Op1->location; /* as it is a temp */
5754 : 0 : Temp->type = M2ALU_integer;
5755 : 0 : Temp->numberValue = m2expr_BuildModTrunc (Temp->location, Op2->numberValue, Op1->numberValue, false);
5756 : 0 : Temp->solved = true;
5757 : 0 : Push (Temp);
5758 : : }
5759 : 0 : Dispose (Op1);
5760 : 0 : Dispose (Op2);
5761 : 0 : }
5762 : :
5763 : :
5764 : : /*
5765 : : Equ - returns true if the top two elements on the stack
5766 : : are identical.
5767 : :
5768 : : The Stack:
5769 : :
5770 : : Entry Exit
5771 : :
5772 : : Ptr ->
5773 : : +------------+
5774 : : | Op1 |
5775 : : |------------|
5776 : : | Op2 |
5777 : : |------------| Empty
5778 : :
5779 : : RETURN( Op2 = Op1 )
5780 : : */
5781 : :
5782 : 1122885 : extern "C" bool M2ALU_Equ (unsigned int tokenno)
5783 : : {
5784 : 1122885 : M2ALU_PtrToValue__opaque Op1;
5785 : 1122885 : M2ALU_PtrToValue__opaque Op2;
5786 : 1122885 : bool result;
5787 : :
5788 : 1122885 : Op1 = Pop ();
5789 : 1122885 : Op2 = Pop ();
5790 : 1122885 : if ((Op1->type == M2ALU_set) && (Op2->type == M2ALU_set))
5791 : : {
5792 : 0 : result = AreSetsEqual (tokenno, Op1, Op2);
5793 : : }
5794 : 1122885 : else if ((Op1->type == M2ALU_set) || (Op2->type == M2ALU_set))
5795 : : {
5796 : : /* avoid dangling else. */
5797 : 0 : M2MetaError_MetaErrorT0 (tokenno, (const char *) "cannot perform a comparison between a number and a set", 54);
5798 : 0 : result = false;
5799 : : }
5800 : : else
5801 : : {
5802 : : /* avoid dangling else. */
5803 : 1122885 : if (Op1->type != Op2->type)
5804 : : {
5805 : 0 : M2MetaError_MetaErrorT0 (tokenno, (const char *) "cannot perform a comparison between a different type constants", 62);
5806 : 0 : result = false;
5807 : : }
5808 : 1122885 : else if ((Op1->type == M2ALU_complex) || (Op1->type == M2ALU_real))
5809 : : {
5810 : : /* avoid dangling else. */
5811 : 54 : result = m2expr_AreRealOrComplexConstantsEqual (Op1->numberValue, Op2->numberValue);
5812 : : }
5813 : : else
5814 : : {
5815 : : /* avoid dangling else. */
5816 : 1122831 : result = m2expr_AreConstantsEqual (Op1->numberValue, Op2->numberValue);
5817 : : }
5818 : : }
5819 : 1122885 : Dispose (Op1);
5820 : 1122885 : Dispose (Op2);
5821 : 1122885 : return result;
5822 : : /* static analysis guarentees a RETURN statement will be used before here. */
5823 : : __builtin_unreachable ();
5824 : : }
5825 : :
5826 : :
5827 : : /*
5828 : : NotEqu - returns true if the top two elements on the stack
5829 : : are not identical.
5830 : :
5831 : : The Stack:
5832 : :
5833 : : Entry Exit
5834 : :
5835 : : Ptr ->
5836 : : +------------+
5837 : : | Op1 |
5838 : : |------------|
5839 : : | Op2 |
5840 : : |------------| Empty
5841 : :
5842 : : RETURN( Op2 # Op1 )
5843 : : */
5844 : :
5845 : 1320 : extern "C" bool M2ALU_NotEqu (unsigned int tokenno)
5846 : : {
5847 : 1320 : return ! (M2ALU_Equ (tokenno));
5848 : : /* static analysis guarentees a RETURN statement will be used before here. */
5849 : : __builtin_unreachable ();
5850 : : }
5851 : :
5852 : :
5853 : : /*
5854 : : Less - returns true if Op2 < Op1
5855 : :
5856 : : The Stack:
5857 : :
5858 : : Entry Exit
5859 : :
5860 : : Ptr ->
5861 : : +------------+
5862 : : | Op1 |
5863 : : |------------|
5864 : : | Op2 |
5865 : : |------------| Empty
5866 : :
5867 : : RETURN( Op2 < Op1 )
5868 : : */
5869 : :
5870 : 3101890 : extern "C" bool M2ALU_Less (unsigned int tokenno)
5871 : : {
5872 : 3101890 : M2ALU_PtrToValue__opaque v1;
5873 : 3101890 : M2ALU_PtrToValue__opaque v2;
5874 : 3101890 : bool result;
5875 : 3101890 : int res;
5876 : :
5877 : 3101890 : v1 = Pop ();
5878 : 3101890 : v2 = Pop ();
5879 : 3101890 : if ((v1->type == M2ALU_set) && (v2->type == M2ALU_set))
5880 : : {
5881 : 0 : result = ! (IsSuperset (tokenno, v2, v1));
5882 : : }
5883 : 3101890 : else if ((v1->type == M2ALU_set) || (v2->type == M2ALU_set))
5884 : : {
5885 : : /* avoid dangling else. */
5886 : 0 : M2MetaError_MetaErrorT0 (tokenno, (const char *) "cannot perform a comparison between a number and a set", 54);
5887 : 0 : result = false;
5888 : : }
5889 : : else
5890 : : {
5891 : : /* avoid dangling else. */
5892 : 3101890 : res = m2expr_CompareTrees (v2->numberValue, v1->numberValue);
5893 : 3101890 : if (res == -1)
5894 : : {
5895 : : result = true;
5896 : : }
5897 : : else
5898 : : {
5899 : 1001703 : result = false;
5900 : : }
5901 : : }
5902 : : /* result := (CompareTrees(v2^.numberValue, v1^.numberValue)=-1) */
5903 : 3101890 : Dispose (v1);
5904 : 3101890 : Dispose (v2);
5905 : 3101890 : return result;
5906 : : /* static analysis guarentees a RETURN statement will be used before here. */
5907 : : __builtin_unreachable ();
5908 : : }
5909 : :
5910 : :
5911 : : /*
5912 : : Gre - returns true if Op2 > Op1
5913 : :
5914 : : The Stack:
5915 : :
5916 : : Entry Exit
5917 : :
5918 : : Ptr ->
5919 : : +------------+
5920 : : | Op1 |
5921 : : |------------|
5922 : : | Op2 |
5923 : : |------------| Empty
5924 : :
5925 : : RETURN( Op2 > Op1 )
5926 : : */
5927 : :
5928 : 3146366 : extern "C" bool M2ALU_Gre (unsigned int tokenno)
5929 : : {
5930 : 3146366 : M2ALU_PtrToValue__opaque v1;
5931 : 3146366 : M2ALU_PtrToValue__opaque v2;
5932 : 3146366 : bool result;
5933 : :
5934 : 3146366 : v1 = Pop ();
5935 : 3146366 : v2 = Pop ();
5936 : 3146366 : if ((v1->type == M2ALU_set) && (v2->type == M2ALU_set))
5937 : : {
5938 : 0 : result = ! (IsSubset (tokenno, v2, v1));
5939 : : }
5940 : 3146366 : else if ((v1->type == M2ALU_set) || (v2->type == M2ALU_set))
5941 : : {
5942 : : /* avoid dangling else. */
5943 : 0 : M2MetaError_MetaErrorT0 (tokenno, (const char *) "cannot perform a comparison between a number and a set", 54);
5944 : 0 : M2Error_FlushErrors ();
5945 : 0 : result = false;
5946 : : }
5947 : : else
5948 : : {
5949 : : /* avoid dangling else. */
5950 : 3146366 : result = (m2expr_CompareTrees (v2->numberValue, v1->numberValue)) == 1;
5951 : : }
5952 : 3146366 : Dispose (v1);
5953 : 3146366 : Dispose (v2);
5954 : 3146366 : return result;
5955 : : /* static analysis guarentees a RETURN statement will be used before here. */
5956 : : __builtin_unreachable ();
5957 : : }
5958 : :
5959 : :
5960 : : /*
5961 : : LessEqu - returns true if Op2<Op1
5962 : :
5963 : : The Stack:
5964 : :
5965 : : Entry Exit
5966 : :
5967 : : Ptr ->
5968 : : +------------+
5969 : : | Op1 |
5970 : : |------------|
5971 : : | Op2 |
5972 : : |------------| Empty
5973 : :
5974 : : RETURN( Op2 <= Op1 )
5975 : : */
5976 : :
5977 : 64 : extern "C" bool M2ALU_LessEqu (unsigned int tokenno)
5978 : : {
5979 : 64 : M2ALU_PtrToValue__opaque v1;
5980 : 64 : M2ALU_PtrToValue__opaque v2;
5981 : 64 : bool result;
5982 : :
5983 : 64 : v1 = Pop ();
5984 : 64 : v2 = Pop ();
5985 : 64 : if ((v1->type == M2ALU_set) && (v2->type == M2ALU_set))
5986 : : {
5987 : 0 : result = IsSubset (tokenno, v2, v1);
5988 : : }
5989 : 64 : else if ((v1->type == M2ALU_set) || (v2->type == M2ALU_set))
5990 : : {
5991 : : /* avoid dangling else. */
5992 : 0 : M2MetaError_MetaErrorT0 (tokenno, (const char *) "cannot perform a comparison between a number and a set", 54);
5993 : 0 : M2Error_FlushErrors ();
5994 : 0 : result = false;
5995 : : }
5996 : : else
5997 : : {
5998 : : /* avoid dangling else. */
5999 : 64 : result = (m2expr_CompareTrees (v2->numberValue, v1->numberValue)) <= 0;
6000 : : }
6001 : 64 : Dispose (v1);
6002 : 64 : Dispose (v2);
6003 : 64 : return result;
6004 : : /* static analysis guarentees a RETURN statement will be used before here. */
6005 : : __builtin_unreachable ();
6006 : : }
6007 : :
6008 : :
6009 : : /*
6010 : : GreEqu - returns true if Op2 >= Op1
6011 : : are not identical.
6012 : :
6013 : : The Stack:
6014 : :
6015 : : Entry Exit
6016 : :
6017 : : Ptr ->
6018 : : +------------+
6019 : : | Op1 |
6020 : : |------------|
6021 : : | Op2 |
6022 : : |------------| Empty
6023 : :
6024 : : RETURN( Op2 >= Op1 )
6025 : : */
6026 : :
6027 : 638446 : extern "C" bool M2ALU_GreEqu (unsigned int tokenno)
6028 : : {
6029 : 638446 : M2ALU_PtrToValue__opaque v1;
6030 : 638446 : M2ALU_PtrToValue__opaque v2;
6031 : 638446 : bool result;
6032 : :
6033 : 638446 : v1 = Pop ();
6034 : 638446 : v2 = Pop ();
6035 : 638446 : if ((v1->type == M2ALU_set) && (v2->type == M2ALU_set))
6036 : : {
6037 : 0 : result = IsSuperset (tokenno, v2, v1);
6038 : : }
6039 : 638446 : else if ((v1->type == M2ALU_set) || (v2->type == M2ALU_set))
6040 : : {
6041 : : /* avoid dangling else. */
6042 : 0 : M2MetaError_MetaErrorT0 (tokenno, (const char *) "cannot perform a comparison between a number and a set", 54);
6043 : 0 : M2Error_FlushErrors ();
6044 : 0 : result = false;
6045 : : }
6046 : : else
6047 : : {
6048 : : /* avoid dangling else. */
6049 : 638446 : result = (m2expr_CompareTrees (v2->numberValue, v1->numberValue)) >= 0;
6050 : : }
6051 : 638446 : Dispose (v1);
6052 : 638446 : Dispose (v2);
6053 : 638446 : return result;
6054 : : /* static analysis guarentees a RETURN statement will be used before here. */
6055 : : __builtin_unreachable ();
6056 : : }
6057 : :
6058 : :
6059 : : /*
6060 : : IsNulSet - returns TRUE if the top element is the nul set constant, {}.
6061 : : */
6062 : :
6063 : 0 : extern "C" bool M2ALU_IsNulSet (void)
6064 : : {
6065 : 0 : M2ALU_PtrToValue__opaque v;
6066 : 0 : bool r;
6067 : :
6068 : 0 : v = Pop ();
6069 : 0 : r = (v->type == M2ALU_set) && (v->setValue == NULL);
6070 : 0 : Push (v);
6071 : 0 : return r;
6072 : : /* static analysis guarentees a RETURN statement will be used before here. */
6073 : : __builtin_unreachable ();
6074 : : }
6075 : :
6076 : :
6077 : : /*
6078 : : IsGenericNulSet - returns TRUE if the top element is the generic nul set constant, {}.
6079 : : */
6080 : :
6081 : 0 : extern "C" bool M2ALU_IsGenericNulSet (void)
6082 : : {
6083 : 0 : M2ALU_PtrToValue__opaque v;
6084 : 0 : bool r;
6085 : :
6086 : 0 : v = Pop ();
6087 : 0 : r = ((v->type == M2ALU_set) && (v->setValue == NULL)) && (v->constructorType == SymbolTable_NulSym);
6088 : 0 : Push (v);
6089 : 0 : return r;
6090 : : /* static analysis guarentees a RETURN statement will be used before here. */
6091 : : __builtin_unreachable ();
6092 : : }
6093 : :
6094 : :
6095 : : /*
6096 : : PushNulSet - pushes an empty set {} onto the ALU stack. The subrange type used
6097 : : to construct the set is defined by, constructorType.
6098 : : If this is NulSym then
6099 : : the set is generic and compatible with all sets.
6100 : :
6101 : : The Stack:
6102 : :
6103 : : Entry Exit
6104 : :
6105 : : <- Ptr
6106 : : +------------+
6107 : : | {} |
6108 : : Ptr -> |------------|
6109 : :
6110 : : */
6111 : :
6112 : 0 : extern "C" void M2ALU_PushNulSet (unsigned int settype)
6113 : : {
6114 : 0 : M2ALU_PtrToValue__opaque v;
6115 : :
6116 : 0 : v = static_cast<M2ALU_PtrToValue__opaque> (M2ALU_InitValue ());
6117 : 0 : v->type = M2ALU_set;
6118 : 0 : v->constructorType = settype;
6119 : 0 : v->areAllConstants = true;
6120 : 0 : v->solved = M2GCCDeclare_CompletelyResolved (settype);
6121 : 0 : v->setValue = NULL;
6122 : 0 : v->next = static_cast<M2ALU_PtrToValue__opaque> (NULL);
6123 : 0 : Push (v);
6124 : 0 : }
6125 : :
6126 : :
6127 : : /*
6128 : : AddBitRange - adds the range op1..op2 to the underlying set.
6129 : :
6130 : : Ptr ->
6131 : : <- Ptr
6132 : : +------------+ +------------+
6133 : : | Set | | Set |
6134 : : |------------| |------------|
6135 : :
6136 : : */
6137 : :
6138 : 10628 : extern "C" void M2ALU_AddBitRange (unsigned int tokenno, unsigned int op1, unsigned int op2)
6139 : : {
6140 : 10628 : M2ALU_PtrToValue__opaque v;
6141 : :
6142 : 10628 : v = Pop ();
6143 : 10628 : v = CoerseTo (tokenno, M2ALU_set, v);
6144 : 10628 : if (v->type == M2ALU_set)
6145 : : {
6146 : 10628 : v->setValue = AddRange (v->setValue, op1, op2);
6147 : 10628 : v->solved = (v->solved && (IsSolvedGCC (op1))) && (IsSolvedGCC (op2));
6148 : 10634 : v->areAllConstants = (v->areAllConstants && (SymbolTable_IsConst (op1))) && (SymbolTable_IsConst (op2));
6149 : : }
6150 : 10628 : Push (v);
6151 : 10628 : }
6152 : :
6153 : :
6154 : : /*
6155 : : AddBit - adds the bit op1 to the underlying set. INCL(Set, op1)
6156 : :
6157 : : Ptr ->
6158 : : <- Ptr
6159 : : +------------+ +------------+
6160 : : | Set | | Set |
6161 : : |------------| |------------|
6162 : : */
6163 : :
6164 : 10386 : extern "C" void M2ALU_AddBit (unsigned int tokenno, unsigned int op1)
6165 : : {
6166 : 10386 : M2ALU_AddBitRange (tokenno, op1, op1);
6167 : 10386 : }
6168 : :
6169 : :
6170 : : /*
6171 : : SubBit - removes a bit op1 from the underlying set. EXCL(Set, Op1)
6172 : :
6173 : : Ptr ->
6174 : : <- Ptr
6175 : : +------------+ +------------+
6176 : : | Set | | Set |
6177 : : |------------| |------------|
6178 : : */
6179 : :
6180 : 0 : extern "C" void M2ALU_SubBit (unsigned int tokenno, unsigned int op1)
6181 : : {
6182 : 0 : M2ALU_PtrToValue__opaque v;
6183 : :
6184 : 0 : v = Pop ();
6185 : 0 : if (v->type == M2ALU_set)
6186 : : {
6187 : 0 : Eval (tokenno, v);
6188 : 0 : if (v->solved)
6189 : : {
6190 : 0 : if (IsSolvedGCC (op1))
6191 : : {
6192 : 0 : PerformSubBit (tokenno, &v->setValue, op1);
6193 : 0 : v->solved = false;
6194 : : }
6195 : : else
6196 : : {
6197 : 0 : M2Error_InternalError ((const char *) "can only subtract a bit from a set when the bit value is known", 62);
6198 : : }
6199 : : }
6200 : : else
6201 : : {
6202 : 0 : M2Error_InternalError ((const char *) "can only subtract a bit from a set when the set value is known", 62);
6203 : : }
6204 : 0 : Eval (tokenno, v);
6205 : : }
6206 : : else
6207 : : {
6208 : 0 : M2Error_InternalError ((const char *) "expecting set type constant", 27);
6209 : : }
6210 : 0 : Push (v);
6211 : 0 : }
6212 : :
6213 : :
6214 : : /*
6215 : : SetIn - returns true if Op2 IN Op1
6216 : :
6217 : : The Stack:
6218 : :
6219 : : Entry Exit
6220 : :
6221 : : Ptr ->
6222 : : +------------+
6223 : : | Set |
6224 : : |------------| Empty
6225 : :
6226 : : RETURN( Op1 IN Set )
6227 : : */
6228 : :
6229 : 0 : extern "C" bool M2ALU_SetIn (unsigned int tokenno, unsigned int Op1)
6230 : : {
6231 : 0 : M2ALU_PtrToValue__opaque Set;
6232 : 0 : bool result;
6233 : :
6234 : 0 : Set = Pop ();
6235 : 0 : if (Set->type != M2ALU_set)
6236 : : {
6237 : 0 : M2Error_InternalError ((const char *) "expecting ALU operand to be a set", 33);
6238 : : }
6239 : 0 : Eval (tokenno, Set);
6240 : 0 : if ((IsSolvedGCC (Op1)) && Set->solved)
6241 : : {
6242 : 0 : result = PerformSetIn (tokenno, Op1, Set->setValue);
6243 : : }
6244 : : else
6245 : : {
6246 : 0 : M2Error_InternalError ((const char *) "one or more operands have not been resolved", 43);
6247 : : }
6248 : 0 : Dispose (Set);
6249 : 0 : return result;
6250 : : /* static analysis guarentees a RETURN statement will be used before here. */
6251 : : __builtin_unreachable ();
6252 : : }
6253 : :
6254 : :
6255 : : /*
6256 : : SetOr - performs an inclusive OR of the top two elements on the stack.
6257 : :
6258 : : The Stack:
6259 : :
6260 : : Entry Exit
6261 : :
6262 : : Ptr ->
6263 : : +------------+
6264 : : | Set1 | <- Ptr
6265 : : |------------| +------------+
6266 : : | Set2 | | Set1 + Set2|
6267 : : |------------| |------------|
6268 : :
6269 : : */
6270 : :
6271 : 212 : extern "C" void M2ALU_SetOr (unsigned int tokenno)
6272 : : {
6273 : 212 : SetOp (tokenno, (M2ALU_DoSetProcedure) {(M2ALU_DoSetProcedure_t) PerformOr});
6274 : 212 : }
6275 : :
6276 : :
6277 : : /*
6278 : : SetAnd - performs a set AND the top two elements on the stack.
6279 : :
6280 : : The Stack:
6281 : :
6282 : : Entry Exit
6283 : :
6284 : : Ptr ->
6285 : : +------------+
6286 : : | Op1 | <- Ptr
6287 : : |------------| +------------+
6288 : : | Op2 | | Op2 * Op1 |
6289 : : |------------| |------------|
6290 : : */
6291 : :
6292 : 6 : extern "C" void M2ALU_SetAnd (unsigned int tokenno)
6293 : : {
6294 : 6 : SetOp (tokenno, (M2ALU_DoSetProcedure) {(M2ALU_DoSetProcedure_t) PerformAnd});
6295 : 6 : }
6296 : :
6297 : :
6298 : : /*
6299 : : SetDifference - performs a set difference of the top two elements on the stack.
6300 : : For each member in the set
6301 : : if member in Op2 and not member in Op1
6302 : :
6303 : : The Stack:
6304 : :
6305 : : Entry Exit
6306 : :
6307 : : Ptr ->
6308 : : +------------+
6309 : : | Op1 | <- Ptr
6310 : : |------------| +-------------------+
6311 : : | Op2 | | Op2 and (not Op1) |
6312 : : |------------| |-------------------|
6313 : : */
6314 : :
6315 : 6 : extern "C" void M2ALU_SetDifference (unsigned int tokenno)
6316 : : {
6317 : 6 : M2ALU_PtrToValue__opaque Set1;
6318 : 6 : M2ALU_PtrToValue__opaque Set2;
6319 : :
6320 : 6 : Set1 = Pop ();
6321 : 6 : Set2 = Pop ();
6322 : 6 : Eval (tokenno, Set1);
6323 : 6 : Eval (tokenno, Set2);
6324 : 6 : if (! (Set1->solved && Set2->solved))
6325 : : {
6326 : 0 : M2Error_InternalError ((const char *) "one or more operands have not been resolved", 43);
6327 : : }
6328 : 6 : if (Set1->setValue == NULL)
6329 : : {
6330 : : /* null set, return Set2 */
6331 : 0 : Push (Set1);
6332 : : }
6333 : : else
6334 : : {
6335 : 6 : Push (Set1);
6336 : 6 : M2ALU_SetNegate (tokenno);
6337 : 6 : Push (Set2);
6338 : 6 : M2ALU_SetAnd (tokenno);
6339 : : }
6340 : 6 : }
6341 : :
6342 : :
6343 : : /*
6344 : : SetSymmetricDifference - performs a set difference of the top two elements on the stack.
6345 : :
6346 : : The Stack:
6347 : :
6348 : : Entry Exit
6349 : :
6350 : : Ptr ->
6351 : : +------------+
6352 : : | Op1 | <- Ptr
6353 : : |------------| +-------------+
6354 : : | Op2 | | Op2 xor Op1 |
6355 : : |------------| |-------------|
6356 : : */
6357 : :
6358 : 0 : extern "C" void M2ALU_SetSymmetricDifference (unsigned int tokenno)
6359 : : {
6360 : 0 : M2ALU_PtrToValue__opaque Set1;
6361 : 0 : M2ALU_PtrToValue__opaque Set2;
6362 : :
6363 : 0 : Set1 = Pop ();
6364 : 0 : Set2 = Pop ();
6365 : 0 : Eval (tokenno, Set1);
6366 : 0 : Eval (tokenno, Set2);
6367 : 0 : if (! (Set1->solved && Set2->solved))
6368 : : {
6369 : 0 : M2Error_InternalError ((const char *) "one or more operands have not been resolved", 43);
6370 : : }
6371 : 0 : if (Set1->setValue == NULL)
6372 : : {
6373 : 0 : Dispose (Set1);
6374 : 0 : Push (Set2);
6375 : : }
6376 : 0 : else if (Set2->setValue == NULL)
6377 : : {
6378 : : /* avoid dangling else. */
6379 : 0 : Dispose (Set2);
6380 : 0 : Push (Set1);
6381 : : }
6382 : : else
6383 : : {
6384 : : /* avoid dangling else. */
6385 : : /* Set1 or Set2 and (not (Set1 and Set2)) */
6386 : 0 : M2ALU_PushFrom (static_cast<M2ALU_PtrToValue> (Set1));
6387 : 0 : M2ALU_PushFrom (static_cast<M2ALU_PtrToValue> (Set2));
6388 : 0 : M2ALU_SetAnd (tokenno);
6389 : 0 : M2ALU_SetNegate (tokenno);
6390 : 0 : Push (Set1);
6391 : 0 : Push (Set2);
6392 : 0 : M2ALU_SetOr (tokenno);
6393 : 0 : M2ALU_SetAnd (tokenno);
6394 : : }
6395 : 0 : }
6396 : :
6397 : :
6398 : : /*
6399 : : SetNegate - negates the top set on the stack.
6400 : :
6401 : : Ptr -> <- Ptr
6402 : : +-----------+ +------------+
6403 : : | Set | | Set |
6404 : : |-----------| |------------|
6405 : : */
6406 : :
6407 : 10 : extern "C" void M2ALU_SetNegate (unsigned int tokenno)
6408 : : {
6409 : 10 : unsigned int min;
6410 : 10 : unsigned int max;
6411 : 10 : M2ALU_listOfRange r;
6412 : 10 : M2ALU_listOfRange s;
6413 : 10 : M2ALU_PtrToValue__opaque v;
6414 : 10 : unsigned int i;
6415 : :
6416 : 10 : v = Pop ();
6417 : 10 : Eval (tokenno, v);
6418 : 10 : if (v->constructorType == SymbolTable_NulSym)
6419 : : {
6420 : 0 : M2MetaError_MetaError0 ((const char *) "cannot negate a generic set, set should be prefixed by a simple type", 68);
6421 : : }
6422 : 10 : r = NULL;
6423 : 10 : min = M2GCCDeclare_GetTypeMin (SymbolTable_GetType (v->constructorType));
6424 : 10 : max = M2GCCDeclare_GetTypeMax (SymbolTable_GetType (v->constructorType));
6425 : 10 : i = min;
6426 : 10 : s = v->setValue;
6427 : 10 : if (Debugging)
6428 : : {
6429 : : M2Printf_printf0 ((const char *) "attempting to negate set\\n", 26);
6430 : : DisplayElements (s);
6431 : : }
6432 : 22 : while (s != NULL)
6433 : : {
6434 : 12 : SymbolTable_PushValue (s->low);
6435 : 12 : SymbolTable_PushValue (min);
6436 : 12 : if (M2ALU_Gre (tokenno))
6437 : : {
6438 : 12 : SymbolTable_PushValue (i);
6439 : 12 : SymbolTable_PushValue (max);
6440 : 12 : if (M2ALU_LessEqu (tokenno))
6441 : : {
6442 : 12 : r = AddRange (r, i, DupConst (tokenno, s->low, -1));
6443 : : }
6444 : : }
6445 : 12 : SymbolTable_PushValue (s->high);
6446 : 12 : SymbolTable_PushValue (max);
6447 : 12 : if (M2ALU_Less (tokenno))
6448 : : {
6449 : 12 : i = DupConst (tokenno, s->high, 1);
6450 : 12 : s = s->next;
6451 : : }
6452 : : else
6453 : : {
6454 : : s = NULL;
6455 : : }
6456 : : }
6457 : 10 : if (Debugging)
6458 : : {
6459 : : M2Printf_printf0 ((const char *) "negated set so far\\n", 20);
6460 : : DisplayElements (r);
6461 : : }
6462 : 10 : DisposeRange (&v->setValue);
6463 : 10 : SymbolTable_PushValue (i);
6464 : 10 : SymbolTable_PushValue (max);
6465 : 10 : if (M2ALU_LessEqu (tokenno))
6466 : : {
6467 : 10 : r = AddRange (r, i, max);
6468 : : }
6469 : 10 : if (Debugging)
6470 : : {
6471 : : M2Printf_printf0 ((const char *) "final negated set value\\n", 25);
6472 : : DisplayElements (r);
6473 : : }
6474 : 10 : v->solved = false;
6475 : 10 : v->setValue = r;
6476 : 10 : Eval (tokenno, v);
6477 : 10 : Push (v);
6478 : 10 : }
6479 : :
6480 : :
6481 : : /*
6482 : : SetShift - if op1 is positive
6483 : : then
6484 : : result := op2 << op1
6485 : : else
6486 : : result := op2 >> op1
6487 : : fi
6488 : :
6489 : :
6490 : : The Stack:
6491 : :
6492 : : Entry Exit
6493 : :
6494 : : Ptr ->
6495 : : +------------+
6496 : : | Op1 | <- Ptr
6497 : : |------------| +------------+
6498 : : | Op2 | | result |
6499 : : |------------| |------------|
6500 : :
6501 : : */
6502 : :
6503 : 0 : extern "C" void M2ALU_SetShift (unsigned int tokenno)
6504 : : {
6505 : 0 : M2ALU_PtrToValue__opaque res;
6506 : 0 : M2ALU_PtrToValue__opaque Shift;
6507 : 0 : M2ALU_PtrToValue__opaque Set;
6508 : 0 : unsigned int n;
6509 : 0 : unsigned int r1;
6510 : 0 : unsigned int r2;
6511 : :
6512 : 0 : if (! (M2ALU_IsValueTypeInteger ()))
6513 : : {
6514 : 0 : M2Error_InternalError ((const char *) "expecting integer type", 22);
6515 : : }
6516 : 0 : Shift = Pop ();
6517 : 0 : if (! (M2ALU_IsValueTypeSet ()))
6518 : : {
6519 : 0 : M2Error_InternalError ((const char *) "expecting set type", 18);
6520 : : }
6521 : 0 : Set = Pop ();
6522 : 0 : Eval (tokenno, Set);
6523 : 0 : if (! Set->solved)
6524 : : {
6525 : 0 : M2Error_InternalError ((const char *) "set has not been resolved", 25);
6526 : : }
6527 : 0 : if (Set->setValue == NULL)
6528 : : {
6529 : 0 : Push (Set);
6530 : : }
6531 : : else
6532 : : {
6533 : 0 : res = New ();
6534 : 0 : (*res) = (*Set);
6535 : 0 : res->setValue = NULL;
6536 : 0 : n = 1;
6537 : 0 : while (M2ALU_GetRange (static_cast<M2ALU_PtrToValue> (Set), n, &r1, &r2))
6538 : : {
6539 : 0 : res->setValue = AddRange (res->setValue, DupConstAndAdd (tokenno, r1, reinterpret_cast <tree> (Shift)), DupConstAndAdd (tokenno, r2, reinterpret_cast <tree> (Shift)));
6540 : 0 : n += 1;
6541 : : }
6542 : 0 : Push (res);
6543 : 0 : if (res->constructorType != SymbolTable_NulSym)
6544 : : {
6545 : 0 : M2ALU_PushNulSet (res->constructorType);
6546 : 0 : M2ALU_SetNegate (tokenno);
6547 : 0 : M2ALU_SetAnd (tokenno);
6548 : : }
6549 : 0 : Dispose (Set);
6550 : : }
6551 : 0 : }
6552 : :
6553 : :
6554 : : /*
6555 : : SetRotate - if op1 is positive
6556 : : then
6557 : : result := ROTATERIGHT(op2, op1)
6558 : : else
6559 : : result := ROTATELEFT(op2, op1)
6560 : : fi
6561 : :
6562 : :
6563 : : The Stack:
6564 : :
6565 : : Entry Exit
6566 : :
6567 : : Ptr ->
6568 : : +------------+
6569 : : | Op1 | <- Ptr
6570 : : |------------| +------------+
6571 : : | Op2 | | result |
6572 : : |------------| |------------|
6573 : : */
6574 : :
6575 : 0 : extern "C" void M2ALU_SetRotate (unsigned int tokenno)
6576 : : {
6577 : 0 : M2ALU_PtrToValue__opaque res;
6578 : 0 : M2ALU_PtrToValue__opaque Rotate;
6579 : 0 : M2ALU_PtrToValue__opaque Set;
6580 : 0 : unsigned int n;
6581 : 0 : unsigned int l;
6582 : 0 : unsigned int h;
6583 : 0 : unsigned int type;
6584 : 0 : unsigned int r1;
6585 : 0 : unsigned int r2;
6586 : :
6587 : 0 : if (! (M2ALU_IsValueTypeInteger ()))
6588 : : {
6589 : 0 : M2Error_InternalError ((const char *) "expecting integer type", 22);
6590 : : }
6591 : 0 : Rotate = Pop ();
6592 : 0 : if (! (M2ALU_IsValueTypeSet ()))
6593 : : {
6594 : 0 : M2Error_InternalError ((const char *) "expecting set type", 18);
6595 : : }
6596 : 0 : Set = Pop ();
6597 : 0 : Eval (tokenno, Set);
6598 : 0 : if (! Set->solved)
6599 : : {
6600 : 0 : M2Error_InternalError ((const char *) "set has not been resolved", 25);
6601 : : }
6602 : 0 : if (Set->setValue == NULL)
6603 : : {
6604 : 0 : Push (Set);
6605 : : }
6606 : : else
6607 : : {
6608 : 0 : type = Set->constructorType;
6609 : 0 : if (type == SymbolTable_NulSym)
6610 : : {
6611 : 0 : M2MetaError_MetaErrorT0 (tokenno, (const char *) "cannot perform a ROTATE on a generic set", 40);
6612 : 0 : Push (Set);
6613 : 0 : return;
6614 : : }
6615 : 0 : l = M2GCCDeclare_GetTypeMin (type);
6616 : 0 : h = M2GCCDeclare_GetTypeMax (type);
6617 : 0 : res = New ();
6618 : 0 : (*res) = (*Set);
6619 : 0 : res->setValue = NULL;
6620 : 0 : n = 1;
6621 : 0 : while (M2ALU_GetRange (static_cast<M2ALU_PtrToValue> (Set), n, &r1, &r2))
6622 : : {
6623 : 0 : res->setValue = AddRange (res->setValue, DupConstAndAddMod (tokenno, r1, reinterpret_cast <tree> (Rotate), l, h), DupConstAndAddMod (tokenno, r2, reinterpret_cast <tree> (Rotate), l, h));
6624 : 0 : n += 1;
6625 : : }
6626 : 0 : Push (res);
6627 : 0 : Dispose (Set);
6628 : : }
6629 : : }
6630 : :
6631 : :
6632 : : /*
6633 : : GetValue - returns and pops the value from the top of stack.
6634 : : */
6635 : :
6636 : 62 : extern "C" M2ALU_PtrToValue M2ALU_GetValue (unsigned int tokenno)
6637 : : {
6638 : 62 : M2ALU_PtrToValue__opaque v;
6639 : :
6640 : 62 : v = Pop ();
6641 : 62 : Eval (tokenno, v);
6642 : 62 : return static_cast<M2ALU_PtrToValue> (v);
6643 : : /* static analysis guarentees a RETURN statement will be used before here. */
6644 : : __builtin_unreachable ();
6645 : : }
6646 : :
6647 : :
6648 : : /*
6649 : : GetRange - returns TRUE if range number, n, exists in the value, v.
6650 : : A non empty set is defined by having 1..N ranges
6651 : : */
6652 : :
6653 : 62826 : extern "C" bool M2ALU_GetRange (M2ALU_PtrToValue v, unsigned int n, unsigned int *low, unsigned int *high)
6654 : : {
6655 : 62826 : M2ALU_listOfRange l;
6656 : :
6657 : 62826 : if (static_cast<M2ALU_PtrToValue__opaque> (v)->type != M2ALU_set)
6658 : : {
6659 : 0 : M2Error_InternalError ((const char *) "expecting set constant", 22);
6660 : : }
6661 : 62826 : l = static_cast<M2ALU_PtrToValue__opaque> (v)->setValue;
6662 : 140380 : while (n > 1)
6663 : : {
6664 : 77554 : if (l == NULL)
6665 : : {
6666 : : return false;
6667 : : }
6668 : 77554 : l = l->next;
6669 : 77554 : n -= 1;
6670 : : }
6671 : 62826 : if (l == NULL)
6672 : : {
6673 : : return false;
6674 : : }
6675 : 38394 : (*low) = l->low;
6676 : 38394 : (*high) = l->high;
6677 : 38394 : return true;
6678 : : /* static analysis guarentees a RETURN statement will be used before here. */
6679 : : __builtin_unreachable ();
6680 : : }
6681 : :
6682 : :
6683 : : /*
6684 : : ConstructSetConstant - builds a struct of integers which represents the
6685 : : set const as defined by, v.
6686 : : */
6687 : :
6688 : 7896 : extern "C" tree M2ALU_ConstructSetConstant (unsigned int tokenno, M2ALU_PtrToValue v)
6689 : : {
6690 : 7896 : NameKey_Name n1;
6691 : 7896 : NameKey_Name n2;
6692 : 7896 : tree gccsym;
6693 : 7896 : unsigned int baseType;
6694 : 7896 : unsigned int high;
6695 : 7896 : unsigned int low;
6696 : :
6697 : 7896 : if (static_cast<M2ALU_PtrToValue__opaque> (v)->constructorType == SymbolTable_NulSym)
6698 : : {
6699 : 0 : M2Error_InternalError ((const char *) "set type must be known in order to generate a constant", 54);
6700 : : }
6701 : : else
6702 : : {
6703 : 7896 : baseType = SymbolTable_SkipType (SymbolTable_GetType (static_cast<M2ALU_PtrToValue__opaque> (v)->constructorType));
6704 : 7896 : if (Debugging)
6705 : : {
6706 : : n1 = SymbolTable_GetSymName (static_cast<M2ALU_PtrToValue__opaque> (v)->constructorType);
6707 : : n2 = SymbolTable_GetSymName (baseType);
6708 : : M2Printf_printf2 ((const char *) "ConstructSetConstant of type %a and baseType %a\\n", 49, (const unsigned char *) &n1, (sizeof (n1)-1), (const unsigned char *) &n2, (sizeof (n2)-1));
6709 : : }
6710 : 7896 : if (SymbolTable_IsSubrange (baseType))
6711 : : {
6712 : 3212 : SymbolTable_GetSubrange (baseType, &high, &low);
6713 : 3212 : gccsym = ConstructLargeOrSmallSet (tokenno, static_cast<M2ALU_PtrToValue__opaque> (v), low, high);
6714 : : }
6715 : : else
6716 : : {
6717 : 4684 : gccsym = ConstructLargeOrSmallSet (tokenno, static_cast<M2ALU_PtrToValue__opaque> (v), M2GCCDeclare_GetTypeMin (baseType), M2GCCDeclare_GetTypeMax (baseType));
6718 : : }
6719 : 7896 : return gccsym;
6720 : : }
6721 : : ReturnException ("/home/worker/buildworker/tiber-lcov/build/gcc/m2/gm2-compiler/M2ALU.def", 20, 1);
6722 : : __builtin_unreachable ();
6723 : : }
6724 : :
6725 : :
6726 : : /*
6727 : : BuildRange - returns a integer sized constant which represents the
6728 : : value {e1..e2}.
6729 : : */
6730 : :
6731 : 9066 : extern "C" tree M2ALU_BuildRange (unsigned int tokenno, tree e1, tree e2)
6732 : : {
6733 : 9066 : tree c;
6734 : 9066 : tree i;
6735 : 9066 : tree t;
6736 : 9066 : location_t location;
6737 : :
6738 : 9066 : location = M2LexBuf_TokenToLocation (tokenno);
6739 : 9066 : M2ALU_PushIntegerTree (e1);
6740 : 9066 : M2ALU_PushIntegerTree (e2);
6741 : 9066 : if (M2ALU_Gre (tokenno))
6742 : : {
6743 : 0 : c = e1;
6744 : 0 : e1 = e2;
6745 : 0 : e2 = c;
6746 : : }
6747 : 9066 : t = (tree) (NULL);
6748 : 9066 : M2ALU_PushIntegerTree (e1);
6749 : 9066 : i = M2ALU_PopIntegerTree ();
6750 : 15238 : do {
6751 : 15238 : if (t == ((tree) (NULL)))
6752 : : {
6753 : 9066 : t = m2expr_BuildLSL (location, m2expr_GetWordOne (location), m2convert_ToWord (location, i), false);
6754 : : }
6755 : : else
6756 : : {
6757 : 6172 : t = m2expr_BuildLogicalOr (location, t, m2expr_BuildLSL (location, m2expr_GetWordOne (location), m2convert_ToWord (location, i), false), false);
6758 : : }
6759 : 15238 : M2ALU_PushIntegerTree (i);
6760 : 15238 : M2ALU_PushIntegerTree (m2expr_GetIntegerOne (location));
6761 : 15238 : M2ALU_Addn ();
6762 : 15238 : i = M2ALU_PopIntegerTree ();
6763 : 15238 : M2ALU_PushIntegerTree (i);
6764 : 15238 : M2ALU_PushIntegerTree (e2);
6765 : 15238 : } while (! (M2ALU_Gre (tokenno)));
6766 : 9066 : return t;
6767 : : /* static analysis guarentees a RETURN statement will be used before here. */
6768 : : __builtin_unreachable ();
6769 : : }
6770 : :
6771 : :
6772 : : /*
6773 : : IsConstructorDependants - return TRUE if all q(dependants) of,
6774 : : sym, return TRUE.
6775 : : */
6776 : :
6777 : 41370 : extern "C" bool M2ALU_IsConstructorDependants (unsigned int sym, M2GCCDeclare_IsAction q)
6778 : : {
6779 : 41370 : M2ALU_PtrToValue__opaque v;
6780 : 41370 : bool typeResult;
6781 : 41370 : bool result;
6782 : :
6783 : 41370 : SymbolTable_PushValue (sym);
6784 : 41370 : if (M2ALU_IsValueTypeNone ())
6785 : : {
6786 : 4662 : v = Pop ();
6787 : 4662 : result = false;
6788 : : }
6789 : : else
6790 : : {
6791 : 36708 : v = Pop ();
6792 : 36708 : typeResult = (*q.proc) (v->constructorType);
6793 : 36708 : switch (v->type)
6794 : : {
6795 : : case M2ALU_none:
6796 : : result = false;
6797 : : break;
6798 : :
6799 : 18790 : case M2ALU_set:
6800 : 18790 : result = IsSetValueDependants (v->setValue, q);
6801 : 18790 : break;
6802 : :
6803 : 15388 : case M2ALU_constructor:
6804 : 15388 : case M2ALU_record:
6805 : 15388 : result = IsFieldValueDependants (v->fieldValues, q);
6806 : 15388 : break;
6807 : :
6808 : 2530 : case M2ALU_array:
6809 : 2530 : result = IsArrayValueDependants (v->arrayValues, q);
6810 : 2530 : break;
6811 : :
6812 : :
6813 : 0 : default:
6814 : 0 : M2Error_InternalError ((const char *) "not expecting this type", 23);
6815 : 36708 : break;
6816 : : }
6817 : 36708 : result = result && typeResult;
6818 : : }
6819 : 41370 : return result;
6820 : : /* static analysis guarentees a RETURN statement will be used before here. */
6821 : : __builtin_unreachable ();
6822 : : }
6823 : :
6824 : :
6825 : : /*
6826 : : WalkConstructorDependants - walk the constructor, sym, calling
6827 : : p for each dependant.
6828 : : */
6829 : :
6830 : 723310 : extern "C" void M2ALU_WalkConstructorDependants (unsigned int sym, M2GCCDeclare_WalkAction p)
6831 : : {
6832 : 723310 : M2ALU_PtrToValue__opaque v;
6833 : :
6834 : 723310 : SymbolTable_PushValue (sym);
6835 : 723310 : if (M2ALU_IsValueTypeNone ())
6836 : : {
6837 : 6732 : v = Pop ();
6838 : : }
6839 : : else
6840 : : {
6841 : 716578 : v = Pop ();
6842 : 716578 : (*p.proc) (v->constructorType);
6843 : 716578 : switch (v->type)
6844 : : {
6845 : : case M2ALU_none:
6846 : : break;
6847 : :
6848 : 221858 : case M2ALU_set:
6849 : 221858 : WalkSetValueDependants (v->setValue, p);
6850 : 221858 : break;
6851 : :
6852 : 408836 : case M2ALU_constructor:
6853 : 408836 : case M2ALU_record:
6854 : 408836 : WalkFieldValueDependants (v->fieldValues, p);
6855 : : break;
6856 : :
6857 : 85884 : case M2ALU_array:
6858 : 85884 : WalkArrayValueDependants (v->arrayValues, p);
6859 : 85884 : break;
6860 : :
6861 : :
6862 : 0 : default:
6863 : 0 : M2Error_InternalError ((const char *) "not expecting this type", 23);
6864 : 723310 : break;
6865 : : }
6866 : : }
6867 : 723310 : }
6868 : :
6869 : :
6870 : : /*
6871 : : IsValueAndTreeKnown - returns TRUE if the value is known and the gcc tree
6872 : : is defined.
6873 : :
6874 : : The Stack:
6875 : :
6876 : : Entry Exit
6877 : :
6878 : : Ptr ->
6879 : : +------------+
6880 : : | Op1 | <- Ptr
6881 : : |------------| +------------+
6882 : : */
6883 : :
6884 : 78 : extern "C" bool M2ALU_IsValueAndTreeKnown (void)
6885 : : {
6886 : 78 : M2ALU_PtrToValue__opaque v;
6887 : :
6888 : 78 : v = Pop ();
6889 : 78 : if (v != NULL)
6890 : : {
6891 : 78 : if (v->solved)
6892 : : {
6893 : 78 : switch (v->type)
6894 : : {
6895 : 78 : case M2ALU_integer:
6896 : 78 : case M2ALU_real:
6897 : 78 : case M2ALU_complex:
6898 : 78 : if (v->numberValue == NULL)
6899 : : {
6900 : 0 : Dispose (v);
6901 : 0 : return false;
6902 : : }
6903 : : break;
6904 : :
6905 : :
6906 : : default:
6907 : : break;
6908 : : }
6909 : : }
6910 : : else
6911 : : {
6912 : 0 : Dispose (v);
6913 : 0 : return false;
6914 : : }
6915 : 78 : Dispose (v);
6916 : : }
6917 : 78 : return true;
6918 : : /* static analysis guarentees a RETURN statement will be used before here. */
6919 : : __builtin_unreachable ();
6920 : : }
6921 : :
6922 : :
6923 : : /*
6924 : : CheckOrResetOverflow - tests to see whether the tree, t, has caused
6925 : : an overflow error and if so it generates an
6926 : : error message.
6927 : : */
6928 : :
6929 : 328215 : extern "C" void M2ALU_CheckOrResetOverflow (unsigned int tokenno, tree t, bool check)
6930 : : {
6931 : 328215 : if (check)
6932 : : {
6933 : 318849 : CheckOverflow (tokenno, t);
6934 : : }
6935 : : else
6936 : : {
6937 : 9366 : t = m2expr_RemoveOverflow (t);
6938 : : }
6939 : 328203 : }
6940 : :
6941 : :
6942 : : /*
6943 : : AddElements - adds the elements, el BY, n, to the array constant.
6944 : :
6945 : : Ptr ->
6946 : : <- Ptr
6947 : : +------------+ +------------+
6948 : : | Array | | Array |
6949 : : |------------| |------------|
6950 : :
6951 : : */
6952 : :
6953 : 30 : extern "C" void M2ALU_AddElements (unsigned int tokenno, unsigned int el, unsigned int n)
6954 : : {
6955 : 30 : M2ALU_PtrToValue__opaque v;
6956 : 30 : M2ALU_listOfElements e;
6957 : :
6958 : 30 : v = Pop ();
6959 : 30 : v = CoerseTo (tokenno, M2ALU_array, v);
6960 : 30 : if (v->type == M2ALU_array)
6961 : : {
6962 : 30 : NewElement (&e);
6963 : 30 : e->element = el;
6964 : 30 : e->by = n;
6965 : 30 : e->next = NULL;
6966 : 30 : AddElementToEnd (v, e);
6967 : 30 : v->solved = (v->solved && (IsSolvedGCC (el))) && (IsSolvedGCC (n));
6968 : : }
6969 : : else
6970 : : {
6971 : 0 : M2Error_InternalError ((const char *) "expecting array type", 20);
6972 : : }
6973 : 30 : Push (v);
6974 : 30 : }
6975 : :
6976 : :
6977 : : /*
6978 : : AddField - adds the field op1 to the underlying constructor.
6979 : :
6980 : : Ptr ->
6981 : : <- Ptr
6982 : : +------------+ +------------+
6983 : : | const | | const |
6984 : : |------------| |------------|
6985 : :
6986 : : */
6987 : :
6988 : 13604 : extern "C" void M2ALU_AddField (unsigned int tokenno, unsigned int op1)
6989 : : {
6990 : 13604 : M2ALU_PtrToValue__opaque v;
6991 : 13604 : M2ALU_listOfFields f;
6992 : 13604 : M2ALU_listOfElements e;
6993 : :
6994 : 13604 : v = Pop ();
6995 : 13604 : switch (v->type)
6996 : : {
6997 : 0 : case M2ALU_set:
6998 : 0 : Push (v);
6999 : 0 : M2ALU_AddBit (tokenno, op1);
7000 : 0 : return;
7001 : 4172 : break;
7002 : :
7003 : 4172 : case M2ALU_array:
7004 : 4172 : v->solved = v->solved && (IsSolvedGCC (op1));
7005 : 4172 : v->areAllConstants = v->areAllConstants && (SymbolTable_IsConst (op1));
7006 : 4172 : NewElement (&e);
7007 : 4172 : e->element = op1;
7008 : 4172 : e->by = SymbolTable_MakeConstLit (tokenno, NameKey_MakeKey ((const char *) "1", 1), M2Base_ZType);
7009 : 4172 : e->next = NULL;
7010 : 4172 : AddElementToEnd (v, e);
7011 : : break;
7012 : :
7013 : 9432 : case M2ALU_constructor:
7014 : 9432 : case M2ALU_record:
7015 : 9432 : v->solved = v->solved && (IsSolvedGCC (op1));
7016 : 9432 : v->areAllConstants = v->areAllConstants && (SymbolTable_IsConst (op1));
7017 : 9432 : NewField (&f);
7018 : 9432 : f->field = op1;
7019 : 9432 : f->next = NULL;
7020 : 9432 : AddFieldToEnd (v, f);
7021 : : break;
7022 : :
7023 : :
7024 : 0 : default:
7025 : 0 : M2Error_InternalError ((const char *) "not expecting this constant type", 32);
7026 : 13604 : break;
7027 : : }
7028 : 13604 : Push (v);
7029 : : }
7030 : :
7031 : :
7032 : : /*
7033 : : PushEmptyConstructor - pushes an empty constructor {} onto the ALU stack.
7034 : : This is expected to be filled in by subsequent
7035 : : calls to AddElements, AddRange or AddField.
7036 : :
7037 : : The Stack:
7038 : :
7039 : : Entry Exit
7040 : :
7041 : : <- Ptr
7042 : : +------------+
7043 : : | {} |
7044 : : Ptr -> |------------|
7045 : :
7046 : : */
7047 : :
7048 : 0 : extern "C" void M2ALU_PushEmptyConstructor (unsigned int constype)
7049 : : {
7050 : 0 : M2ALU_PtrToValue__opaque v;
7051 : :
7052 : 0 : v = static_cast<M2ALU_PtrToValue__opaque> (M2ALU_InitValue ());
7053 : 0 : v->type = M2ALU_constructor;
7054 : 0 : v->constructorType = constype;
7055 : 0 : v->areAllConstants = true;
7056 : 0 : v->solved = M2GCCDeclare_CompletelyResolved (constype);
7057 : 0 : v->fieldValues = NULL;
7058 : 0 : v->next = static_cast<M2ALU_PtrToValue__opaque> (NULL);
7059 : 0 : Push (v);
7060 : 0 : }
7061 : :
7062 : :
7063 : : /*
7064 : : PushEmptyArray - pushes an empty array {} onto the ALU stack.
7065 : : This is expected to be filled in by subsequent
7066 : : calls to AddElements.
7067 : :
7068 : : The Stack:
7069 : :
7070 : : Entry Exit
7071 : :
7072 : : <- Ptr
7073 : : +------------+
7074 : : | {} |
7075 : : Ptr -> |------------|
7076 : :
7077 : : */
7078 : :
7079 : 0 : extern "C" void M2ALU_PushEmptyArray (unsigned int arraytype)
7080 : : {
7081 : 0 : M2ALU_PtrToValue__opaque v;
7082 : :
7083 : 0 : v = static_cast<M2ALU_PtrToValue__opaque> (M2ALU_InitValue ());
7084 : 0 : v->type = M2ALU_array;
7085 : 0 : v->constructorType = arraytype;
7086 : 0 : v->areAllConstants = true;
7087 : 0 : v->solved = M2GCCDeclare_CompletelyResolved (arraytype);
7088 : 0 : v->arrayValues = NULL;
7089 : 0 : v->next = static_cast<M2ALU_PtrToValue__opaque> (NULL);
7090 : 0 : Push (v);
7091 : 0 : }
7092 : :
7093 : :
7094 : : /*
7095 : : PushEmptyRecord - pushes an empty record {} onto the ALU stack.
7096 : : This is expected to be filled in by subsequent
7097 : : calls to AddField.
7098 : :
7099 : : The Stack:
7100 : :
7101 : : Entry Exit
7102 : :
7103 : : <- Ptr
7104 : : +------------+
7105 : : | {} |
7106 : : Ptr -> |------------|
7107 : :
7108 : : */
7109 : :
7110 : 0 : extern "C" void M2ALU_PushEmptyRecord (unsigned int recordtype)
7111 : : {
7112 : 0 : M2ALU_PtrToValue__opaque v;
7113 : :
7114 : 0 : v = static_cast<M2ALU_PtrToValue__opaque> (M2ALU_InitValue ());
7115 : 0 : v->type = M2ALU_record;
7116 : 0 : v->constructorType = recordtype;
7117 : 0 : v->areAllConstants = true;
7118 : 0 : v->solved = M2GCCDeclare_CompletelyResolved (recordtype);
7119 : 0 : v->arrayValues = NULL;
7120 : 0 : v->next = static_cast<M2ALU_PtrToValue__opaque> (NULL);
7121 : 0 : Push (v);
7122 : 0 : }
7123 : :
7124 : :
7125 : : /*
7126 : : ChangeToConstructor - change the top of stack value to a constructor, type.
7127 : : (Constructor, Set, Array or Record).
7128 : : */
7129 : :
7130 : 29420 : extern "C" void M2ALU_ChangeToConstructor (unsigned int tokenno, unsigned int constype)
7131 : : {
7132 : 29420 : M2ALU_PtrToValue__opaque v;
7133 : :
7134 : 29420 : if ((((M2ALU_IsValueTypeConstructor ()) || (M2ALU_IsValueTypeSet ())) || (M2ALU_IsValueTypeArray ())) || (M2ALU_IsValueTypeRecord ()))
7135 : : {
7136 : 8130 : return;
7137 : : }
7138 : 21290 : else if (M2ALU_IsValueTypeNone ())
7139 : : {
7140 : : /* avoid dangling else. */
7141 : 21290 : v = Pop ();
7142 : 21290 : v->type = M2ALU_constructor;
7143 : 21290 : v->constructorType = constype;
7144 : 21290 : v->solved = M2GCCDeclare_CompletelyResolved (constype);
7145 : 21290 : v->fieldValues = NULL;
7146 : 21290 : v->next = static_cast<M2ALU_PtrToValue__opaque> (NULL);
7147 : 21290 : if (SymbolTable_IsSet (SymbolTable_SkipType (constype)))
7148 : : {
7149 : 18160 : v = CoerseTo (tokenno, M2ALU_set, v);
7150 : : }
7151 : 3130 : else if (SymbolTable_IsRecord (SymbolTable_SkipType (constype)))
7152 : : {
7153 : : /* avoid dangling else. */
7154 : 2258 : v = CoerseTo (tokenno, M2ALU_record, v);
7155 : : }
7156 : 872 : else if (SymbolTable_IsArray (SymbolTable_SkipType (constype)))
7157 : : {
7158 : : /* avoid dangling else. */
7159 : 866 : v = CoerseTo (tokenno, M2ALU_array, v);
7160 : : }
7161 : 21290 : Push (v);
7162 : : }
7163 : : else
7164 : : {
7165 : : /* avoid dangling else. */
7166 : 0 : M2Error_InternalError ((const char *) "cannot change constant to a constructor type", 44);
7167 : : }
7168 : : }
7169 : :
7170 : :
7171 : : /*
7172 : : IsValueConst - returns true if the memory cell indicated by v
7173 : : is only defined by constants. For example
7174 : : no variables are used in the constructor.
7175 : : */
7176 : :
7177 : 2359198 : extern "C" bool M2ALU_IsValueConst (M2ALU_PtrToValue v)
7178 : : {
7179 : 2359198 : if (v == NULL)
7180 : : {
7181 : 0 : M2Error_InternalError ((const char *) "uninitialized value", 19);
7182 : : }
7183 : : else
7184 : : {
7185 : 2359198 : return static_cast<M2ALU_PtrToValue__opaque> (v)->areAllConstants;
7186 : : }
7187 : : ReturnException ("/home/worker/buildworker/tiber-lcov/build/gcc/m2/gm2-compiler/M2ALU.def", 20, 1);
7188 : : __builtin_unreachable ();
7189 : : }
7190 : :
7191 : :
7192 : : /*
7193 : : PushTypeOfTree - pushes tree, gcc, to the stack and records the
7194 : : front end type.
7195 : : */
7196 : :
7197 : 322034 : extern "C" void M2ALU_PushTypeOfTree (unsigned int sym, tree gcc)
7198 : : {
7199 : 322034 : unsigned int t;
7200 : :
7201 : 322034 : t = SymbolTable_SkipType (SymbolTable_GetType (sym));
7202 : 322034 : if (t == SymbolTable_NulSym)
7203 : : {
7204 : 12 : M2ALU_PushIntegerTree (gcc);
7205 : : }
7206 : 322022 : else if (M2Base_IsComplexType (t))
7207 : : {
7208 : : /* avoid dangling else. */
7209 : 708 : M2ALU_PushComplexTree (gcc);
7210 : : }
7211 : 321314 : else if (SymbolTable_IsArray (t))
7212 : : {
7213 : : /* avoid dangling else. */
7214 : 0 : PushGCCArrayTree (gcc, t);
7215 : : }
7216 : 321314 : else if (SymbolTable_IsSet (t))
7217 : : {
7218 : : /* avoid dangling else. */
7219 : 18 : PushGCCSetTree (gcc, t);
7220 : : }
7221 : 321296 : else if (SymbolTable_IsRecord (t))
7222 : : {
7223 : : /* avoid dangling else. */
7224 : 0 : PushGCCRecordTree (gcc, t);
7225 : : }
7226 : 321296 : else if (M2Base_IsRealType (t))
7227 : : {
7228 : : /* avoid dangling else. */
7229 : 1158 : M2ALU_PushRealTree (gcc);
7230 : : }
7231 : : else
7232 : : {
7233 : : /* avoid dangling else. */
7234 : 320138 : M2ALU_PushIntegerTree (gcc);
7235 : : }
7236 : 322034 : }
7237 : :
7238 : 14232 : extern "C" void _M2_M2ALU_init (__attribute__((unused)) int argc, __attribute__((unused)) char *argv[], __attribute__((unused)) char *envp[])
7239 : : {
7240 : 14232 : Init ();
7241 : 14232 : }
7242 : :
7243 : 0 : extern "C" void _M2_M2ALU_fini (__attribute__((unused)) int argc, __attribute__((unused)) char *argv[], __attribute__((unused)) char *envp[])
7244 : : {
7245 : 0 : }
|
