Branch data Line data Source code
1 : : /* do not edit automatically generated by mc from P2SymBuild. */
2 : : /* P2SymBuild.mod pass 2 symbol creation.
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 : : #if defined(__cplusplus)
43 : : # undef NULL
44 : : # define NULL 0
45 : : #endif
46 : : #define _P2SymBuild_C
47 : :
48 : : #include "GP2SymBuild.h"
49 : : # include "Glibc.h"
50 : : # include "GNameKey.h"
51 : : # include "GStrLib.h"
52 : : # include "GM2Debug.h"
53 : : # include "GM2LexBuf.h"
54 : : # include "GM2Error.h"
55 : : # include "GDynamicStrings.h"
56 : : # include "GFormatStrings.h"
57 : : # include "GM2Printf.h"
58 : : # include "GM2StackWord.h"
59 : : # include "GM2Options.h"
60 : : # include "GStrIO.h"
61 : : # include "GM2Base.h"
62 : : # include "GStorage.h"
63 : : # include "Ggcctypes.h"
64 : : # include "GM2Reserved.h"
65 : : # include "GM2MetaError.h"
66 : : # include "GFifoQueue.h"
67 : : # include "GSymbolTable.h"
68 : : # include "GM2Batch.h"
69 : : # include "GM2Quads.h"
70 : : # include "GM2Comp.h"
71 : : # include "GM2Const.h"
72 : : # include "GM2Students.h"
73 : :
74 : : # define Debugging false
75 : : static unsigned int alignTypeNo;
76 : : static unsigned int castType;
77 : : static M2Const_constType type;
78 : : static unsigned int RememberedConstant;
79 : : static M2StackWord_StackOfWord RememberStack;
80 : : static M2StackWord_StackOfWord TypeStack;
81 : : static unsigned int curModuleSym;
82 : : static unsigned int curBeginTok;
83 : : static unsigned int curFinallyTok;
84 : : static unsigned int curStartTok;
85 : : static unsigned int curEndTok;
86 : : static M2StackWord_StackOfWord BlockStack;
87 : :
88 : : /*
89 : : BlockStart - tokno is the module/procedure/implementation/definition token
90 : : */
91 : :
92 : : extern "C" void P2SymBuild_BlockStart (unsigned int tokno);
93 : :
94 : : /*
95 : : BlockEnd - declare module ctor/init/fini/dep procedures.
96 : : */
97 : :
98 : : extern "C" void P2SymBuild_BlockEnd (unsigned int tokno);
99 : :
100 : : /*
101 : : BlockBegin - assign curBeginTok to tokno.
102 : : */
103 : :
104 : : extern "C" void P2SymBuild_BlockBegin (unsigned int tokno);
105 : :
106 : : /*
107 : : BlockFinally - assign curFinallyTok to tokno.
108 : : */
109 : :
110 : : extern "C" void P2SymBuild_BlockFinally (unsigned int tokno);
111 : : extern "C" void P2SymBuild_P2StartBuildDefModule (void);
112 : : extern "C" void P2SymBuild_P2EndBuildDefModule (void);
113 : : extern "C" void P2SymBuild_P2StartBuildImplementationModule (void);
114 : : extern "C" void P2SymBuild_P2EndBuildImplementationModule (void);
115 : : extern "C" void P2SymBuild_P2StartBuildProgramModule (void);
116 : : extern "C" void P2SymBuild_P2EndBuildProgramModule (void);
117 : :
118 : : /*
119 : : StartBuildInnerModule - Creates an Inner module and starts
120 : : a new scope.
121 : :
122 : : The Stack is expected:
123 : :
124 : : Entry Exit
125 : :
126 : : Ptr -> <- Ptr
127 : : +------------+ +-----------+
128 : : | NameStart | | NameStart |
129 : : |------------| |-----------|
130 : :
131 : : */
132 : :
133 : : extern "C" void P2SymBuild_StartBuildInnerModule (void);
134 : :
135 : : /*
136 : : EndBuildInnerModule - Destroys the Inner module scope and
137 : : checks for correct name.
138 : :
139 : : The Stack is expected:
140 : :
141 : : Entry Exit
142 : :
143 : : Ptr ->
144 : : +------------+ +-----------+
145 : : | NameEnd | | |
146 : : |------------| |-----------|
147 : : | NameStart | | | <- Ptr
148 : : |------------| |-----------|
149 : : */
150 : :
151 : : extern "C" void P2SymBuild_EndBuildInnerModule (void);
152 : :
153 : : /*
154 : : BuildImportOuterModule - Builds imported identifiers into an outer module
155 : : from a definition module.
156 : :
157 : : The Stack is expected:
158 : :
159 : : Entry OR Entry
160 : :
161 : : Ptr -> Ptr ->
162 : : +------------+ +-----------+
163 : : | # | | # |
164 : : |------------| |-----------|
165 : : | Id1 | | Id1 |
166 : : |------------| |-----------|
167 : : . . . .
168 : : . . . .
169 : : . . . .
170 : : |------------| |-----------|
171 : : | Id# | | Id# |
172 : : |------------| |-----------|
173 : : | ImportTok | | Ident |
174 : : |------------| |-----------|
175 : :
176 : : IMPORT Id1, .. Id# ; FROM Ident IMPORT Id1 .. Id# ;
177 : :
178 : :
179 : : Exit
180 : :
181 : : All above stack discarded
182 : : */
183 : :
184 : : extern "C" void P2SymBuild_BuildImportOuterModule (void);
185 : :
186 : : /*
187 : : BuildExportOuterModule - Builds exported identifiers from an outer module
188 : : to the outside world of library modules.
189 : :
190 : : The Stack is expected:
191 : :
192 : : Entry OR Entry
193 : :
194 : : Ptr -> Ptr ->
195 : : +------------+ +--------------+
196 : : | # | | # |
197 : : |------------| |--------------|
198 : : | Id1 | | Id1 |
199 : : |------------| |--------------|
200 : : . . . .
201 : : . . . .
202 : : . . . .
203 : : |------------| |--------------|
204 : : | Id# | | Id# |
205 : : |------------| |--------------|
206 : : | ExportTok | | QualifiedTok |
207 : : |------------| |--------------|
208 : :
209 : : EXPORT Id1, .. Id# ; EXPORT QUALIFIED Id1 .. Id# ;
210 : :
211 : : Error Condition
212 : :
213 : :
214 : : Exit
215 : :
216 : : All above stack discarded
217 : : */
218 : :
219 : : extern "C" void P2SymBuild_BuildExportOuterModule (void);
220 : :
221 : : /*
222 : : BuildImportInnerModule - Builds imported identifiers into an inner module
223 : : from the last level of module.
224 : :
225 : : The Stack is expected:
226 : :
227 : : Entry OR Entry
228 : :
229 : : Ptr -> Ptr ->
230 : : +------------+ +-----------+
231 : : | # | | # |
232 : : |------------| |-----------|
233 : : | Id1 | | Id1 |
234 : : |------------| |-----------|
235 : : . . . .
236 : : . . . .
237 : : . . . .
238 : : |------------| |-----------|
239 : : | Id# | | Id# |
240 : : |------------| |-----------|
241 : : | ImportTok | | Ident |
242 : : |------------| |-----------|
243 : :
244 : : IMPORT Id1, .. Id# ; FROM Ident IMPORT Id1 .. Id# ;
245 : :
246 : : Exit
247 : :
248 : : All above stack discarded
249 : : */
250 : :
251 : : extern "C" void P2SymBuild_BuildImportInnerModule (void);
252 : :
253 : : /*
254 : : BuildExportInnerModule - Builds exported identifiers from an inner module
255 : : to the next layer module.
256 : :
257 : : The Stack is expected:
258 : :
259 : : Entry OR Entry
260 : :
261 : : Ptr -> Ptr ->
262 : : +------------+ +--------------+
263 : : | # | | # |
264 : : |------------| |--------------|
265 : : | Id1 | | Id1 |
266 : : |------------| |--------------|
267 : : . . . .
268 : : . . . .
269 : : . . . .
270 : : |------------| |--------------|
271 : : | Id# | | Id# |
272 : : |------------| |--------------|
273 : : | ExportTok | | QualifiedTok |
274 : : |------------| |--------------|
275 : :
276 : : EXPORT Id1, .. Id# ; EXPORT QUALIFIED Id1 .. Id# ;
277 : :
278 : :
279 : : Exit
280 : :
281 : : All above stack discarded
282 : : */
283 : :
284 : : extern "C" void P2SymBuild_BuildExportInnerModule (void);
285 : :
286 : : /*
287 : : BuildNumber - Converts a number into a symbol.
288 : :
289 : :
290 : : Stack
291 : :
292 : : Entry Exit
293 : :
294 : : Ptr -> <- Ptr
295 : : +------------+ +-------------------+
296 : : | Name | tok | | Sym | Type | tok |
297 : : |------------+ |-------------------|
298 : : */
299 : :
300 : : extern "C" void P2SymBuild_BuildNumber (void);
301 : :
302 : : /*
303 : : BuildString - Converts a string into a symbol.
304 : :
305 : :
306 : : Stack
307 : :
308 : : Entry Exit
309 : :
310 : : Ptr -> <- Ptr
311 : : +-------------+ +--------------------+
312 : : | Name | | tok| | Sym | NulSym | tok |
313 : : |-------------+ |--------------------|
314 : : */
315 : :
316 : : extern "C" void P2SymBuild_BuildString (void);
317 : :
318 : : /*
319 : : BuildConst - builds a constant.
320 : : Stack
321 : :
322 : : Entry Exit
323 : :
324 : : Ptr ->
325 : : +------------+
326 : : | Name |
327 : : |------------+ <- Ptr
328 : : */
329 : :
330 : : extern "C" void P2SymBuild_BuildConst (void);
331 : :
332 : : /*
333 : : StartBuildEnumeration - Builds an Enumeration type Type.
334 : :
335 : :
336 : : Stack
337 : :
338 : : Entry Exit
339 : :
340 : : Ptr ->
341 : : +------------+
342 : : | # |
343 : : |------------|
344 : : | en 1 |
345 : : |------------|
346 : : | en 2 |
347 : : |------------|
348 : : . .
349 : : . .
350 : : . . <- Ptr
351 : : |------------| +------------+
352 : : | en # | | Type |
353 : : |------------| |------------|
354 : : | Name | | Name |
355 : : |------------| |------------|
356 : : */
357 : :
358 : : extern "C" void P2SymBuild_StartBuildEnumeration (void);
359 : :
360 : : /*
361 : : BuildSubrange - Builds a Subrange type Symbol, the base type can also be
362 : : supplied if known.
363 : :
364 : : Stack
365 : :
366 : : Entry Exit
367 : :
368 : :
369 : : <- Ptr
370 : : +------------+
371 : : Ptr -> | Type |
372 : : +------------+ |------------|
373 : : | Name | | Name |
374 : : |------------| |------------|
375 : : */
376 : :
377 : : extern "C" void P2SymBuild_BuildSubrange (unsigned int Base);
378 : :
379 : : /*
380 : : BuildAligned - builds an alignment constant symbol which is placed onto
381 : : the stack. It expects the ident ALIGNED to be on the
382 : : stack.
383 : :
384 : : Stack
385 : :
386 : : Entry Exit
387 : :
388 : :
389 : : Ptr -> <- Ptr
390 : : +---------------+ +-----------------+
391 : : | bytealignment | | AlignmentConst |
392 : : +---------------+ |-----------------|
393 : : */
394 : :
395 : : extern "C" void P2SymBuild_BuildAligned (void);
396 : :
397 : : /*
398 : : BuildVarAlignment - the AlignmentConst is either a temporary or NulSym.
399 : : A type may only have one alignment value and
400 : : error checking is performed.
401 : :
402 : : Stack
403 : :
404 : : Entry Exit
405 : :
406 : :
407 : : Ptr ->
408 : : +-----------------+
409 : : | AlignmentConst | <- Ptr
410 : : |-----------------| +------------------+
411 : : | Type | | Type | TypeName |
412 : : |-----------------| |------------------|
413 : : */
414 : :
415 : : extern "C" void P2SymBuild_BuildVarAlignment (void);
416 : :
417 : : /*
418 : : BuildTypeAlignment - the AlignmentConst is either a temporary or NulSym.
419 : : In the case of NulSym it is popped from the stack
420 : : and the procedure returns. Otherwise the temporary
421 : : is popped and recorded as the alignment value for this
422 : : type. A type may only have one alignment value and
423 : : error checking is performed.
424 : :
425 : : Stack
426 : :
427 : : Entry Exit
428 : :
429 : :
430 : : Ptr ->
431 : : +-----------------+
432 : : | AlignmentConst |
433 : : |-----------------|
434 : : | Type | Empty
435 : : |-----------------|
436 : : */
437 : :
438 : : extern "C" void P2SymBuild_BuildTypeAlignment (void);
439 : : extern "C" void P2SymBuild_P2BuildDefaultFieldAlignment (void);
440 : :
441 : : /*
442 : : BuildPragmaConst - pushes a constant to the stack and stores it away into the
443 : : const fifo queue ready for pass 3.
444 : : */
445 : :
446 : : extern "C" void P2SymBuild_BuildPragmaConst (void);
447 : :
448 : : /*
449 : : BuildVariable - Builds variables listed in an IdentList with a Type.
450 : :
451 : : Stack
452 : :
453 : : Entry Exit
454 : :
455 : : Ptr ->
456 : : +------------+ +------------+
457 : : | Type | Name| | |
458 : : |------------| |------------|
459 : : | # | | |
460 : : |------------| |------------|
461 : : | Ident 1 | | |
462 : : |------------| |------------|
463 : : | Ident 2 | | |
464 : : |------------| |------------|
465 : : . . . .
466 : : . . . .
467 : : . . . .
468 : : |------------| |------------|
469 : : | Ident # | | | <- Ptr
470 : : |------------| |------------|
471 : :
472 : : Empty
473 : : */
474 : :
475 : : extern "C" void P2SymBuild_BuildVariable (void);
476 : :
477 : : /*
478 : : BuildType - Builds a Type.
479 : :
480 : :
481 : : Stack
482 : :
483 : : Entry Exit
484 : :
485 : : Ptr ->
486 : : +------------+
487 : : | Type | <- Ptr
488 : : |------------| +---------------+
489 : : | Name | | Type | Name |
490 : : |------------| |---------------|
491 : :
492 : : Empty
493 : : */
494 : :
495 : : extern "C" void P2SymBuild_BuildType (void);
496 : :
497 : : /*
498 : : StartBuildFormalParameters - Initialises the quadruple stack for
499 : : Formal Parameters.
500 : :
501 : : The Stack:
502 : :
503 : : Entry Exit
504 : :
505 : : <- Ptr
506 : : +------------+
507 : : Empty | 0 |
508 : : |------------|
509 : : */
510 : :
511 : : extern "C" void P2SymBuild_StartBuildFormalParameters (void);
512 : :
513 : : /*
514 : : EndBuildFormalParameters - Resets the quadruple stack after building
515 : : Formal Parameters.
516 : :
517 : : The Stack:
518 : :
519 : : Entry Exit
520 : :
521 : : Ptr ->
522 : : +------------+
523 : : | NoOfParam | <- Ptr
524 : : |------------| +------------+
525 : : | ProcSym | | ProcSym |
526 : : |------------| |------------|
527 : : */
528 : :
529 : : extern "C" void P2SymBuild_EndBuildFormalParameters (void);
530 : :
531 : : /*
532 : : BuildProcedureHeading - Builds a procedure heading for the definition
533 : : module procedures.
534 : :
535 : : Operation only performed if compiling a
536 : : definition module.
537 : :
538 : : The Stack:
539 : :
540 : : Entry Exit
541 : :
542 : : Ptr ->
543 : : +------------+
544 : : | ProcSym |
545 : : |------------|
546 : : | NameStart |
547 : : |------------|
548 : : Empty
549 : :
550 : : */
551 : :
552 : : extern "C" void P2SymBuild_BuildProcedureHeading (void);
553 : :
554 : : /*
555 : : BuildFunction - Builds a procedures return type.
556 : : Procedure becomes a function.
557 : :
558 : : The Stack:
559 : :
560 : : Entry Exit
561 : :
562 : : Ptr ->
563 : : +------------+
564 : : | TypeSym | <- Ptr
565 : : |------------| +------------+
566 : : | ProcSym | | ProcSym |
567 : : |------------| |------------|
568 : : */
569 : :
570 : : extern "C" void P2SymBuild_BuildFunction (void);
571 : :
572 : : /*
573 : : BuildOptFunction - Builds a procedures optional return type.
574 : : Procedure becomes a function and the user
575 : : can either call it as a function or a procedure.
576 : :
577 : : The Stack:
578 : :
579 : : Entry Exit
580 : :
581 : : Ptr ->
582 : : +------------+
583 : : | TypeSym | <- Ptr
584 : : |------------| +------------+
585 : : | ProcSym | | ProcSym |
586 : : |------------| |------------|
587 : : */
588 : :
589 : : extern "C" void P2SymBuild_BuildOptFunction (void);
590 : :
591 : : /*
592 : : BuildFPSection - Builds a Formal Parameter in a procedure.
593 : :
594 : : The Stack:
595 : :
596 : : Entry Exit
597 : :
598 : : Ptr ->
599 : : +------------+
600 : : | ParamTotal |
601 : : |------------|
602 : : | TypeSym |
603 : : |------------|
604 : : | Array/Nul |
605 : : |------------|
606 : : | NoOfIds |
607 : : |------------|
608 : : | Id 1 |
609 : : |------------|
610 : : . .
611 : : . .
612 : : . .
613 : : |------------|
614 : : | Id n | <- Ptr
615 : : |------------| +------------+
616 : : | Var / Nul | | ParamTotal |
617 : : |------------| |------------|
618 : : | ProcSym | | ProcSym |
619 : : |------------| |------------|
620 : : */
621 : :
622 : : extern "C" void P2SymBuild_BuildFPSection (void);
623 : :
624 : : /*
625 : : BuildVarArgs - indicates that the ProcSym takes varargs
626 : : after ParamTotal.
627 : : <- Ptr
628 : : +------------+ +------------+
629 : : | ParamTotal | | ParamTotal |
630 : : |------------| |------------|
631 : : | ProcSym | | ProcSym |
632 : : |------------| |------------|
633 : :
634 : : */
635 : :
636 : : extern "C" void P2SymBuild_BuildVarArgs (void);
637 : :
638 : : /*
639 : : BuildFormalVarArgs - indicates that the procedure type takes varargs.
640 : :
641 : : <- Ptr
642 : : +------------+ +------------+
643 : : | ProcSym | | ProcSym |
644 : : |------------| |------------|
645 : :
646 : : */
647 : :
648 : : extern "C" void P2SymBuild_BuildFormalVarArgs (void);
649 : :
650 : : /*
651 : : BuildOptArg - indicates that the ProcSym takes a single optarg
652 : : after ParamTotal.
653 : :
654 : : <- Ptr
655 : : +------------+ +------------+
656 : : | ParamTotal | | ParamTotal |
657 : : |------------| |------------|
658 : : | ProcSym | | ProcSym |
659 : : |------------| |------------|
660 : : */
661 : :
662 : : extern "C" void P2SymBuild_BuildOptArg (void);
663 : :
664 : : /*
665 : : StartBuildProcedure - Builds a Procedure.
666 : :
667 : : The Stack:
668 : :
669 : : Entry Exit
670 : :
671 : : <- Ptr
672 : : +------------+
673 : : Ptr -> | ProcSym |
674 : : +------------+ |------------|
675 : : | Name | | Name |
676 : : |------------| |------------|
677 : : */
678 : :
679 : : extern "C" void P2SymBuild_StartBuildProcedure (void);
680 : :
681 : : /*
682 : : EndBuildProcedure - Ends building a Procedure.
683 : : It checks the start procedure name matches the end
684 : : procedure name.
685 : :
686 : : The Stack:
687 : :
688 : : (Procedure Not Defined in definition module)
689 : :
690 : : Entry Exit
691 : :
692 : : Ptr ->
693 : : +------------+
694 : : | NameEnd |
695 : : |------------|
696 : : | ProcSym |
697 : : |------------|
698 : : | NameStart |
699 : : |------------|
700 : : Empty
701 : : */
702 : :
703 : : extern "C" void P2SymBuild_EndBuildProcedure (void);
704 : :
705 : : /*
706 : : EndBuildForward - ends building a forward procedure.
707 : : */
708 : :
709 : : extern "C" void P2SymBuild_EndBuildForward (void);
710 : :
711 : : /*
712 : : BuildNoReturnAttribute - provide an interface to the symbol table module.
713 : : */
714 : :
715 : : extern "C" void P2SymBuild_BuildNoReturnAttribute (void);
716 : :
717 : : /*
718 : : CheckProcedure - checks to see that the top of stack procedure
719 : : has not been declared as a procedure function.
720 : :
721 : : The Stack:
722 : :
723 : : Entry Exit
724 : :
725 : : Ptr -> <- Ptr
726 : : +------------+ +------------+
727 : : | ProcSym | | ProcSym |
728 : : |------------| |------------|
729 : : */
730 : :
731 : : extern "C" void P2SymBuild_CheckProcedure (void);
732 : :
733 : : /*
734 : : BuildPointerType - builds a pointer type.
735 : : The Stack:
736 : :
737 : : Entry Exit
738 : : ===== ====
739 : :
740 : :
741 : : Ptr -> <- Ptr
742 : : +------------+ +-------------+
743 : : | Type | | PointerType |
744 : : |------------| |-------------|
745 : : | Name | | Name |
746 : : |------------| |-------------|
747 : : */
748 : :
749 : : extern "C" void P2SymBuild_BuildPointerType (unsigned int pointerpos);
750 : :
751 : : /*
752 : : BuildSetType - builds a set type.
753 : : The Stack:
754 : :
755 : : Entry Exit
756 : : ===== ====
757 : :
758 : :
759 : : Ptr -> <- Ptr
760 : : +------------+ +-------------+
761 : : | Type | | SetType |
762 : : |------------| |-------------|
763 : : | Name | | Name |
764 : : |------------| |-------------|
765 : : */
766 : :
767 : : extern "C" void P2SymBuild_BuildSetType (unsigned int setpos, bool ispacked);
768 : :
769 : : /*
770 : : BuildRecord - Builds a record type.
771 : : The Stack:
772 : :
773 : : Entry Exit
774 : : ===== ====
775 : :
776 : :
777 : : <- Ptr
778 : : +-----------+
779 : : Ptr -> | RecordSym |
780 : : +------------------+ |-----------|
781 : : | Name | | Name |
782 : : |------------------| |-----------|
783 : : */
784 : :
785 : : extern "C" void P2SymBuild_BuildRecord (void);
786 : :
787 : : /*
788 : : BuildFieldRecord - Builds a field into a record sym.
789 : : The Stack:
790 : :
791 : :
792 : : Entry Exit
793 : : ===== ====
794 : :
795 : : Ptr ->
796 : : +-------------+
797 : : | NoOfPragmas |
798 : : |-------------|
799 : : | Const1 |
800 : : |-------------|
801 : : | PragmaName1 |
802 : : |-------------|
803 : : | Type | Name |
804 : : |-------------|
805 : : | n |
806 : : |-------------|
807 : : | Id 1 |
808 : : |-------------|
809 : : . .
810 : : . .
811 : : . .
812 : : |-------------|
813 : : | Id n | <- Ptr
814 : : |-------------| +-------------+
815 : : | RecordSym | | RecordSym |
816 : : |-------------| |-------------|
817 : : | RecordName | | RecordName |
818 : : |-------------| |-------------|
819 : : */
820 : :
821 : : extern "C" void P2SymBuild_BuildFieldRecord (void);
822 : :
823 : : /*
824 : : StartBuildVarient - Builds a varient symbol on top of a record sym.
825 : : The Stack:
826 : :
827 : :
828 : : Entry Exit
829 : : ===== ====
830 : :
831 : : <- Ptr
832 : : +-------------+
833 : : Ptr -> | VarientSym |
834 : : +-------------+ |-------------|
835 : : | RecordSym | | RecordSym |
836 : : |-------------| |-------------|
837 : : | RecordName | | RecordName |
838 : : |-------------| |-------------|
839 : : */
840 : :
841 : : extern "C" void P2SymBuild_StartBuildVarient (void);
842 : :
843 : : /*
844 : : EndBuildVarient - Removes the varient symbol from the stack.
845 : : The Stack:
846 : :
847 : : Entry Exit
848 : : ===== ====
849 : :
850 : : Ptr ->
851 : : +-------------+
852 : : | VarientSym | <- Ptr
853 : : |-------------| +-------------+
854 : : | RecordSym | | RecordSym |
855 : : |-------------| |-------------|
856 : : | RecordName | | RecordName |
857 : : |-------------| |-------------|
858 : : */
859 : :
860 : : extern "C" void P2SymBuild_EndBuildVarient (void);
861 : :
862 : : /*
863 : : BuildVarientSelector - Builds a field into a record sym.
864 : : The Stack:
865 : :
866 : :
867 : : Entry Exit
868 : : ===== ====
869 : :
870 : : Ptr ->
871 : : +-------------+
872 : : | Type |
873 : : |-------------|
874 : : | Tag | <- Ptr
875 : : |-------------| +-------------+
876 : : | RecordSym | | RecordSym |
877 : : |-------------| |-------------|
878 : : */
879 : :
880 : : extern "C" void P2SymBuild_BuildVarientSelector (void);
881 : :
882 : : /*
883 : : StartBuildVarientFieldRecord - Builds a varient field into a varient sym.
884 : : The Stack:
885 : :
886 : :
887 : : Entry Exit
888 : : ===== ====
889 : :
890 : : <- Ptr
891 : : +-------------+
892 : : Ptr -> | VarientField|
893 : : +-------------+ |-------------|
894 : : | VarientSym | | VarientSym |
895 : : |-------------| |-------------|
896 : : */
897 : :
898 : : extern "C" void P2SymBuild_StartBuildVarientFieldRecord (void);
899 : :
900 : : /*
901 : : EndBuildVarientFieldRecord - Removes a varient field from the stack.
902 : : The Stack:
903 : :
904 : :
905 : : Entry Exit
906 : : ===== ====
907 : :
908 : : Ptr ->
909 : : +-------------+
910 : : | VarientField| <- Ptr
911 : : |-------------| +-------------+
912 : : | VarientSym | | VarientSym |
913 : : |-------------| |-------------|
914 : : */
915 : :
916 : : extern "C" void P2SymBuild_EndBuildVarientFieldRecord (void);
917 : :
918 : : /*
919 : : BuildNulName - Pushes a NulName onto the top of the stack.
920 : : The Stack:
921 : :
922 : :
923 : : Entry Exit
924 : :
925 : : <- Ptr
926 : : Empty +------------+
927 : : | NulName |
928 : : |------------|
929 : : */
930 : :
931 : : extern "C" void P2SymBuild_BuildNulName (void);
932 : :
933 : : /*
934 : : BuildTypeEnd - Pops the type Type and Name.
935 : : The Stack:
936 : :
937 : :
938 : : Entry Exit
939 : :
940 : :
941 : : Ptr ->
942 : : +-------------+
943 : : | Type | Name | Empty
944 : : |-------------|
945 : : */
946 : :
947 : : extern "C" void P2SymBuild_BuildTypeEnd (void);
948 : :
949 : : /*
950 : : StartBuildArray - Builds an array type.
951 : : The Stack:
952 : :
953 : : Entry Exit
954 : : ===== ====
955 : :
956 : : <- Ptr
957 : : +-----------+
958 : : Ptr -> | ArraySym |
959 : : +------------+ |-----------|
960 : : | Name | | Name |
961 : : |------------| |-----------|
962 : : */
963 : :
964 : : extern "C" void P2SymBuild_StartBuildArray (void);
965 : :
966 : : /*
967 : : EndBuildArray - Builds an array type.
968 : : The Stack:
969 : :
970 : : Entry Exit
971 : : ===== ====
972 : :
973 : : Ptr ->
974 : : +------------+
975 : : | TypeSym | <- Ptr
976 : : |------------| +------------+
977 : : | ArraySym | | ArraySym |
978 : : |------------| |------------|
979 : : | Name | | Name |
980 : : |------------| |------------|
981 : : */
982 : :
983 : : extern "C" void P2SymBuild_EndBuildArray (void);
984 : :
985 : : /*
986 : : BuildFieldArray - Builds a field into an array sym.
987 : : The Stack:
988 : :
989 : :
990 : : Entry Exit
991 : : ===== ====
992 : :
993 : : Ptr ->
994 : : +-------------+
995 : : | Type | Name | <- Ptr
996 : : |-------------| +-------------+
997 : : | ArraySym | | ArraySym |
998 : : |-------------| |-------------|
999 : : | ArrayName | | ArrayName |
1000 : : |-------------| |-------------|
1001 : : */
1002 : :
1003 : : extern "C" void P2SymBuild_BuildFieldArray (void);
1004 : :
1005 : : /*
1006 : : BuildArrayComma - converts ARRAY [..], [..] OF into ARRAY [..] OF ARRAY [..]
1007 : :
1008 : :
1009 : : Ptr -> <- Ptr
1010 : : +-------------+ +-------------+
1011 : : | ArraySym1 | | ArraySym2 |
1012 : : |-------------| |-------------|
1013 : : | ArrayName | | ArrayName |
1014 : : |-------------| |-------------|
1015 : : */
1016 : :
1017 : : extern "C" void P2SymBuild_BuildArrayComma (void);
1018 : :
1019 : : /*
1020 : : BuildProcedureType - builds a procedure type symbol.
1021 : : The Stack:
1022 : :
1023 : :
1024 : : <- Ptr
1025 : : +-------------+
1026 : : Ptr -> | ProcTypeSym |
1027 : : +-------------+ |-------------|
1028 : : | Name | | Name |
1029 : : |-------------| |-------------|
1030 : : */
1031 : :
1032 : : extern "C" void P2SymBuild_BuildProcedureType (void);
1033 : :
1034 : : /*
1035 : : BuildFormalType - Builds a Formal Parameter in a procedure type.
1036 : :
1037 : : The Stack:
1038 : :
1039 : : Entry Exit
1040 : :
1041 : : Ptr ->
1042 : : +------------+
1043 : : | TypeSym |
1044 : : |------------|
1045 : : | Array/Nul |
1046 : : |------------|
1047 : : | Var / Nul | <- Ptr
1048 : : |------------| +--------------+
1049 : : | ProcTypeSym| | ProcTypeSym |
1050 : : |------------| |--------------|
1051 : : */
1052 : :
1053 : : extern "C" void P2SymBuild_BuildFormalType (void);
1054 : :
1055 : : /*
1056 : : SeenUnknown - sets the operand type to unknown.
1057 : : */
1058 : :
1059 : : extern "C" void P2SymBuild_SeenUnknown (void);
1060 : :
1061 : : /*
1062 : : SeenCast - sets the operand type to cast.
1063 : : */
1064 : :
1065 : : extern "C" void P2SymBuild_SeenCast (unsigned int sym);
1066 : :
1067 : : /*
1068 : : SeenSet - sets the operand type to set.
1069 : : */
1070 : :
1071 : : extern "C" void P2SymBuild_SeenSet (void);
1072 : :
1073 : : /*
1074 : : SeenConstructor - sets the operand type to constructor.
1075 : : */
1076 : :
1077 : : extern "C" void P2SymBuild_SeenConstructor (void);
1078 : :
1079 : : /*
1080 : : SeenArray - sets the operand type to array.
1081 : : */
1082 : :
1083 : : extern "C" void P2SymBuild_SeenArray (void);
1084 : :
1085 : : /*
1086 : : SeenString - sets the operand type to string.
1087 : : */
1088 : :
1089 : : extern "C" void P2SymBuild_SeenString (void);
1090 : :
1091 : : /*
1092 : : SeenBoolean - sets the operand type to a BOOLEAN.
1093 : : */
1094 : :
1095 : : extern "C" void P2SymBuild_SeenBoolean (void);
1096 : :
1097 : : /*
1098 : : SeenZType - sets the operand type to a Z type.
1099 : : */
1100 : :
1101 : : extern "C" void P2SymBuild_SeenZType (void);
1102 : :
1103 : : /*
1104 : : SeenRType - sets the operand type to a R type.
1105 : : */
1106 : :
1107 : : extern "C" void P2SymBuild_SeenRType (void);
1108 : :
1109 : : /*
1110 : : SeenCType - sets the operand type to a C type.
1111 : : */
1112 : :
1113 : : extern "C" void P2SymBuild_SeenCType (void);
1114 : :
1115 : : /*
1116 : : DetermineType - assigns the top of stack symbol with the type of
1117 : : constant expression, if known.
1118 : : */
1119 : :
1120 : : extern "C" void P2SymBuild_DetermineType (void);
1121 : :
1122 : : /*
1123 : : PushType -
1124 : : */
1125 : :
1126 : : extern "C" void P2SymBuild_PushType (void);
1127 : :
1128 : : /*
1129 : : PopType -
1130 : : */
1131 : :
1132 : : extern "C" void P2SymBuild_PopType (void);
1133 : :
1134 : : /*
1135 : : PushRememberConstant -
1136 : : */
1137 : :
1138 : : extern "C" void P2SymBuild_PushRememberConstant (void);
1139 : :
1140 : : /*
1141 : : PopRememberConstant -
1142 : : */
1143 : :
1144 : : extern "C" void P2SymBuild_PopRememberConstant (void);
1145 : :
1146 : : /*
1147 : : RememberConstant -
1148 : : */
1149 : :
1150 : : extern "C" void P2SymBuild_RememberConstant (unsigned int sym);
1151 : : static void stop (void);
1152 : :
1153 : : /*
1154 : : Debug - call stop if symbol name is name.
1155 : : */
1156 : :
1157 : : static void Debug (unsigned int sym, const char *name_, unsigned int _name_high);
1158 : :
1159 : : /*
1160 : : propageteTokenPosition - if laterTokPos is unknown then return knownTokPos.
1161 : : else return laterTokPos.
1162 : : */
1163 : :
1164 : : static unsigned int propageteTokenPosition (unsigned int knownTokPos, unsigned int laterTokPos);
1165 : :
1166 : : /*
1167 : : PushBlock - push the block variables to the block stack.
1168 : : */
1169 : :
1170 : : static void PushBlock (unsigned int tokno);
1171 : :
1172 : : /*
1173 : : PopBlock - pop the block variables from the block stack.
1174 : : */
1175 : :
1176 : : static void PopBlock (void);
1177 : :
1178 : : /*
1179 : : BuildFormalParameterSection - Builds a Formal Parameter in a procedure.
1180 : :
1181 : : The Stack:
1182 : :
1183 : : Entry and Exit
1184 : :
1185 : : Ptr -> <- Ptr
1186 : : +------------+
1187 : : | ParamTotal |
1188 : : |------------|
1189 : : | TypeSym |
1190 : : |------------|
1191 : : | Array/Nul |
1192 : : |------------|
1193 : : | NoOfIds |
1194 : : |------------|
1195 : : | Id 1 |
1196 : : |------------|
1197 : : . .
1198 : : . .
1199 : : . .
1200 : : |------------|
1201 : : | Id n |
1202 : : |------------|
1203 : : | Var / Nul |
1204 : : |------------|
1205 : : | ProcSym |
1206 : : |------------|
1207 : : */
1208 : :
1209 : : static void BuildFormalParameterSection (SymbolTable_ProcedureKind kind);
1210 : :
1211 : : /*
1212 : : CheckFormalParameterSection - Checks a Formal Parameter in a procedure.
1213 : : The stack is unaffected.
1214 : :
1215 : : The Stack:
1216 : :
1217 : : Entry and Exit
1218 : :
1219 : : Ptr ->
1220 : : +------------+
1221 : : | ParamTotal |
1222 : : |------------|
1223 : : | TypeSym |
1224 : : |------------|
1225 : : | Array/Nul |
1226 : : |------------|
1227 : : | NoOfIds |
1228 : : |------------|
1229 : : | Id 1 |
1230 : : |------------|
1231 : : . .
1232 : : . .
1233 : : . .
1234 : : |------------|
1235 : : | Id n |
1236 : : |------------|
1237 : : | Var / Nul |
1238 : : |------------|
1239 : : | ProcSym |
1240 : : |------------|
1241 : : */
1242 : :
1243 : : static void CheckFormalParameterSection (SymbolTable_ProcedureKind curkind, SymbolTable_ProcedureKind prevkind);
1244 : :
1245 : : /*
1246 : : RemoveFPParameters - remove the FPSection parameters from the stack and
1247 : : increment the param total with the NoOfIds.
1248 : :
1249 : : The Stack:
1250 : :
1251 : : Entry Exit
1252 : :
1253 : : Ptr ->
1254 : : +------------+
1255 : : | ParamTotal |
1256 : : |------------|
1257 : : | TypeSym |
1258 : : |------------|
1259 : : | Array/Nul |
1260 : : |------------|
1261 : : | NoOfIds |
1262 : : |------------|
1263 : : | Id 1 |
1264 : : |------------|
1265 : : . .
1266 : : . .
1267 : : . .
1268 : : |------------|
1269 : : | Id n | <- Ptr
1270 : : |------------| +------------+
1271 : : | Var / Nul | | ParamTotal |
1272 : : |------------| |------------|
1273 : : | ProcSym | | ProcSym |
1274 : : |------------| |------------|
1275 : : */
1276 : :
1277 : : static void RemoveFPParameters (void);
1278 : :
1279 : : /*
1280 : : ParameterError - create two error strings chained together.
1281 : : */
1282 : :
1283 : : static void ParameterError (const char *FmtHeader_, unsigned int _FmtHeader_high, const char *PrevDesc_, unsigned int _PrevDesc_high, const char *CurDesc_, unsigned int _CurDesc_high, unsigned int ParamNo, unsigned int ProcSym, SymbolTable_ProcedureKind curkind, SymbolTable_ProcedureKind prevkind);
1284 : :
1285 : : /*
1286 : : ParameterMismatch - generate a parameter mismatch error between the current
1287 : : declaration at tok and a previous ProcSym declaration.
1288 : : NoOfPar is the current number of parameters.
1289 : : */
1290 : :
1291 : : static void ParameterMismatch (unsigned int tok, unsigned int ProcSym, unsigned int NoOfPar, SymbolTable_ProcedureKind prevkind, SymbolTable_ProcedureKind curkind);
1292 : :
1293 : : /*
1294 : : GetComparison - return a simple description from the result of
1295 : : a comparison between left and right.
1296 : : */
1297 : :
1298 : : static DynamicStrings_String GetComparison (unsigned int left, unsigned int right);
1299 : :
1300 : : /*
1301 : : ReturnTypeMismatch - generate two errors showing the return type mismatches between
1302 : : ProcSym and ReturnType at procedure location tok.
1303 : : */
1304 : :
1305 : : static void ReturnTypeMismatch (unsigned int curtok, unsigned int ProcSym, unsigned int CurRetType, unsigned int curtypetok, SymbolTable_ProcedureKind curkind, SymbolTable_ProcedureKind prevkind, unsigned int PrevRetType);
1306 : :
1307 : : /*
1308 : : CheckOptFunction - checks to see whether the optional return value
1309 : : has been set before and if it differs it will
1310 : : generate an error message. It will set the
1311 : : new value to isopt.
1312 : : */
1313 : :
1314 : : static void CheckOptFunction (unsigned int tok, unsigned int sym, SymbolTable_ProcedureKind kind, bool isopt);
1315 : :
1316 : : /*
1317 : : CheckProcedure - checks to see that the top of stack procedure
1318 : : has not been declared as a procedure function.
1319 : :
1320 : : The Stack:
1321 : :
1322 : : Entry Exit
1323 : :
1324 : : Ptr -> <- Ptr
1325 : : +------------+ +------------+
1326 : : | ProcSym | | ProcSym |
1327 : : |------------| |------------|
1328 : : */
1329 : :
1330 : : static void CheckProcedureReturn (unsigned int RetType, unsigned int typetok);
1331 : :
1332 : : /*
1333 : : HandleRecordFieldPragmas -
1334 : :
1335 : : Entry Exit
1336 : : ===== ====
1337 : :
1338 : : Ptr -> <- Ptr
1339 : :
1340 : : |-------------| |-------------|
1341 : : | Const1 | | Const1 |
1342 : : |-------------| |-------------|
1343 : : | PragmaName1 | | PragmaName1 |
1344 : : |-------------| |-------------|
1345 : : */
1346 : :
1347 : : static void HandleRecordFieldPragmas (unsigned int record, unsigned int field, unsigned int n);
1348 : :
1349 : : /*
1350 : : SaveRememberedConstructor -
1351 : : */
1352 : :
1353 : : static void SaveRememberedConstructor (void);
1354 : :
1355 : : /*
1356 : : GetSeenString - returns a string corresponding to, s.
1357 : : */
1358 : :
1359 : : static DynamicStrings_String GetSeenString (M2Const_constType s);
1360 : :
1361 : : /*
1362 : : SetTypeTo - attempts to set, type, to, s.
1363 : : */
1364 : :
1365 : : static void SetTypeTo (M2Const_constType s);
1366 : :
1367 : 0 : static void stop (void)
1368 : : {
1369 : 0 : }
1370 : :
1371 : :
1372 : : /*
1373 : : Debug - call stop if symbol name is name.
1374 : : */
1375 : :
1376 : 4853017 : static void Debug (unsigned int sym, const char *name_, unsigned int _name_high)
1377 : : {
1378 : 4853017 : char name[_name_high+1];
1379 : :
1380 : : /* make a local copy of each unbounded array. */
1381 : 4853017 : memcpy (name, name_, _name_high+1);
1382 : :
1383 : 4853017 : if ((NameKey_MakeKey ((const char *) name, _name_high)) == (SymbolTable_GetSymName (sym)))
1384 : : {
1385 : 4853017 : stop ();
1386 : : }
1387 : 4853017 : }
1388 : :
1389 : :
1390 : : /*
1391 : : propageteTokenPosition - if laterTokPos is unknown then return knownTokPos.
1392 : : else return laterTokPos.
1393 : : */
1394 : :
1395 : 127378 : static unsigned int propageteTokenPosition (unsigned int knownTokPos, unsigned int laterTokPos)
1396 : : {
1397 : 0 : if (laterTokPos == M2LexBuf_UnknownTokenNo)
1398 : : {
1399 : : return knownTokPos;
1400 : : }
1401 : : else
1402 : : {
1403 : 41413 : return laterTokPos;
1404 : : }
1405 : : /* static analysis guarentees a RETURN statement will be used before here. */
1406 : : __builtin_unreachable ();
1407 : : }
1408 : :
1409 : :
1410 : : /*
1411 : : PushBlock - push the block variables to the block stack.
1412 : : */
1413 : :
1414 : 63707 : static void PushBlock (unsigned int tokno)
1415 : : {
1416 : 63707 : M2StackWord_PushWord (BlockStack, curStartTok); /* module/implementation/definition/procedure token pos. */
1417 : 63707 : M2StackWord_PushWord (BlockStack, curBeginTok); /* BEGIN keyword pos. */
1418 : 63707 : M2StackWord_PushWord (BlockStack, curEndTok); /* END keyword pos. */
1419 : 63707 : M2StackWord_PushWord (BlockStack, curFinallyTok); /* FINALLY keyword pos. */
1420 : 63707 : M2StackWord_PushWord (BlockStack, curModuleSym); /* current module. */
1421 : 63707 : curStartTok = tokno; /* current module. */
1422 : 63707 : curBeginTok = M2LexBuf_UnknownTokenNo;
1423 : 63707 : curEndTok = M2LexBuf_UnknownTokenNo;
1424 : 63707 : curFinallyTok = M2LexBuf_UnknownTokenNo;
1425 : 63707 : curModuleSym = SymbolTable_NulSym;
1426 : 63707 : }
1427 : :
1428 : :
1429 : : /*
1430 : : PopBlock - pop the block variables from the block stack.
1431 : : */
1432 : :
1433 : 63689 : static void PopBlock (void)
1434 : : {
1435 : 63689 : curModuleSym = static_cast<unsigned int> (M2StackWord_PopWord (BlockStack));
1436 : 63689 : curFinallyTok = static_cast<unsigned int> (M2StackWord_PopWord (BlockStack));
1437 : 63689 : curEndTok = static_cast<unsigned int> (M2StackWord_PopWord (BlockStack));
1438 : 63689 : curBeginTok = static_cast<unsigned int> (M2StackWord_PopWord (BlockStack));
1439 : 63689 : curStartTok = static_cast<unsigned int> (M2StackWord_PopWord (BlockStack));
1440 : 63689 : }
1441 : :
1442 : :
1443 : : /*
1444 : : BuildFormalParameterSection - Builds a Formal Parameter in a procedure.
1445 : :
1446 : : The Stack:
1447 : :
1448 : : Entry and Exit
1449 : :
1450 : : Ptr -> <- Ptr
1451 : : +------------+
1452 : : | ParamTotal |
1453 : : |------------|
1454 : : | TypeSym |
1455 : : |------------|
1456 : : | Array/Nul |
1457 : : |------------|
1458 : : | NoOfIds |
1459 : : |------------|
1460 : : | Id 1 |
1461 : : |------------|
1462 : : . .
1463 : : . .
1464 : : . .
1465 : : |------------|
1466 : : | Id n |
1467 : : |------------|
1468 : : | Var / Nul |
1469 : : |------------|
1470 : : | ProcSym |
1471 : : |------------|
1472 : : */
1473 : :
1474 : 4853017 : static void BuildFormalParameterSection (SymbolTable_ProcedureKind kind)
1475 : : {
1476 : 4853017 : NameKey_Name ParamName;
1477 : 4853017 : NameKey_Name Var;
1478 : 4853017 : NameKey_Name Array;
1479 : 4853017 : unsigned int tok;
1480 : 4853017 : unsigned int pi;
1481 : 4853017 : unsigned int TypeTok;
1482 : 4853017 : unsigned int ParamTotal;
1483 : 4853017 : unsigned int TypeSym;
1484 : 4853017 : unsigned int UnBoundedSym;
1485 : 4853017 : unsigned int NoOfIds;
1486 : 4853017 : unsigned int ProcSym;
1487 : 4853017 : unsigned int i;
1488 : 4853017 : unsigned int ndim;
1489 : :
1490 : 4853017 : M2Quads_PopT (&ParamTotal);
1491 : 4853017 : M2Quads_PopTtok (&TypeSym, &TypeTok);
1492 : 4853017 : M2Quads_PopTF (&Array, &ndim);
1493 : 9706034 : M2Debug_Assert ((Array == M2Reserved_ArrayTok) || (Array == M2Reserved_NulTok));
1494 : 4853017 : M2Quads_PopT (&NoOfIds);
1495 : 4853017 : ProcSym = static_cast<unsigned int> (M2Quads_OperandT (NoOfIds+2));
1496 : 4853017 : M2Debug_Assert (SymbolTable_IsProcedure (ProcSym));
1497 : 4853017 : Var = static_cast<NameKey_Name> (M2Quads_OperandT (NoOfIds+1));
1498 : 4853017 : tok = static_cast<unsigned int> (M2Quads_OperandTok (NoOfIds+2));
1499 : 9706034 : M2Debug_Assert ((Var == M2Reserved_VarTok) || (Var == M2Reserved_NulTok));
1500 : : /* Restore popped elements. */
1501 : 4853017 : M2Quads_PushT (NoOfIds);
1502 : 4853017 : M2Quads_PushTF (Array, ndim);
1503 : 4853017 : M2Quads_PushTtok (TypeSym, TypeTok);
1504 : 4853017 : M2Quads_PushT (ParamTotal);
1505 : 4853017 : if (Array == M2Reserved_ArrayTok)
1506 : : {
1507 : 500261 : UnBoundedSym = SymbolTable_MakeUnbounded (tok, TypeSym, ndim);
1508 : 500261 : TypeSym = UnBoundedSym;
1509 : : }
1510 : 4853017 : i = 1;
1511 : : /* +4 to skip over the top restored elements. */
1512 : 4853017 : pi = NoOfIds+4; /* Stack index referencing stacked parameter i. */
1513 : 11236539 : while (i <= NoOfIds) /* Stack index referencing stacked parameter i. */
1514 : : {
1515 : 6383522 : if (((M2Comp_CompilingDefinitionModule ()) && ! M2Options_PedanticParamNames) && (((SymbolTable_GetMainModule ()) == (SymbolTable_GetCurrentModule ())) || ((SymbolTable_IsHiddenTypeDeclared (SymbolTable_GetCurrentModule ())) && M2Options_ExtendedOpaque)))
1516 : : {
1517 : : /* We will see the parameters in the implementation module. */
1518 : : ParamName = NameKey_NulName;
1519 : : }
1520 : : else
1521 : : {
1522 : 6339261 : ParamName = static_cast<NameKey_Name> (M2Quads_OperandT (pi));
1523 : : }
1524 : 6383522 : tok = static_cast<unsigned int> (M2Quads_OperandTok (pi));
1525 : 6383522 : if (Var == M2Reserved_VarTok)
1526 : : {
1527 : : /* avoid dangling else. */
1528 : : /* VAR parameter. */
1529 : 544872 : if (! (SymbolTable_PutVarParam (tok, ProcSym, kind, ParamTotal+i, ParamName, TypeSym, Array == M2Reserved_ArrayTok, TypeTok)))
1530 : : {
1531 : 0 : M2Error_InternalError ((const char *) "problems adding a VarParameter - wrong param number?", 52);
1532 : : }
1533 : : }
1534 : : else
1535 : : {
1536 : : /* Non VAR parameter. */
1537 : 5838650 : if (! (SymbolTable_PutParam (tok, ProcSym, kind, ParamTotal+i, ParamName, TypeSym, Array == M2Reserved_ArrayTok, TypeTok)))
1538 : : {
1539 : 0 : M2Error_InternalError ((const char *) "problems adding a Parameter - wrong param number?", 49);
1540 : : }
1541 : : }
1542 : : /*
1543 : : IF kind = ProperProcedure
1544 : : THEN
1545 : : PutDeclared (OperandTok (pi), GetParameterShadowVar (GetNthParam (ProcSym, kind, ParamTotal + i)))
1546 : : END ;
1547 : : */
1548 : 6383522 : i += 1;
1549 : 6383522 : pi -= 1;
1550 : : }
1551 : 4853017 : }
1552 : :
1553 : :
1554 : : /*
1555 : : CheckFormalParameterSection - Checks a Formal Parameter in a procedure.
1556 : : The stack is unaffected.
1557 : :
1558 : : The Stack:
1559 : :
1560 : : Entry and Exit
1561 : :
1562 : : Ptr ->
1563 : : +------------+
1564 : : | ParamTotal |
1565 : : |------------|
1566 : : | TypeSym |
1567 : : |------------|
1568 : : | Array/Nul |
1569 : : |------------|
1570 : : | NoOfIds |
1571 : : |------------|
1572 : : | Id 1 |
1573 : : |------------|
1574 : : . .
1575 : : . .
1576 : : . .
1577 : : |------------|
1578 : : | Id n |
1579 : : |------------|
1580 : : | Var / Nul |
1581 : : |------------|
1582 : : | ProcSym |
1583 : : |------------|
1584 : : */
1585 : :
1586 : 989625 : static void CheckFormalParameterSection (SymbolTable_ProcedureKind curkind, SymbolTable_ProcedureKind prevkind)
1587 : : {
1588 : 989625 : NameKey_Name Array;
1589 : 989625 : NameKey_Name Var;
1590 : 989625 : bool isVarParam;
1591 : 989625 : bool Unbounded;
1592 : 989625 : unsigned int ParamI;
1593 : 989625 : unsigned int ParamIType;
1594 : 989625 : unsigned int ParamTotal;
1595 : 989625 : unsigned int TypeTok;
1596 : 989625 : unsigned int TypeSym;
1597 : 989625 : unsigned int NoOfIds;
1598 : 989625 : unsigned int ProcSym;
1599 : 989625 : unsigned int pi;
1600 : 989625 : unsigned int i;
1601 : 989625 : unsigned int ndim;
1602 : :
1603 : 989625 : M2Quads_PopT (&ParamTotal);
1604 : 989625 : M2Quads_PopTtok (&TypeSym, &TypeTok);
1605 : 989625 : M2Quads_PopTF (&Array, &ndim);
1606 : 1979250 : M2Debug_Assert ((Array == M2Reserved_ArrayTok) || (Array == M2Reserved_NulTok));
1607 : 989625 : M2Quads_PopT (&NoOfIds);
1608 : 989625 : ProcSym = static_cast<unsigned int> (M2Quads_OperandT (NoOfIds+2));
1609 : 989625 : M2Debug_Assert (SymbolTable_IsProcedure (ProcSym));
1610 : 989625 : Var = static_cast<NameKey_Name> (M2Quads_OperandT (NoOfIds+1));
1611 : 1979250 : M2Debug_Assert ((Var == NameKey_NulName) || (Var == M2Reserved_VarTok));
1612 : 989625 : isVarParam = Var != NameKey_NulName;
1613 : : /* Restore popped elements. */
1614 : 989625 : M2Quads_PushT (NoOfIds);
1615 : 989625 : M2Quads_PushTF (Array, ndim);
1616 : 989625 : M2Quads_PushTtok (TypeSym, TypeTok);
1617 : 989625 : M2Quads_PushT (ParamTotal);
1618 : 1979250 : M2Debug_Assert ((Var == M2Reserved_VarTok) || (Var == M2Reserved_NulTok));
1619 : 989625 : Unbounded = Array == M2Reserved_ArrayTok; /* ARRAY OF Type, parameter. */
1620 : 989625 : i = 1;
1621 : : /* +4 to skip over the top restored elements. */
1622 : 989625 : pi = NoOfIds+4; /* Stack index referencing stacked parameter i. */
1623 : : /* If there are an incorrect number of parameters specified then this
1624 : : will be detcted by EndBuildFormalParameters. */
1625 : 2237056 : while (i <= NoOfIds)
1626 : : {
1627 : 1247431 : if ((ParamTotal+i) <= (SymbolTable_NoOfParam (ProcSym, prevkind)))
1628 : : {
1629 : : /* WarnStringAt (InitString ('parampos?'), OperandTok (pi)) ; */
1630 : 1247425 : if (Unbounded && (! (SymbolTable_IsUnboundedParam (ProcSym, prevkind, ParamTotal+i))))
1631 : : {
1632 : 0 : ParameterError ((const char *) "declaration of procedure {%%1a} in the %s differs from the %s, {%%2N} parameter is inconsistant, %s", 99, (const char *) "the parameter {%3EHa} was not declared as an ARRAY OF type", 58, (const char *) "the parameter {%3EVa} was declared as an ARRAY OF type", 54, ParamTotal+i, ProcSym, curkind, prevkind);
1633 : : }
1634 : 1247425 : else if (! Unbounded && (SymbolTable_IsUnboundedParam (ProcSym, prevkind, ParamTotal+i)))
1635 : : {
1636 : : /* avoid dangling else. */
1637 : 6 : ParameterError ((const char *) "declaration of procedure {%%1a} in the %s differs from the %s, {%%2N} parameter is inconsistant, %s", 99, (const char *) "the parameter {%3EHa} was declared as an ARRAY OF type", 54, (const char *) "the parameter {%3EVa} was not declared as an ARRAY OF type", 58, ParamTotal+i, ProcSym, curkind, prevkind);
1638 : : }
1639 : 1247425 : if (Unbounded)
1640 : : {
1641 : 168856 : if ((SymbolTable_GetDimension (SymbolTable_GetNthParam (ProcSym, prevkind, ParamTotal+1))) != ndim)
1642 : : {
1643 : 0 : ParameterError ((const char *) "declaration of procedure {%%1a} in the %s differs from the %s, {%%2N} parameter is inconsistant, %s", 99, (const char *) "the dynamic array parameter {%3EHa} was declared with a different of dimensions", 79, (const char *) "the dynamic array parameter {%3EVa} was declared with a different of dimensions", 79, ParamTotal+i, ProcSym, curkind, prevkind);
1644 : : }
1645 : : }
1646 : 1247425 : if (isVarParam && (! (SymbolTable_IsVarParam (ProcSym, prevkind, ParamTotal+i))))
1647 : : {
1648 : : /* Expecting non VAR parameter. */
1649 : 6 : ParameterError ((const char *) "declaration of procedure {%%1a} in the %s differs from the %s, {%%2N} parameter is inconsistant, %s", 99, (const char *) "{%3EHa} was not declared as a {%kVAR} parameter", 47, (const char *) "{%3EVa} was declared as a {%kVAR} parameter", 43, ParamTotal+i, ProcSym, curkind, prevkind);
1650 : : }
1651 : 1247419 : else if (! isVarParam && (SymbolTable_IsVarParam (ProcSym, prevkind, ParamTotal+i)))
1652 : : {
1653 : : /* avoid dangling else. */
1654 : : /* Expecting VAR pamarater. */
1655 : 6 : ParameterError ((const char *) "declaration of procedure {%%1a} in the %s differs from the %s, {%%2N} parameter is inconsistant, %s", 99, (const char *) "{%3EHa} was declared as a {%kVAR} parameter", 43, (const char *) "{%3EVa} was not declared as a {%kVAR} parameter", 47, ParamTotal+i, ProcSym, curkind, prevkind);
1656 : : }
1657 : 1247425 : ParamI = SymbolTable_GetNthParam (ProcSym, prevkind, ParamTotal+i);
1658 : 1247425 : if (M2Options_PedanticParamNames)
1659 : : {
1660 : 30 : if ((SymbolTable_GetSymName (ParamI)) != (M2Quads_OperandT (pi)))
1661 : : {
1662 : : /* Different parameter names. */
1663 : 24 : ParameterError ((const char *) "procedure {%%1a} in the %s differs from the %s, {%%2N} parameter name is inconsistant, %s", 89, (const char *) "named as {%3EVa}", 16, (const char *) "named as {%3EVa}", 16, ParamTotal+i, ProcSym, curkind, prevkind);
1664 : : }
1665 : : }
1666 : 1247425 : if (Unbounded)
1667 : : {
1668 : : /* GetType(ParamI) yields an UnboundedSym or a PartialUnboundedSym,
1669 : : depending whether it has been resolved.. */
1670 : 168856 : ParamIType = SymbolTable_GetType (SymbolTable_GetType (ParamI));
1671 : : }
1672 : : else
1673 : : {
1674 : 1078569 : ParamIType = SymbolTable_GetType (ParamI);
1675 : : }
1676 : 1247425 : if (((((SymbolTable_SkipType (ParamIType)) != (SymbolTable_SkipType (TypeSym))) || (M2Options_PedanticParamNames && (ParamIType != TypeSym))) && (! (SymbolTable_IsUnknown (SymbolTable_SkipType (TypeSym))))) && (! (SymbolTable_IsUnknown (SymbolTable_SkipType (ParamIType)))))
1677 : : {
1678 : : /* Different parameter types. */
1679 : 18 : ParameterError ((const char *) "declaration in the %s differs from the %s, {%%2N} parameter is inconsistant, %s", 79, (const char *) "the parameter {%3EHa} was declared with a different type", 56, (const char *) "the parameter {%3EVa} was declared with a different type", 56, ParamTotal+i, ProcSym, curkind, prevkind);
1680 : : }
1681 : : }
1682 : 1247431 : i += 1;
1683 : 1247431 : pi -= 1;
1684 : : }
1685 : 989625 : }
1686 : :
1687 : :
1688 : : /*
1689 : : RemoveFPParameters - remove the FPSection parameters from the stack and
1690 : : increment the param total with the NoOfIds.
1691 : :
1692 : : The Stack:
1693 : :
1694 : : Entry Exit
1695 : :
1696 : : Ptr ->
1697 : : +------------+
1698 : : | ParamTotal |
1699 : : |------------|
1700 : : | TypeSym |
1701 : : |------------|
1702 : : | Array/Nul |
1703 : : |------------|
1704 : : | NoOfIds |
1705 : : |------------|
1706 : : | Id 1 |
1707 : : |------------|
1708 : : . .
1709 : : . .
1710 : : . .
1711 : : |------------|
1712 : : | Id n | <- Ptr
1713 : : |------------| +------------+
1714 : : | Var / Nul | | ParamTotal |
1715 : : |------------| |------------|
1716 : : | ProcSym | | ProcSym |
1717 : : |------------| |------------|
1718 : : */
1719 : :
1720 : 4853017 : static void RemoveFPParameters (void)
1721 : : {
1722 : 4853017 : unsigned int ParamTotal;
1723 : 4853017 : unsigned int Array;
1724 : 4853017 : unsigned int TypeSym;
1725 : 4853017 : unsigned int NoOfIds;
1726 : 4853017 : unsigned int ProcSym;
1727 : :
1728 : 4853017 : M2Quads_PopT (&ParamTotal);
1729 : 4853017 : M2Quads_PopT (&TypeSym);
1730 : 4853017 : M2Quads_PopT (&Array);
1731 : 9706034 : M2Debug_Assert ((Array == M2Reserved_ArrayTok) || (Array == M2Reserved_NulTok));
1732 : 4853017 : M2Quads_PopT (&NoOfIds);
1733 : 4853017 : ProcSym = static_cast<unsigned int> (M2Quads_OperandT (NoOfIds+2));
1734 : 4853017 : M2Debug_Assert (SymbolTable_IsProcedure (ProcSym));
1735 : 4853017 : M2Quads_PopN (NoOfIds+1); /* +1 for the Var/Nul. */
1736 : 4853017 : M2Quads_PushT (ParamTotal+NoOfIds); /* +1 for the Var/Nul. */
1737 : 4853017 : M2Quads_Annotate ((const char *) "%1d||running total of no. of parameters", 39);
1738 : 4853017 : M2Debug_Assert (SymbolTable_IsProcedure (M2Quads_OperandT (2)));
1739 : 4853017 : }
1740 : :
1741 : :
1742 : : /*
1743 : : ParameterError - create two error strings chained together.
1744 : : */
1745 : :
1746 : 60 : static void ParameterError (const char *FmtHeader_, unsigned int _FmtHeader_high, const char *PrevDesc_, unsigned int _PrevDesc_high, const char *CurDesc_, unsigned int _CurDesc_high, unsigned int ParamNo, unsigned int ProcSym, SymbolTable_ProcedureKind curkind, SymbolTable_ProcedureKind prevkind)
1747 : : {
1748 : 60 : unsigned int PrevParam;
1749 : 60 : unsigned int CurParam;
1750 : 60 : DynamicStrings_String CurStr;
1751 : 60 : DynamicStrings_String PrevStr;
1752 : 60 : DynamicStrings_String Msg;
1753 : 60 : DynamicStrings_String CurKindStr;
1754 : 60 : DynamicStrings_String PrevKindStr;
1755 : 60 : char FmtHeader[_FmtHeader_high+1];
1756 : 60 : char PrevDesc[_PrevDesc_high+1];
1757 : 60 : char CurDesc[_CurDesc_high+1];
1758 : :
1759 : : /* make a local copy of each unbounded array. */
1760 : 60 : memcpy (FmtHeader, FmtHeader_, _FmtHeader_high+1);
1761 : 60 : memcpy (PrevDesc, PrevDesc_, _PrevDesc_high+1);
1762 : 60 : memcpy (CurDesc, CurDesc_, _CurDesc_high+1);
1763 : :
1764 : 120 : CurParam = SymbolTable_GetNthParam (ProcSym, curkind, ParamNo);
1765 : 60 : CurKindStr = SymbolTable_GetProcedureKindDesc (curkind);
1766 : 60 : PrevKindStr = SymbolTable_GetProcedureKindDesc (prevkind);
1767 : 60 : PrevParam = SymbolTable_GetNthParam (ProcSym, prevkind, ParamNo);
1768 : 60 : PrevStr = DynamicStrings_InitString ((const char *) PrevDesc, _PrevDesc_high);
1769 : 60 : CurStr = DynamicStrings_InitString ((const char *) CurDesc, _CurDesc_high);
1770 : 60 : Msg = FormatStrings_Sprintf3 (DynamicStrings_Mark (DynamicStrings_InitString ((const char *) FmtHeader, _FmtHeader_high)), (const unsigned char *) &CurKindStr, (sizeof (CurKindStr)-1), (const unsigned char *) &PrevKindStr, (sizeof (PrevKindStr)-1), (const unsigned char *) &PrevStr, (sizeof (PrevStr)-1));
1771 : 60 : M2MetaError_MetaErrorString3 (Msg, ProcSym, ParamNo, PrevParam);
1772 : 60 : Msg = FormatStrings_Sprintf3 (DynamicStrings_Mark (DynamicStrings_InitString ((const char *) FmtHeader, _FmtHeader_high)), (const unsigned char *) &CurKindStr, (sizeof (CurKindStr)-1), (const unsigned char *) &PrevKindStr, (sizeof (PrevKindStr)-1), (const unsigned char *) &CurStr, (sizeof (CurStr)-1));
1773 : 60 : M2MetaError_MetaErrorString3 (Msg, ProcSym, ParamNo, CurParam);
1774 : 60 : }
1775 : :
1776 : :
1777 : : /*
1778 : : ParameterMismatch - generate a parameter mismatch error between the current
1779 : : declaration at tok and a previous ProcSym declaration.
1780 : : NoOfPar is the current number of parameters.
1781 : : */
1782 : :
1783 : 18 : static void ParameterMismatch (unsigned int tok, unsigned int ProcSym, unsigned int NoOfPar, SymbolTable_ProcedureKind prevkind, SymbolTable_ProcedureKind curkind)
1784 : : {
1785 : 18 : DynamicStrings_String MsgCurrent;
1786 : 18 : DynamicStrings_String MsgPrev;
1787 : 18 : DynamicStrings_String CompCur;
1788 : 18 : DynamicStrings_String CompPrev;
1789 : 18 : DynamicStrings_String CurDesc;
1790 : 18 : DynamicStrings_String PrevDesc;
1791 : :
1792 : 18 : CurDesc = SymbolTable_GetProcedureKindDesc (curkind);
1793 : 18 : PrevDesc = SymbolTable_GetProcedureKindDesc (prevkind);
1794 : 18 : CompPrev = GetComparison (SymbolTable_NoOfParam (ProcSym, prevkind), NoOfPar);
1795 : 18 : CompCur = GetComparison (NoOfPar, SymbolTable_NoOfParam (ProcSym, prevkind));
1796 : 18 : MsgCurrent = FormatStrings_Sprintf3 (DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "the %s for {%%1ad} has %s parameters than the %s", 48)), (const unsigned char *) &CurDesc, (sizeof (CurDesc)-1), (const unsigned char *) &CompCur, (sizeof (CompCur)-1), (const unsigned char *) &PrevDesc, (sizeof (PrevDesc)-1));
1797 : 18 : MsgPrev = FormatStrings_Sprintf3 (DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "the %s for {%%1ad} has %s parameters than the %s", 48)), (const unsigned char *) &PrevDesc, (sizeof (PrevDesc)-1), (const unsigned char *) &CompPrev, (sizeof (CompPrev)-1), (const unsigned char *) &CurDesc, (sizeof (CurDesc)-1));
1798 : 18 : M2MetaError_MetaErrorStringT1 (SymbolTable_GetProcedureDeclaredTok (ProcSym, prevkind), MsgPrev, ProcSym);
1799 : 18 : M2MetaError_MetaErrorStringT1 (tok, MsgCurrent, ProcSym);
1800 : 18 : CurDesc = DynamicStrings_KillString (CurDesc);
1801 : 18 : PrevDesc = DynamicStrings_KillString (PrevDesc);
1802 : 18 : CompCur = DynamicStrings_KillString (CompCur);
1803 : 18 : CompPrev = DynamicStrings_KillString (CompPrev);
1804 : 18 : }
1805 : :
1806 : :
1807 : : /*
1808 : : GetComparison - return a simple description from the result of
1809 : : a comparison between left and right.
1810 : : */
1811 : :
1812 : 36 : static DynamicStrings_String GetComparison (unsigned int left, unsigned int right)
1813 : : {
1814 : 36 : if (left < right)
1815 : : {
1816 : 18 : return DynamicStrings_InitString ((const char *) "fewer", 5);
1817 : : }
1818 : 18 : else if (left > right)
1819 : : {
1820 : : /* avoid dangling else. */
1821 : 18 : return DynamicStrings_InitString ((const char *) "more", 4);
1822 : : }
1823 : : else
1824 : : {
1825 : : /* avoid dangling else. */
1826 : 0 : return DynamicStrings_InitString ((const char *) "same", 4);
1827 : : }
1828 : : /* static analysis guarentees a RETURN statement will be used before here. */
1829 : : __builtin_unreachable ();
1830 : : }
1831 : :
1832 : :
1833 : : /*
1834 : : ReturnTypeMismatch - generate two errors showing the return type mismatches between
1835 : : ProcSym and ReturnType at procedure location tok.
1836 : : */
1837 : :
1838 : 6 : static void ReturnTypeMismatch (unsigned int curtok, unsigned int ProcSym, unsigned int CurRetType, unsigned int curtypetok, SymbolTable_ProcedureKind curkind, SymbolTable_ProcedureKind prevkind, unsigned int PrevRetType)
1839 : : {
1840 : 6 : unsigned int prevtok;
1841 : 6 : DynamicStrings_String CurDesc;
1842 : 6 : DynamicStrings_String PrevDesc;
1843 : 6 : DynamicStrings_String MsgCurrent;
1844 : 6 : DynamicStrings_String MsgPrev;
1845 : :
1846 : 6 : CurDesc = SymbolTable_GetProcedureKindDesc (curkind);
1847 : 6 : PrevDesc = SymbolTable_GetProcedureKindDesc (prevkind);
1848 : 6 : prevtok = SymbolTable_GetProcedureDeclaredTok (ProcSym, prevkind);
1849 : 6 : if (CurRetType == SymbolTable_NulSym)
1850 : : {
1851 : 6 : MsgCurrent = FormatStrings_Sprintf2 (DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "there is no return type for {%%1ad} specified in the %s whereas a return type is specified in the %s", 100)), (const unsigned char *) &CurDesc, (sizeof (CurDesc)-1), (const unsigned char *) &PrevDesc, (sizeof (PrevDesc)-1));
1852 : 6 : MsgPrev = FormatStrings_Sprintf2 (DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "there is no return type for {%%1ad} specified in the %s whereas a return type is specified in the %s", 100)), (const unsigned char *) &CurDesc, (sizeof (CurDesc)-1), (const unsigned char *) &PrevDesc, (sizeof (PrevDesc)-1));
1853 : 6 : prevtok = SymbolTable_GetReturnTypeTok (ProcSym, prevkind);
1854 : : }
1855 : 0 : else if (PrevRetType == SymbolTable_NulSym)
1856 : : {
1857 : : /* avoid dangling else. */
1858 : 0 : MsgCurrent = FormatStrings_Sprintf2 (DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "there is no return type for {%%1ad} specified in the %s whereas a return type is specified in the %s", 100)), (const unsigned char *) &PrevDesc, (sizeof (PrevDesc)-1), (const unsigned char *) &CurDesc, (sizeof (CurDesc)-1));
1859 : 0 : MsgPrev = FormatStrings_Sprintf2 (DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "there is no return type for {%%1ad} specified in the %s whereas a return type is specified in the %s", 100)), (const unsigned char *) &PrevDesc, (sizeof (PrevDesc)-1), (const unsigned char *) &CurDesc, (sizeof (CurDesc)-1));
1860 : 0 : curtok = curtypetok;
1861 : : }
1862 : : else
1863 : : {
1864 : : /* avoid dangling else. */
1865 : 0 : MsgCurrent = FormatStrings_Sprintf2 (DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "the return type for {%%1ad} specified in the %s differs in the %s", 65)), (const unsigned char *) &CurDesc, (sizeof (CurDesc)-1), (const unsigned char *) &PrevDesc, (sizeof (PrevDesc)-1));
1866 : 0 : MsgPrev = FormatStrings_Sprintf2 (DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "the return type for {%%1ad} specified in the %s differs in the %s", 65)), (const unsigned char *) &CurDesc, (sizeof (CurDesc)-1), (const unsigned char *) &PrevDesc, (sizeof (PrevDesc)-1));
1867 : 0 : curtok = curtypetok;
1868 : 0 : prevtok = SymbolTable_GetReturnTypeTok (ProcSym, prevkind);
1869 : : }
1870 : 6 : M2MetaError_MetaErrorStringT1 (curtok, MsgCurrent, ProcSym);
1871 : 6 : M2MetaError_MetaErrorStringT1 (prevtok, MsgPrev, ProcSym);
1872 : 6 : }
1873 : :
1874 : :
1875 : : /*
1876 : : CheckOptFunction - checks to see whether the optional return value
1877 : : has been set before and if it differs it will
1878 : : generate an error message. It will set the
1879 : : new value to isopt.
1880 : : */
1881 : :
1882 : 1267964 : static void CheckOptFunction (unsigned int tok, unsigned int sym, SymbolTable_ProcedureKind kind, bool isopt)
1883 : : {
1884 : 1267964 : SymbolTable_ProcedureKind other;
1885 : :
1886 : 1267964 : if ((SymbolTable_GetType (sym)) != SymbolTable_NulSym)
1887 : : {
1888 : 5071856 : for (other=SymbolTable_ProperProcedure; other<=SymbolTable_DefProcedure; other= static_cast<SymbolTable_ProcedureKind>(static_cast<int>(other+1)))
1889 : : {
1890 : : /* Procedure sym has been declared as a function. */
1891 : 3803892 : if ((kind != other) && (SymbolTable_GetProcedureParametersDefined (sym, other)))
1892 : : {
1893 : : /* avoid gcc warning by using compound statement even if not strictly necessary. */
1894 : 266125 : if ((SymbolTable_IsReturnOptional (sym, kind)) && ! isopt)
1895 : : {
1896 : 0 : M2MetaError_MetaErrorT1 (tok, (const char *) "procedure {%1Ea} is not declared with an optional return type here", 66, sym);
1897 : 0 : M2MetaError_MetaErrorT1 (SymbolTable_GetReturnTypeTok (sym, kind), (const char *) "previously procedure {%1Ea} was declared with an optional return type", 69, sym);
1898 : : }
1899 : 266125 : else if ((! (SymbolTable_IsReturnOptional (sym, kind))) && isopt)
1900 : : {
1901 : : /* avoid dangling else. */
1902 : 0 : M2MetaError_MetaErrorT1 (tok, (const char *) "procedure {%1Ea} is declared with an optional return type here", 62, sym);
1903 : 0 : M2MetaError_MetaErrorT1 (SymbolTable_GetReturnTypeTok (sym, kind), (const char *) "previously procedure {%1Ea} was declared without an optional return type", 72, sym);
1904 : : }
1905 : : }
1906 : : }
1907 : : }
1908 : 1267964 : SymbolTable_SetReturnOptional (sym, kind, isopt);
1909 : 1267964 : }
1910 : :
1911 : :
1912 : : /*
1913 : : CheckProcedure - checks to see that the top of stack procedure
1914 : : has not been declared as a procedure function.
1915 : :
1916 : : The Stack:
1917 : :
1918 : : Entry Exit
1919 : :
1920 : : Ptr -> <- Ptr
1921 : : +------------+ +------------+
1922 : : | ProcSym | | ProcSym |
1923 : : |------------| |------------|
1924 : : */
1925 : :
1926 : 2613078 : static void CheckProcedureReturn (unsigned int RetType, unsigned int typetok)
1927 : : {
1928 : 2613078 : SymbolTable_ProcedureKind curkind;
1929 : 2613078 : SymbolTable_ProcedureKind kind;
1930 : 2613078 : unsigned int tok;
1931 : 2613078 : unsigned int PrevRetType;
1932 : 2613078 : unsigned int ProcSym;
1933 : :
1934 : 2613078 : M2Quads_PopTtok (&ProcSym, &tok);
1935 : 2613078 : M2Quads_PushTtok (ProcSym, tok);
1936 : 2613078 : M2Quads_Annotate ((const char *) "%1s(%1d)||procedure start symbol", 32);
1937 : 2613078 : if (SymbolTable_IsProcedure (ProcSym))
1938 : : {
1939 : 2573719 : curkind = SymbolTable_GetProcedureKind (ProcSym, tok);
1940 : 12868595 : for (kind=SymbolTable_ProperProcedure; kind<=SymbolTable_DefProcedure; kind= static_cast<SymbolTable_ProcedureKind>(static_cast<int>(kind+1)))
1941 : : {
1942 : : /* Check against any previously declared kinds. */
1943 : 7721157 : if ((kind != curkind) && (SymbolTable_GetProcedureParametersDefined (ProcSym, kind)))
1944 : : {
1945 : 571557 : PrevRetType = SymbolTable_GetType (ProcSym);
1946 : 571557 : if (PrevRetType != RetType)
1947 : : {
1948 : 6 : ReturnTypeMismatch (tok, ProcSym, RetType, typetok, curkind, kind, PrevRetType);
1949 : : }
1950 : : }
1951 : : }
1952 : 2573719 : SymbolTable_PutFunction (tok, ProcSym, curkind, RetType);
1953 : : }
1954 : 2613078 : }
1955 : :
1956 : :
1957 : : /*
1958 : : HandleRecordFieldPragmas -
1959 : :
1960 : : Entry Exit
1961 : : ===== ====
1962 : :
1963 : : Ptr -> <- Ptr
1964 : :
1965 : : |-------------| |-------------|
1966 : : | Const1 | | Const1 |
1967 : : |-------------| |-------------|
1968 : : | PragmaName1 | | PragmaName1 |
1969 : : |-------------| |-------------|
1970 : : */
1971 : :
1972 : 253702 : static void HandleRecordFieldPragmas (unsigned int record, unsigned int field, unsigned int n)
1973 : : {
1974 : 253702 : bool seenAlignment;
1975 : 253702 : unsigned int defaultAlignment;
1976 : 253702 : unsigned int sym;
1977 : 253702 : unsigned int i;
1978 : 253702 : NameKey_Name name;
1979 : 253702 : DynamicStrings_String s;
1980 : :
1981 : 253702 : seenAlignment = false;
1982 : 253702 : defaultAlignment = SymbolTable_GetDefaultRecordFieldAlignment (record);
1983 : 253702 : i = 1;
1984 : 507416 : while (i <= n)
1985 : : {
1986 : 12 : name = static_cast<NameKey_Name> (M2Quads_OperandT (i*2));
1987 : 12 : sym = static_cast<unsigned int> (M2Quads_OperandT ((i*2)-1));
1988 : 12 : if (name == (NameKey_MakeKey ((const char *) "unused", 6)))
1989 : : {
1990 : 0 : if (sym == SymbolTable_NulSym)
1991 : : {
1992 : 0 : SymbolTable_PutUnused (field);
1993 : : }
1994 : : else
1995 : : {
1996 : 0 : M2Error_WriteFormat0 ((const char *) "not expecting pragma 'unused' to contain an expression", 54);
1997 : : }
1998 : : }
1999 : 12 : else if (name == (NameKey_MakeKey ((const char *) "bytealignment", 13)))
2000 : : {
2001 : : /* avoid dangling else. */
2002 : 12 : if (sym == SymbolTable_NulSym)
2003 : : {
2004 : 0 : M2Error_WriteFormat0 ((const char *) "expecting an expression with the pragma 'bytealignment'", 55);
2005 : : }
2006 : : else
2007 : : {
2008 : 12 : SymbolTable_PutAlignment (field, sym);
2009 : 12 : seenAlignment = true;
2010 : : }
2011 : : }
2012 : : else
2013 : : {
2014 : : /* avoid dangling else. */
2015 : 0 : s = DynamicStrings_InitString ((const char *) "cannot use pragma '", 19);
2016 : 0 : s = DynamicStrings_ConCat (s, DynamicStrings_Mark (DynamicStrings_InitStringCharStar (NameKey_KeyToCharStar (name))));
2017 : 0 : s = DynamicStrings_ConCat (s, DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "' on record field {%1ad}", 24)));
2018 : 0 : M2MetaError_MetaErrorString1 (s, field);
2019 : : }
2020 : 12 : i += 1;
2021 : : }
2022 : 253702 : if (! seenAlignment && (defaultAlignment != SymbolTable_NulSym))
2023 : : {
2024 : 108 : SymbolTable_PutAlignment (field, defaultAlignment);
2025 : : }
2026 : 253702 : }
2027 : :
2028 : :
2029 : : /*
2030 : : SaveRememberedConstructor -
2031 : : */
2032 : :
2033 : 0 : static void SaveRememberedConstructor (void)
2034 : : {
2035 : 0 : }
2036 : :
2037 : :
2038 : : /*
2039 : : GetSeenString - returns a string corresponding to, s.
2040 : : */
2041 : :
2042 : 0 : static DynamicStrings_String GetSeenString (M2Const_constType s)
2043 : : {
2044 : 0 : switch (s)
2045 : : {
2046 : 0 : case M2Const_unknown:
2047 : 0 : return DynamicStrings_InitString ((const char *) "unknown", 7);
2048 : 0 : break;
2049 : :
2050 : 0 : case M2Const_set:
2051 : 0 : return DynamicStrings_InitString ((const char *) "SET", 3);
2052 : 0 : break;
2053 : :
2054 : 0 : case M2Const_str:
2055 : 0 : return DynamicStrings_InitString ((const char *) "string", 6);
2056 : 0 : break;
2057 : :
2058 : 0 : case M2Const_constructor:
2059 : 0 : return DynamicStrings_InitString ((const char *) "constructor", 11);
2060 : 0 : break;
2061 : :
2062 : 0 : case M2Const_array:
2063 : 0 : return DynamicStrings_InitString ((const char *) "ARRAY", 5);
2064 : 0 : break;
2065 : :
2066 : 0 : case M2Const_cast:
2067 : 0 : return DynamicStrings_InitStringCharStar (NameKey_KeyToCharStar (SymbolTable_GetSymName (castType)));
2068 : 0 : break;
2069 : :
2070 : 0 : case M2Const_boolean:
2071 : 0 : return DynamicStrings_InitString ((const char *) "BOOLEAN", 7);
2072 : 0 : break;
2073 : :
2074 : 0 : case M2Const_ztype:
2075 : 0 : return DynamicStrings_InitString ((const char *) "Z type", 6);
2076 : 0 : break;
2077 : :
2078 : 0 : case M2Const_rtype:
2079 : 0 : return DynamicStrings_InitString ((const char *) "R type", 6);
2080 : 0 : break;
2081 : :
2082 : 0 : case M2Const_ctype:
2083 : 0 : return DynamicStrings_InitString ((const char *) "C type", 6);
2084 : 0 : break;
2085 : :
2086 : 0 : case M2Const_procedure:
2087 : 0 : return DynamicStrings_InitString ((const char *) "PROCEDURE", 9);
2088 : 0 : break;
2089 : :
2090 : :
2091 : 0 : default:
2092 : 0 : M2Error_InternalError ((const char *) "unexpected value of type", 24);
2093 : : break;
2094 : : }
2095 : : return static_cast<DynamicStrings_String> (NULL);
2096 : : /* static analysis guarentees a RETURN statement will be used before here. */
2097 : : __builtin_unreachable ();
2098 : : }
2099 : :
2100 : :
2101 : : /*
2102 : : SetTypeTo - attempts to set, type, to, s.
2103 : : */
2104 : :
2105 : 33758 : static void SetTypeTo (M2Const_constType s)
2106 : : {
2107 : 33758 : DynamicStrings_String s1;
2108 : 33758 : DynamicStrings_String s2;
2109 : 33758 : DynamicStrings_String s3;
2110 : :
2111 : 33758 : if (type == M2Const_unknown)
2112 : : {
2113 : 33240 : type = s;
2114 : : }
2115 : : /* leave it alone */
2116 : 518 : else if ((type == M2Const_constructor) && (s != M2Const_str))
2117 : : {
2118 : : /* avoid dangling else. */
2119 : 284 : type = s;
2120 : : }
2121 : 234 : else if ((s == M2Const_constructor) && ((type == M2Const_array) || (type == M2Const_set)))
2122 : : {
2123 : : /* avoid dangling else. */
2124 : : }
2125 : 222 : else if (type != s)
2126 : : {
2127 : : /* avoid dangling else. */
2128 : 0 : s1 = GetSeenString (type);
2129 : 0 : s2 = GetSeenString (s);
2130 : 0 : s3 = FormatStrings_Sprintf2 (DynamicStrings_InitString ((const char *) "cannot create a %s constant together with a %s constant", 55), (const unsigned char *) &s1, (sizeof (s1)-1), (const unsigned char *) &s2, (sizeof (s2)-1));
2131 : 0 : M2Error_ErrorStringAt (s3, M2LexBuf_GetTokenNo ());
2132 : 0 : s1 = DynamicStrings_KillString (s1);
2133 : 0 : s2 = DynamicStrings_KillString (s2);
2134 : : }
2135 : 33758 : }
2136 : :
2137 : :
2138 : : /*
2139 : : BlockStart - tokno is the module/procedure/implementation/definition token
2140 : : */
2141 : :
2142 : 63707 : extern "C" void P2SymBuild_BlockStart (unsigned int tokno)
2143 : : {
2144 : 63707 : PushBlock (tokno);
2145 : 63707 : }
2146 : :
2147 : :
2148 : : /*
2149 : : BlockEnd - declare module ctor/init/fini/dep procedures.
2150 : : */
2151 : :
2152 : 63689 : extern "C" void P2SymBuild_BlockEnd (unsigned int tokno)
2153 : : {
2154 : 63689 : curBeginTok = propageteTokenPosition (curStartTok, curBeginTok);
2155 : 63689 : curFinallyTok = propageteTokenPosition (tokno, curFinallyTok);
2156 : 63689 : M2Debug_Assert (curModuleSym != SymbolTable_NulSym);
2157 : 63689 : SymbolTable_MakeModuleCtor (curStartTok, curBeginTok, curFinallyTok, curModuleSym);
2158 : 63689 : PopBlock ();
2159 : 63689 : }
2160 : :
2161 : :
2162 : : /*
2163 : : BlockBegin - assign curBeginTok to tokno.
2164 : : */
2165 : :
2166 : 35811 : extern "C" void P2SymBuild_BlockBegin (unsigned int tokno)
2167 : : {
2168 : 35811 : curBeginTok = tokno;
2169 : 35811 : }
2170 : :
2171 : :
2172 : : /*
2173 : : BlockFinally - assign curFinallyTok to tokno.
2174 : : */
2175 : :
2176 : 5602 : extern "C" void P2SymBuild_BlockFinally (unsigned int tokno)
2177 : : {
2178 : 5602 : curFinallyTok = tokno;
2179 : 5602 : }
2180 : :
2181 : 114964 : extern "C" void P2SymBuild_P2StartBuildDefModule (void)
2182 : : {
2183 : 114964 : NameKey_Name name;
2184 : 114964 : unsigned int ModuleSym;
2185 : 114964 : unsigned int tokno;
2186 : :
2187 : : /*
2188 : : StartBuildDefinitionModule - Creates a definition module and starts
2189 : : a new scope.
2190 : :
2191 : : he Stack is expected:
2192 : :
2193 : : Entry Exit
2194 : :
2195 : : Ptr -> <- Ptr
2196 : : +------------+ +-----------+
2197 : : | NameStart | | NameStart |
2198 : : |------------| |-----------|
2199 : :
2200 : : */
2201 : 114964 : M2Quads_PopTtok (&name, &tokno);
2202 : 114964 : ModuleSym = M2Batch_MakeDefinitionSource (tokno, name);
2203 : 114964 : curModuleSym = ModuleSym;
2204 : 114964 : SymbolTable_SetCurrentModule (ModuleSym);
2205 : 114964 : SymbolTable_SetFileModule (ModuleSym);
2206 : 114964 : SymbolTable_StartScope (ModuleSym);
2207 : 114964 : M2Debug_Assert (SymbolTable_IsDefImp (ModuleSym));
2208 : 114964 : M2Debug_Assert (M2Comp_CompilingDefinitionModule ());
2209 : 114964 : M2Quads_PushT (name);
2210 : 114964 : M2Quads_Annotate ((const char *) "%1n||definition module name", 27);
2211 : 114964 : M2Error_EnterDefinitionScope (name);
2212 : 114964 : }
2213 : :
2214 : 114964 : extern "C" void P2SymBuild_P2EndBuildDefModule (void)
2215 : : {
2216 : 114964 : NameKey_Name NameStart;
2217 : 114964 : NameKey_Name NameEnd;
2218 : :
2219 : : /*
2220 : : EndBuildDefinitionModule - Destroys the definition module scope and
2221 : : checks for correct name.
2222 : :
2223 : : The Stack is expected:
2224 : :
2225 : : Entry Exit
2226 : :
2227 : : Ptr ->
2228 : : +------------+ +-----------+
2229 : : | NameEnd | | |
2230 : : |------------| |-----------|
2231 : : | NameStart | | | <- Ptr
2232 : : |------------| |-----------|
2233 : : */
2234 : 114964 : M2Debug_Assert (M2Comp_CompilingDefinitionModule ());
2235 : 114964 : SymbolTable_CheckForUndeclaredExports (SymbolTable_GetCurrentModule ());
2236 : 114964 : SymbolTable_EndScope ();
2237 : 114964 : M2Quads_PopT (&NameStart);
2238 : 114964 : M2Quads_PopT (&NameEnd);
2239 : 114964 : if (Debugging)
2240 : : {
2241 : : M2Printf_printf0 ((const char *) "pass 2: ", 8);
2242 : : SymbolTable_DisplayTrees (SymbolTable_GetCurrentModule ());
2243 : : }
2244 : 114964 : if (NameStart != NameEnd)
2245 : : {
2246 : 0 : M2Error_WriteFormat2 ((const char *) "inconsistant definition module name, module began as (%a) and ended with (%a)", 77, (const unsigned char *) &NameStart, (sizeof (NameStart)-1), (const unsigned char *) &NameEnd, (sizeof (NameEnd)-1));
2247 : : }
2248 : 114964 : M2Error_LeaveErrorScope ();
2249 : 114964 : }
2250 : :
2251 : 52177 : extern "C" void P2SymBuild_P2StartBuildImplementationModule (void)
2252 : : {
2253 : 52177 : NameKey_Name name;
2254 : 52177 : unsigned int ModuleSym;
2255 : 52177 : unsigned int tokno;
2256 : :
2257 : : /*
2258 : : StartBuildImplementationModule - Creates an implementation module and starts
2259 : : a new scope.
2260 : :
2261 : : The Stack is expected:
2262 : :
2263 : : Entry Exit
2264 : :
2265 : : Ptr -> <- Ptr
2266 : : +------------+ +-----------+
2267 : : | NameStart | | NameStart |
2268 : : |------------| |-----------|
2269 : :
2270 : : */
2271 : 52177 : M2Quads_PopTtok (&name, &tokno);
2272 : 52177 : ModuleSym = M2Batch_MakeImplementationSource (tokno, name);
2273 : 52177 : curModuleSym = ModuleSym;
2274 : 52177 : SymbolTable_SetCurrentModule (ModuleSym);
2275 : 52177 : SymbolTable_SetFileModule (ModuleSym);
2276 : 52177 : SymbolTable_StartScope (ModuleSym);
2277 : 52177 : M2Debug_Assert (SymbolTable_IsDefImp (ModuleSym));
2278 : 52177 : M2Debug_Assert (M2Comp_CompilingImplementationModule ());
2279 : 52177 : M2Quads_PushT (name);
2280 : 52177 : M2Quads_Annotate ((const char *) "%1n||implementation module name", 31);
2281 : 52177 : M2Error_EnterImplementationScope (name);
2282 : 52177 : }
2283 : :
2284 : 52171 : extern "C" void P2SymBuild_P2EndBuildImplementationModule (void)
2285 : : {
2286 : 52171 : NameKey_Name NameStart;
2287 : 52171 : NameKey_Name NameEnd;
2288 : :
2289 : : /*
2290 : : EndBuildImplementationModule - Destroys the implementation module scope and
2291 : : checks for correct name.
2292 : :
2293 : : The Stack is expected:
2294 : :
2295 : : Entry Exit
2296 : :
2297 : : Ptr ->
2298 : : +------------+ +-----------+
2299 : : | NameEnd | | |
2300 : : |------------| |-----------|
2301 : : | NameStart | | | <- Ptr
2302 : : |------------| |-----------|
2303 : : */
2304 : 52171 : M2Debug_Assert (M2Comp_CompilingImplementationModule ());
2305 : 52171 : SymbolTable_CheckForUnImplementedExports ();
2306 : 52171 : SymbolTable_EndScope ();
2307 : 52171 : M2Quads_PopT (&NameStart);
2308 : 52171 : M2Quads_PopT (&NameEnd);
2309 : 52171 : if (NameStart != NameEnd)
2310 : : {
2311 : 0 : M2Error_WriteFormat1 ((const char *) "inconsistant implementation module name %a", 42, (const unsigned char *) &NameStart, (sizeof (NameStart)-1));
2312 : : }
2313 : 52171 : M2Error_LeaveErrorScope ();
2314 : 52171 : }
2315 : :
2316 : 11110 : extern "C" void P2SymBuild_P2StartBuildProgramModule (void)
2317 : : {
2318 : 11110 : NameKey_Name name;
2319 : 11110 : unsigned int ModuleSym;
2320 : 11110 : unsigned int tokno;
2321 : :
2322 : : /*
2323 : : StartBuildProgramModule - Creates a program module and starts
2324 : : a new scope.
2325 : :
2326 : : The Stack is expected:
2327 : :
2328 : : Entry Exit
2329 : :
2330 : : Ptr -> <- Ptr
2331 : : +------------+ +-----------+
2332 : : | NameStart | | NameStart |
2333 : : |------------| |-----------|
2334 : :
2335 : : */
2336 : 11110 : M2Quads_PopTtok (&name, &tokno);
2337 : 11110 : ModuleSym = M2Batch_MakeProgramSource (tokno, name);
2338 : 11110 : curModuleSym = ModuleSym;
2339 : 11110 : SymbolTable_SetCurrentModule (ModuleSym);
2340 : 11110 : SymbolTable_SetFileModule (ModuleSym);
2341 : 11110 : SymbolTable_StartScope (ModuleSym);
2342 : 11110 : M2Debug_Assert (M2Comp_CompilingProgramModule ());
2343 : 11110 : M2Debug_Assert (! (SymbolTable_IsDefImp (ModuleSym)));
2344 : 11110 : M2Quads_PushT (name);
2345 : 11110 : M2Quads_Annotate ((const char *) "%1n||program module name", 24);
2346 : 11110 : M2Error_EnterProgramScope (name);
2347 : 11110 : }
2348 : :
2349 : 11098 : extern "C" void P2SymBuild_P2EndBuildProgramModule (void)
2350 : : {
2351 : 11098 : NameKey_Name NameStart;
2352 : 11098 : NameKey_Name NameEnd;
2353 : :
2354 : : /*
2355 : : EndBuildProgramModule - Destroys the program module scope and
2356 : : checks for correct name.
2357 : :
2358 : : The Stack is expected:
2359 : :
2360 : : Entry Exit
2361 : :
2362 : : Ptr ->
2363 : : +------------+ +-----------+
2364 : : | NameEnd | | |
2365 : : |------------| |-----------|
2366 : : | NameStart | | | <- Ptr
2367 : : |------------| |-----------|
2368 : : */
2369 : 11098 : M2Debug_Assert (M2Comp_CompilingProgramModule ());
2370 : 11098 : SymbolTable_CheckForUndeclaredExports (SymbolTable_GetCurrentModule ()); /* Not really allowed exports here though! */
2371 : 11098 : SymbolTable_EndScope (); /* Not really allowed exports here though! */
2372 : 11098 : M2Quads_PopT (&NameStart);
2373 : 11098 : M2Quads_PopT (&NameEnd);
2374 : 11098 : if (Debugging)
2375 : : {
2376 : : M2Printf_printf0 ((const char *) "pass 2: ", 8);
2377 : : SymbolTable_DisplayTrees (SymbolTable_GetCurrentModule ());
2378 : : }
2379 : 11098 : if (NameStart != NameEnd)
2380 : : {
2381 : 0 : M2Error_WriteFormat2 ((const char *) "inconsistant program module name %a does not match %a", 53, (const unsigned char *) &NameStart, (sizeof (NameStart)-1), (const unsigned char *) &NameEnd, (sizeof (NameEnd)-1));
2382 : : }
2383 : 11098 : M2Error_LeaveErrorScope ();
2384 : 11098 : }
2385 : :
2386 : :
2387 : : /*
2388 : : StartBuildInnerModule - Creates an Inner module and starts
2389 : : a new scope.
2390 : :
2391 : : The Stack is expected:
2392 : :
2393 : : Entry Exit
2394 : :
2395 : : Ptr -> <- Ptr
2396 : : +------------+ +-----------+
2397 : : | NameStart | | NameStart |
2398 : : |------------| |-----------|
2399 : :
2400 : : */
2401 : :
2402 : 420 : extern "C" void P2SymBuild_StartBuildInnerModule (void)
2403 : : {
2404 : 420 : NameKey_Name name;
2405 : 420 : unsigned int tok;
2406 : 420 : unsigned int ModuleSym;
2407 : :
2408 : 420 : M2Quads_PopTtok (&name, &tok);
2409 : 420 : ModuleSym = SymbolTable_GetDeclareSym (tok, name);
2410 : 420 : curModuleSym = ModuleSym;
2411 : 420 : SymbolTable_StartScope (ModuleSym);
2412 : 420 : M2Debug_Assert (! (SymbolTable_IsDefImp (ModuleSym)));
2413 : 420 : M2Quads_PushTtok (name, tok);
2414 : 420 : M2Quads_Annotate ((const char *) "%1n||inner module name", 22);
2415 : 420 : M2Error_EnterModuleScope (name);
2416 : 420 : }
2417 : :
2418 : :
2419 : : /*
2420 : : EndBuildInnerModule - Destroys the Inner module scope and
2421 : : checks for correct name.
2422 : :
2423 : : The Stack is expected:
2424 : :
2425 : : Entry Exit
2426 : :
2427 : : Ptr ->
2428 : : +------------+ +-----------+
2429 : : | NameEnd | | |
2430 : : |------------| |-----------|
2431 : : | NameStart | | | <- Ptr
2432 : : |------------| |-----------|
2433 : : */
2434 : :
2435 : 420 : extern "C" void P2SymBuild_EndBuildInnerModule (void)
2436 : : {
2437 : 420 : NameKey_Name NameStart;
2438 : 420 : NameKey_Name NameEnd;
2439 : :
2440 : 420 : SymbolTable_CheckForUndeclaredExports (SymbolTable_GetCurrentModule ());
2441 : 420 : SymbolTable_EndScope ();
2442 : 420 : M2Quads_PopT (&NameStart);
2443 : 420 : M2Quads_PopT (&NameEnd);
2444 : 420 : if (NameStart != NameEnd)
2445 : : {
2446 : 0 : M2Error_WriteFormat2 ((const char *) "inconsistant inner module name %a does not match %a", 51, (const unsigned char *) &NameStart, (sizeof (NameStart)-1), (const unsigned char *) &NameEnd, (sizeof (NameEnd)-1));
2447 : : }
2448 : 420 : M2Error_LeaveErrorScope ();
2449 : 420 : }
2450 : :
2451 : :
2452 : : /*
2453 : : BuildImportOuterModule - Builds imported identifiers into an outer module
2454 : : from a definition module.
2455 : :
2456 : : The Stack is expected:
2457 : :
2458 : : Entry OR Entry
2459 : :
2460 : : Ptr -> Ptr ->
2461 : : +------------+ +-----------+
2462 : : | # | | # |
2463 : : |------------| |-----------|
2464 : : | Id1 | | Id1 |
2465 : : |------------| |-----------|
2466 : : . . . .
2467 : : . . . .
2468 : : . . . .
2469 : : |------------| |-----------|
2470 : : | Id# | | Id# |
2471 : : |------------| |-----------|
2472 : : | ImportTok | | Ident |
2473 : : |------------| |-----------|
2474 : :
2475 : : IMPORT Id1, .. Id# ; FROM Ident IMPORT Id1 .. Id# ;
2476 : :
2477 : :
2478 : : Exit
2479 : :
2480 : : All above stack discarded
2481 : : */
2482 : :
2483 : 279214 : extern "C" void P2SymBuild_BuildImportOuterModule (void)
2484 : : {
2485 : 279214 : unsigned int Sym;
2486 : 279214 : unsigned int ModSym;
2487 : 279214 : unsigned int i;
2488 : 279214 : unsigned int n;
2489 : :
2490 : 279214 : M2Quads_PopT (&n); /* n = # of the Ident List */
2491 : 279214 : if ((M2Quads_OperandT (n+1)) != M2Reserved_ImportTok)
2492 : : {
2493 : : /* Ident List contains list of objects imported from ModSym */
2494 : 245628 : ModSym = M2Batch_LookupModule (M2Quads_OperandTok (n+1), M2Quads_OperandT (n+1));
2495 : 245628 : i = 1;
2496 : 1082118 : while (i <= n)
2497 : : {
2498 : 590862 : Sym = SymbolTable_GetExported (M2Quads_OperandTok (i), ModSym, M2Quads_OperandT (i));
2499 : 590862 : SymbolTable_CheckForEnumerationInCurrentModule (Sym);
2500 : 590862 : i += 1;
2501 : : }
2502 : : }
2503 : 279214 : M2Quads_PopN (n+1); /* clear stack */
2504 : 279214 : }
2505 : :
2506 : :
2507 : : /*
2508 : : BuildExportOuterModule - Builds exported identifiers from an outer module
2509 : : to the outside world of library modules.
2510 : :
2511 : : The Stack is expected:
2512 : :
2513 : : Entry OR Entry
2514 : :
2515 : : Ptr -> Ptr ->
2516 : : +------------+ +--------------+
2517 : : | # | | # |
2518 : : |------------| |--------------|
2519 : : | Id1 | | Id1 |
2520 : : |------------| |--------------|
2521 : : . . . .
2522 : : . . . .
2523 : : . . . .
2524 : : |------------| |--------------|
2525 : : | Id# | | Id# |
2526 : : |------------| |--------------|
2527 : : | ExportTok | | QualifiedTok |
2528 : : |------------| |--------------|
2529 : :
2530 : : EXPORT Id1, .. Id# ; EXPORT QUALIFIED Id1 .. Id# ;
2531 : :
2532 : : Error Condition
2533 : :
2534 : :
2535 : : Exit
2536 : :
2537 : : All above stack discarded
2538 : : */
2539 : :
2540 : 67240 : extern "C" void P2SymBuild_BuildExportOuterModule (void)
2541 : : {
2542 : 67240 : unsigned int n;
2543 : :
2544 : 67240 : M2Quads_PopT (&n); /* n = # of the Ident List */
2545 : 67240 : M2Quads_PopN (n+1); /* n = # of the Ident List */
2546 : 67240 : }
2547 : :
2548 : :
2549 : : /*
2550 : : BuildImportInnerModule - Builds imported identifiers into an inner module
2551 : : from the last level of module.
2552 : :
2553 : : The Stack is expected:
2554 : :
2555 : : Entry OR Entry
2556 : :
2557 : : Ptr -> Ptr ->
2558 : : +------------+ +-----------+
2559 : : | # | | # |
2560 : : |------------| |-----------|
2561 : : | Id1 | | Id1 |
2562 : : |------------| |-----------|
2563 : : . . . .
2564 : : . . . .
2565 : : . . . .
2566 : : |------------| |-----------|
2567 : : | Id# | | Id# |
2568 : : |------------| |-----------|
2569 : : | ImportTok | | Ident |
2570 : : |------------| |-----------|
2571 : :
2572 : : IMPORT Id1, .. Id# ; FROM Ident IMPORT Id1 .. Id# ;
2573 : :
2574 : : Exit
2575 : :
2576 : : All above stack discarded
2577 : : */
2578 : :
2579 : 222 : extern "C" void P2SymBuild_BuildImportInnerModule (void)
2580 : : {
2581 : 222 : unsigned int Sym;
2582 : 222 : unsigned int ModSym;
2583 : 222 : unsigned int n;
2584 : 222 : unsigned int i;
2585 : :
2586 : 222 : M2Quads_PopT (&n); /* i = # of the Ident List */
2587 : 222 : if ((M2Quads_OperandT (n+1)) == M2Reserved_ImportTok)
2588 : : {
2589 : : /* Ident List contains list of objects */
2590 : : i = 1;
2591 : 318 : while (i <= n)
2592 : : {
2593 : 162 : Sym = SymbolTable_GetFromOuterModule (M2Quads_OperandTok (i), M2Quads_OperandT (i));
2594 : 162 : SymbolTable_CheckForEnumerationInCurrentModule (Sym);
2595 : 162 : i += 1;
2596 : : }
2597 : : }
2598 : : else
2599 : : {
2600 : : /* Ident List contains list of objects from ModSym */
2601 : 66 : ModSym = M2Batch_LookupOuterModule (M2Quads_OperandTok (n+1), M2Quads_OperandT (n+1));
2602 : 66 : i = 1;
2603 : 198 : while (i <= n)
2604 : : {
2605 : 66 : Sym = SymbolTable_GetExported (M2Quads_OperandTok (i), ModSym, M2Quads_OperandT (i));
2606 : 66 : SymbolTable_CheckForEnumerationInCurrentModule (Sym);
2607 : 66 : i += 1;
2608 : : }
2609 : : }
2610 : 222 : M2Quads_PopN (n+1); /* Clear Stack */
2611 : 222 : }
2612 : :
2613 : :
2614 : : /*
2615 : : BuildExportInnerModule - Builds exported identifiers from an inner module
2616 : : to the next layer module.
2617 : :
2618 : : The Stack is expected:
2619 : :
2620 : : Entry OR Entry
2621 : :
2622 : : Ptr -> Ptr ->
2623 : : +------------+ +--------------+
2624 : : | # | | # |
2625 : : |------------| |--------------|
2626 : : | Id1 | | Id1 |
2627 : : |------------| |--------------|
2628 : : . . . .
2629 : : . . . .
2630 : : . . . .
2631 : : |------------| |--------------|
2632 : : | Id# | | Id# |
2633 : : |------------| |--------------|
2634 : : | ExportTok | | QualifiedTok |
2635 : : |------------| |--------------|
2636 : :
2637 : : EXPORT Id1, .. Id# ; EXPORT QUALIFIED Id1 .. Id# ;
2638 : :
2639 : :
2640 : : Exit
2641 : :
2642 : : All above stack discarded
2643 : : */
2644 : :
2645 : 282 : extern "C" void P2SymBuild_BuildExportInnerModule (void)
2646 : : {
2647 : 282 : unsigned int n;
2648 : :
2649 : 282 : M2Quads_PopT (&n);
2650 : 282 : M2Quads_PopN (n+1); /* clear stack */
2651 : 282 : }
2652 : :
2653 : :
2654 : : /*
2655 : : BuildNumber - Converts a number into a symbol.
2656 : :
2657 : :
2658 : : Stack
2659 : :
2660 : : Entry Exit
2661 : :
2662 : : Ptr -> <- Ptr
2663 : : +------------+ +-------------------+
2664 : : | Name | tok | | Sym | Type | tok |
2665 : : |------------+ |-------------------|
2666 : : */
2667 : :
2668 : 695504 : extern "C" void P2SymBuild_BuildNumber (void)
2669 : : {
2670 : 695504 : NameKey_Name name;
2671 : 695504 : unsigned int Sym;
2672 : 695504 : unsigned int tok;
2673 : :
2674 : 695504 : M2Quads_PopTtok (&name, &tok);
2675 : 695504 : Sym = SymbolTable_MakeConstLit (tok, name, SymbolTable_NulSym);
2676 : 695504 : M2Quads_PushTFtok (Sym, SymbolTable_GetType (Sym), tok);
2677 : 695504 : M2Quads_Annotate ((const char *) "%1s(%1d)||constant number", 25);
2678 : 695504 : }
2679 : :
2680 : :
2681 : : /*
2682 : : BuildString - Converts a string into a symbol.
2683 : :
2684 : :
2685 : : Stack
2686 : :
2687 : : Entry Exit
2688 : :
2689 : : Ptr -> <- Ptr
2690 : : +-------------+ +--------------------+
2691 : : | Name | | tok| | Sym | NulSym | tok |
2692 : : |-------------+ |--------------------|
2693 : : */
2694 : :
2695 : 89128 : extern "C" void P2SymBuild_BuildString (void)
2696 : : {
2697 : 89128 : NameKey_Name name;
2698 : 89128 : unsigned int Sym;
2699 : 89128 : unsigned int tok;
2700 : :
2701 : 89128 : M2Quads_PopTtok (&name, &tok);
2702 : : /* slice off the leading and trailing quotes */
2703 : 89128 : if (name == 1140)
2704 : : {
2705 : 89128 : stop ();
2706 : : }
2707 : 89128 : Sym = SymbolTable_MakeConstString (tok, NameKey_makekey (DynamicStrings_string (DynamicStrings_Mark (DynamicStrings_Slice (DynamicStrings_Mark (DynamicStrings_InitStringCharStar (NameKey_KeyToCharStar (name))), 1, -1)))));
2708 : 89128 : M2Quads_PushTFtok (Sym, static_cast<unsigned int> (SymbolTable_NulSym), tok);
2709 : 89128 : M2Quads_Annotate ((const char *) "%1s(%1d)|%3d||constant string", 29);
2710 : 89128 : }
2711 : :
2712 : :
2713 : : /*
2714 : : BuildConst - builds a constant.
2715 : : Stack
2716 : :
2717 : : Entry Exit
2718 : :
2719 : : Ptr ->
2720 : : +------------+
2721 : : | Name |
2722 : : |------------+ <- Ptr
2723 : : */
2724 : :
2725 : 237123 : extern "C" void P2SymBuild_BuildConst (void)
2726 : : {
2727 : 237123 : NameKey_Name name;
2728 : 237123 : unsigned int sym;
2729 : 237123 : unsigned int tok;
2730 : :
2731 : 237123 : M2Quads_PopTtok (&name, &tok);
2732 : 237123 : sym = SymbolTable_MakeConstVar (tok, name);
2733 : 237123 : M2Quads_PushTtok (sym, tok);
2734 : 237123 : P2SymBuild_RememberConstant (sym);
2735 : 237123 : M2Quads_Annotate ((const char *) "%1s(%1d)|%3d||remembered constant", 33);
2736 : 237123 : }
2737 : :
2738 : :
2739 : : /*
2740 : : StartBuildEnumeration - Builds an Enumeration type Type.
2741 : :
2742 : :
2743 : : Stack
2744 : :
2745 : : Entry Exit
2746 : :
2747 : : Ptr ->
2748 : : +------------+
2749 : : | # |
2750 : : |------------|
2751 : : | en 1 |
2752 : : |------------|
2753 : : | en 2 |
2754 : : |------------|
2755 : : . .
2756 : : . .
2757 : : . . <- Ptr
2758 : : |------------| +------------+
2759 : : | en # | | Type |
2760 : : |------------| |------------|
2761 : : | Name | | Name |
2762 : : |------------| |------------|
2763 : : */
2764 : :
2765 : 22704 : extern "C" void P2SymBuild_StartBuildEnumeration (void)
2766 : : {
2767 : 22704 : unsigned int n;
2768 : 22704 : unsigned int Type;
2769 : 22704 : unsigned int tok;
2770 : :
2771 : 22704 : M2Quads_PopT (&n); /* n := # */
2772 : : /* name is in OperandT(n+1) but we dont need it here. */
2773 : 22704 : tok = static_cast<unsigned int> (M2Quads_OperandTok (n+1));
2774 : 22704 : FifoQueue_GetEnumerationFromFifoQueue (&Type);
2775 : 22704 : SymbolTable_CheckForExportedImplementation (Type); /* May be an exported hidden type */
2776 : 22704 : M2Quads_PopN (n); /* May be an exported hidden type */
2777 : 22704 : M2Quads_PushTtok (Type, tok);
2778 : 22704 : M2Quads_Annotate ((const char *) "%1s(%1d)|%3d||enumerated type", 29);
2779 : 22704 : }
2780 : :
2781 : :
2782 : : /*
2783 : : BuildSubrange - Builds a Subrange type Symbol, the base type can also be
2784 : : supplied if known.
2785 : :
2786 : : Stack
2787 : :
2788 : : Entry Exit
2789 : :
2790 : :
2791 : : <- Ptr
2792 : : +------------+
2793 : : Ptr -> | Type |
2794 : : +------------+ |------------|
2795 : : | Name | | Name |
2796 : : |------------| |------------|
2797 : : */
2798 : :
2799 : 81938 : extern "C" void P2SymBuild_BuildSubrange (unsigned int Base)
2800 : : {
2801 : 81938 : NameKey_Name name;
2802 : 81938 : unsigned int Type;
2803 : 81938 : unsigned int tok;
2804 : :
2805 : 81938 : M2Quads_PopTtok (&name, &tok);
2806 : 81938 : Type = SymbolTable_MakeSubrange (tok, name);
2807 : 81938 : FifoQueue_PutSubrangeIntoFifoQueue (Type); /* Store Subrange away so that we can fill in */
2808 : : /* its bounds during pass 3. */
2809 : 81938 : FifoQueue_PutSubrangeIntoFifoQueue (Base); /* store Base type of subrange away as well. */
2810 : 81938 : SymbolTable_CheckForExportedImplementation (Type); /* May be an exported hidden type */
2811 : 81938 : M2Quads_PushTtok (name, tok); /* May be an exported hidden type */
2812 : 81938 : M2Quads_Annotate ((const char *) "%1n|%3d||subrange name|token no", 31);
2813 : 81938 : M2Quads_PushTtok (Type, tok);
2814 : 81938 : M2Quads_Annotate ((const char *) "%1s(%1d)|%3d||subrange type|token no", 36);
2815 : 81938 : }
2816 : :
2817 : :
2818 : : /*
2819 : : BuildAligned - builds an alignment constant symbol which is placed onto
2820 : : the stack. It expects the ident ALIGNED to be on the
2821 : : stack.
2822 : :
2823 : : Stack
2824 : :
2825 : : Entry Exit
2826 : :
2827 : :
2828 : : Ptr -> <- Ptr
2829 : : +---------------+ +-----------------+
2830 : : | bytealignment | | AlignmentConst |
2831 : : +---------------+ |-----------------|
2832 : : */
2833 : :
2834 : 72 : extern "C" void P2SymBuild_BuildAligned (void)
2835 : : {
2836 : 72 : unsigned int tok;
2837 : 72 : NameKey_Name name;
2838 : 72 : unsigned int align;
2839 : :
2840 : 72 : M2Quads_PopTtok (&name, &tok);
2841 : 72 : if (name == (NameKey_MakeKey ((const char *) "bytealignment", 13)))
2842 : : {
2843 : 72 : align = SymbolTable_MakeTemporary (tok, SymbolTable_ImmediateValue);
2844 : 72 : SymbolTable_PutConst (align, M2Base_ZType);
2845 : 72 : FifoQueue_PutConstIntoFifoQueue (align); /* Store align away so that we can fill in its */
2846 : 72 : M2Quads_PushT (align); /* value during pass 3. */
2847 : 72 : M2Quads_Annotate ((const char *) "%1s(%1d)|%3d||bytealignment constant generated from <* *>|token no", 66); /* value during pass 3. */
2848 : 72 : M2Quads_PushTtok (name, tok);
2849 : : }
2850 : : else
2851 : : {
2852 : 0 : M2Error_WriteFormat1 ((const char *) "expecting bytealignment identifier, rather than %a", 50, (const unsigned char *) &name, (sizeof (name)-1));
2853 : 0 : M2Quads_PushT (static_cast<unsigned int> (SymbolTable_NulSym));
2854 : : }
2855 : 72 : M2Quads_Annotate ((const char *) "%1n(%1d)||bytealignment constant generated from <* *>", 53);
2856 : 72 : }
2857 : :
2858 : :
2859 : : /*
2860 : : BuildVarAlignment - the AlignmentConst is either a temporary or NulSym.
2861 : : A type may only have one alignment value and
2862 : : error checking is performed.
2863 : :
2864 : : Stack
2865 : :
2866 : : Entry Exit
2867 : :
2868 : :
2869 : : Ptr ->
2870 : : +-----------------+
2871 : : | AlignmentConst | <- Ptr
2872 : : |-----------------| +------------------+
2873 : : | Type | | Type | TypeName |
2874 : : |-----------------| |------------------|
2875 : : */
2876 : :
2877 : 801798 : extern "C" void P2SymBuild_BuildVarAlignment (void)
2878 : : {
2879 : 801798 : unsigned int tokno;
2880 : 801798 : NameKey_Name alignment;
2881 : 801798 : NameKey_Name newname;
2882 : 801798 : unsigned int new_;
2883 : 801798 : unsigned int type;
2884 : 801798 : unsigned int align;
2885 : 801798 : DynamicStrings_String s;
2886 : :
2887 : 801798 : M2Quads_PopT (&alignment);
2888 : 801798 : if (alignment == (NameKey_MakeKey ((const char *) "bytealignment", 13)))
2889 : : {
2890 : 42 : M2Quads_PopT (&align);
2891 : 42 : M2Quads_PopTtok (&type, &tokno);
2892 : 42 : if (((((SymbolTable_IsRecord (type)) || (SymbolTable_IsRecordField (type))) || (SymbolTable_IsType (type))) || (SymbolTable_IsArray (type))) || (SymbolTable_IsPointer (type)))
2893 : : {
2894 : 42 : stop ();
2895 : 42 : if (SymbolTable_IsNameAnonymous (type))
2896 : : {
2897 : 30 : SymbolTable_PutAlignment (type, align);
2898 : 30 : M2Quads_PushTFtok (type, SymbolTable_GetSymName (type), tokno);
2899 : 30 : M2Quads_Annotate ((const char *) "%1s(%1d)|%2n|%3d||aligned type|aligned type name|token no", 57);
2900 : : }
2901 : : else
2902 : : {
2903 : : /* create a pseudonym */
2904 : 12 : s = FormatStrings_Sprintf1 (DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "_$A%d", 5)), (const unsigned char *) &alignTypeNo, (sizeof (alignTypeNo)-1));
2905 : 12 : alignTypeNo += 1;
2906 : 12 : newname = NameKey_makekey (DynamicStrings_string (s));
2907 : 12 : if (SymbolTable_IsPointer (type))
2908 : : {
2909 : 0 : new_ = SymbolTable_MakePointer (tokno, newname);
2910 : : }
2911 : : else
2912 : : {
2913 : 12 : new_ = SymbolTable_MakeType (tokno, newname);
2914 : : }
2915 : 12 : s = DynamicStrings_KillString (s);
2916 : 12 : SymbolTable_PutType (new_, type);
2917 : 12 : SymbolTable_PutAlignment (new_, align);
2918 : 12 : M2Quads_PushTFtok (new_, SymbolTable_GetSymName (new_), tokno);
2919 : 12 : M2Quads_Annotate ((const char *) "%1s(%1d)|%2n|%3d||aligned type|aligned type name", 48);
2920 : : }
2921 : : }
2922 : : else
2923 : : {
2924 : 0 : M2MetaError_MetaError1 ((const char *) "not allowed to add an alignment attribute to type {%1ad}", 56, type);
2925 : 0 : M2Quads_PushTFtok (type, SymbolTable_GetSymName (type), tokno);
2926 : 0 : M2Quads_Annotate ((const char *) "%1s(%1d)|%2n|%3d||error aligned type|error aligned type name", 60);
2927 : : }
2928 : : }
2929 : 801756 : else if (alignment != NameKey_NulName)
2930 : : {
2931 : : /* avoid dangling else. */
2932 : 0 : M2Error_WriteFormat1 ((const char *) "unknown variable alignment attribute, %a", 40, (const unsigned char *) &alignment, (sizeof (alignment)-1));
2933 : : }
2934 : 801798 : }
2935 : :
2936 : :
2937 : : /*
2938 : : BuildTypeAlignment - the AlignmentConst is either a temporary or NulSym.
2939 : : In the case of NulSym it is popped from the stack
2940 : : and the procedure returns. Otherwise the temporary
2941 : : is popped and recorded as the alignment value for this
2942 : : type. A type may only have one alignment value and
2943 : : error checking is performed.
2944 : :
2945 : : Stack
2946 : :
2947 : : Entry Exit
2948 : :
2949 : :
2950 : : Ptr ->
2951 : : +-----------------+
2952 : : | AlignmentConst |
2953 : : |-----------------|
2954 : : | Type | Empty
2955 : : |-----------------|
2956 : : */
2957 : :
2958 : 72312 : extern "C" void P2SymBuild_BuildTypeAlignment (void)
2959 : : {
2960 : 72312 : NameKey_Name alignment;
2961 : 72312 : unsigned int type;
2962 : 72312 : unsigned int align;
2963 : :
2964 : 72312 : M2Quads_PopT (&alignment);
2965 : 72312 : if (alignment == (NameKey_MakeKey ((const char *) "bytealignment", 13)))
2966 : : {
2967 : : /* avoid dangling else. */
2968 : 30 : M2Quads_PopT (&align);
2969 : 30 : M2Quads_PopT (&type);
2970 : 30 : if (align != SymbolTable_NulSym)
2971 : : {
2972 : : /* avoid gcc warning by using compound statement even if not strictly necessary. */
2973 : 30 : if ((((((SymbolTable_IsRecord (type)) || (SymbolTable_IsRecordField (type))) || (SymbolTable_IsType (type))) || (SymbolTable_IsArray (type))) || (SymbolTable_IsPointer (type))) || (SymbolTable_IsSubrange (type)))
2974 : : {
2975 : 30 : SymbolTable_PutAlignment (type, align);
2976 : : }
2977 : : else
2978 : : {
2979 : 0 : M2MetaError_MetaError1 ((const char *) "not allowed to add an alignment attribute to type {%1ad}", 56, type);
2980 : : }
2981 : : }
2982 : : }
2983 : 72282 : else if (alignment != NameKey_NulName)
2984 : : {
2985 : : /* avoid dangling else. */
2986 : 0 : M2Error_WriteFormat1 ((const char *) "unknown type alignment attribute, %a", 36, (const unsigned char *) &alignment, (sizeof (alignment)-1));
2987 : : }
2988 : : else
2989 : : {
2990 : : /* avoid dangling else. */
2991 : 72282 : M2Quads_PopT (&type);
2992 : : }
2993 : 72312 : }
2994 : :
2995 : 36 : extern "C" void P2SymBuild_P2BuildDefaultFieldAlignment (void)
2996 : : {
2997 : 36 : unsigned int tok;
2998 : 36 : NameKey_Name alignment;
2999 : 36 : unsigned int align;
3000 : :
3001 : : /*
3002 : : BuildDefaultFieldAlignment -
3003 : :
3004 : : The Stack:
3005 : :
3006 : : Entry Exit
3007 : : ===== ====
3008 : :
3009 : :
3010 : : Ptr ->
3011 : : +-----------+
3012 : : | Alignment |
3013 : : |-----------| +-----------+
3014 : : | RecordSym | | RecordSym |
3015 : : |-----------| |-----------|
3016 : : | Name | | Name |
3017 : : |-----------| |-----------|
3018 : :
3019 : : */
3020 : 36 : M2Quads_PopTtok (&alignment, &tok);
3021 : 36 : align = SymbolTable_MakeTemporary (tok, SymbolTable_ImmediateValue);
3022 : 36 : SymbolTable_PutConst (align, M2Base_ZType);
3023 : 36 : FifoQueue_PutConstIntoFifoQueue (align); /* store align away ready for pass 3 */
3024 : 36 : SymbolTable_PutDefaultRecordFieldAlignment (M2Quads_OperandT (1), align); /* store align away ready for pass 3 */
3025 : 36 : }
3026 : :
3027 : :
3028 : : /*
3029 : : BuildPragmaConst - pushes a constant to the stack and stores it away into the
3030 : : const fifo queue ready for pass 3.
3031 : : */
3032 : :
3033 : 12 : extern "C" void P2SymBuild_BuildPragmaConst (void)
3034 : : {
3035 : 12 : unsigned int value;
3036 : :
3037 : 12 : value = SymbolTable_MakeTemporary (M2LexBuf_GetTokenNo (), SymbolTable_ImmediateValue);
3038 : 12 : SymbolTable_PutConst (value, M2Base_ZType);
3039 : 12 : FifoQueue_PutConstIntoFifoQueue (value); /* Store value away so that we can fill it in */
3040 : 12 : M2Quads_PushT (value); /* during pass 3. */
3041 : 12 : M2Quads_Annotate ((const char *) "%1s(%1d)||pragma constant", 25); /* during pass 3. */
3042 : 12 : }
3043 : :
3044 : :
3045 : : /*
3046 : : BuildVariable - Builds variables listed in an IdentList with a Type.
3047 : :
3048 : : Stack
3049 : :
3050 : : Entry Exit
3051 : :
3052 : : Ptr ->
3053 : : +------------+ +------------+
3054 : : | Type | Name| | |
3055 : : |------------| |------------|
3056 : : | # | | |
3057 : : |------------| |------------|
3058 : : | Ident 1 | | |
3059 : : |------------| |------------|
3060 : : | Ident 2 | | |
3061 : : |------------| |------------|
3062 : : . . . .
3063 : : . . . .
3064 : : . . . .
3065 : : |------------| |------------|
3066 : : | Ident # | | | <- Ptr
3067 : : |------------| |------------|
3068 : :
3069 : : Empty
3070 : : */
3071 : :
3072 : 701776 : extern "C" void P2SymBuild_BuildVariable (void)
3073 : : {
3074 : 701776 : NameKey_Name name;
3075 : 701776 : unsigned int tok;
3076 : 701776 : unsigned int typetok;
3077 : 701776 : unsigned int AtAddress;
3078 : 701776 : unsigned int Type;
3079 : 701776 : unsigned int Var;
3080 : 701776 : unsigned int i;
3081 : 701776 : unsigned int n;
3082 : :
3083 : 701776 : M2Quads_PopTFtok (&Type, &name, &typetok);
3084 : 701776 : M2Quads_PopT (&n);
3085 : 701776 : i = 1;
3086 : 2338434 : while (i <= n)
3087 : : {
3088 : 934894 : M2Students_CheckVariableAgainstKeyword (M2Quads_OperandT ((n+1)-i));
3089 : 934894 : tok = static_cast<unsigned int> (M2Quads_OperandTok ((n+1)-i));
3090 : 934894 : Var = SymbolTable_MakeVar (tok, M2Quads_OperandT ((n+1)-i));
3091 : 934894 : AtAddress = static_cast<unsigned int> (M2Quads_OperandA ((n+1)-i));
3092 : 934894 : if (AtAddress != SymbolTable_NulSym)
3093 : : {
3094 : 54 : SymbolTable_PutVariableAtAddress (Var, SymbolTable_NulSym);
3095 : 54 : SymbolTable_PutMode (Var, SymbolTable_LeftValue);
3096 : : }
3097 : 934894 : SymbolTable_PutVarTok (Var, Type, typetok);
3098 : 934882 : if (tok != M2LexBuf_UnknownTokenNo)
3099 : : {
3100 : 934882 : SymbolTable_PutDeclared (tok, Var);
3101 : 934882 : SymbolTable_PutVarDeclTok (Var, tok);
3102 : : }
3103 : 934882 : i += 1;
3104 : : }
3105 : 701764 : M2Quads_PopN (n);
3106 : 701764 : }
3107 : :
3108 : :
3109 : : /*
3110 : : BuildType - Builds a Type.
3111 : :
3112 : :
3113 : : Stack
3114 : :
3115 : : Entry Exit
3116 : :
3117 : : Ptr ->
3118 : : +------------+
3119 : : | Type | <- Ptr
3120 : : |------------| +---------------+
3121 : : | Name | | Type | Name |
3122 : : |------------| |---------------|
3123 : :
3124 : : Empty
3125 : : */
3126 : :
3127 : 1338890 : extern "C" void P2SymBuild_BuildType (void)
3128 : : {
3129 : 1338890 : bool isunknown;
3130 : 1338890 : NameKey_Name n1;
3131 : 1338890 : NameKey_Name n2;
3132 : 1338890 : unsigned int Sym;
3133 : 1338890 : unsigned int Type;
3134 : 1338890 : NameKey_Name name;
3135 : 1338890 : unsigned int tokno;
3136 : :
3137 : : /*
3138 : : Two cases
3139 : :
3140 : : - the type name the same as Name, or the name is nul. - do nothing.
3141 : : - when type with a name that is different to Name. In which case
3142 : : we create a new type.
3143 : : */
3144 : 1338890 : M2Quads_PopTtok (&Type, &tokno);
3145 : 1338890 : M2Quads_PopT (&name);
3146 : 1338890 : if (Debugging)
3147 : : {
3148 : : n1 = SymbolTable_GetSymName (SymbolTable_GetCurrentModule ());
3149 : : M2Printf_printf2 ((const char *) "inside module %a declaring type name %a\\n", 41, (const unsigned char *) &n1, (sizeof (n1)-1), (const unsigned char *) &name, (sizeof (name)-1));
3150 : : if (! (SymbolTable_IsUnknown (Type)))
3151 : : {
3152 : : n1 = SymbolTable_GetSymName (SymbolTable_GetScope (Type));
3153 : : n2 = SymbolTable_GetSymName (Type);
3154 : : M2Printf_printf2 ((const char *) "type was created inside scope %a as name %a\\n", 45, (const unsigned char *) &n1, (sizeof (n1)-1), (const unsigned char *) &n2, (sizeof (n2)-1));
3155 : : }
3156 : : }
3157 : 1338890 : if (name == NameKey_NulName)
3158 : : {
3159 : : /* WriteString('Blank name type') ; WriteLn ; */
3160 : 1136152 : M2Quads_PushTFtok (Type, name, tokno);
3161 : 1136152 : M2Quads_Annotate ((const char *) "%1s(%1d)|%2n|%3d||type|type name|token no", 41);
3162 : : }
3163 : 202738 : else if (SymbolTable_IsError (Type))
3164 : : {
3165 : : /* avoid dangling else. */
3166 : 0 : M2Quads_PushTFtok (Type, name, tokno);
3167 : 0 : M2Quads_Annotate ((const char *) "%1s(%1d)|%2n|%3d||error type|error type name|token no", 53);
3168 : : }
3169 : 202738 : else if ((SymbolTable_GetSymName (Type)) == name)
3170 : : {
3171 : : /* avoid dangling else. */
3172 : 188338 : isunknown = SymbolTable_IsUnknown (Type);
3173 : 188338 : if (isunknown || (! (SymbolTable_IsDeclaredIn (SymbolTable_GetCurrentScope (), Type))))
3174 : : {
3175 : 1428 : Sym = SymbolTable_MakeType (tokno, name);
3176 : 1428 : if (! (SymbolTable_IsError (Sym)))
3177 : : {
3178 : : /* avoid gcc warning by using compound statement even if not strictly necessary. */
3179 : 1422 : if (Sym == Type)
3180 : : {
3181 : 0 : if (isunknown)
3182 : : {
3183 : 0 : M2MetaError_MetaError2 ((const char *) "attempting to declare a type {%1ad} to a type which is itself and also unknown {%2ad}", 85, Sym, Type);
3184 : : }
3185 : : else
3186 : : {
3187 : 0 : M2MetaError_MetaError1 ((const char *) "attempting to declare a type {%1ad} as itself", 45, Sym);
3188 : : }
3189 : : }
3190 : : else
3191 : : {
3192 : 1422 : SymbolTable_PutType (Sym, Type);
3193 : 1422 : SymbolTable_CheckForExportedImplementation (Sym); /* May be an exported hidden type */
3194 : : /* if Type is an enumerated type then add its contents to the pseudo scope */
3195 : 1422 : SymbolTable_CheckForEnumerationInCurrentModule (Type);
3196 : : }
3197 : : }
3198 : 1428 : M2Quads_PushTFtok (Sym, name, tokno);
3199 : 1428 : M2Quads_Annotate ((const char *) "%1s(%1d)|%2n|%3d||type|type name|token no", 41);
3200 : : }
3201 : : else
3202 : : {
3203 : 186910 : M2Quads_PushTFtok (Type, name, tokno);
3204 : 186910 : M2Quads_Annotate ((const char *) "%1s(%1d)|%2n|%3d||type|type name|token no", 41);
3205 : : }
3206 : : }
3207 : : else
3208 : : {
3209 : : /* avoid dangling else. */
3210 : : /* example TYPE a = CARDINAL */
3211 : 14400 : Sym = SymbolTable_MakeType (tokno, name);
3212 : 14400 : SymbolTable_PutType (Sym, Type);
3213 : 14400 : SymbolTable_CheckForExportedImplementation (Sym); /* May be an exported hidden type */
3214 : 14400 : M2Quads_PushTFtok (Sym, name, tokno); /* May be an exported hidden type */
3215 : 14400 : M2Quads_Annotate ((const char *) "%1s(%1d)|%2n|%3d||type|type name|token no", 41);
3216 : : }
3217 : 1338890 : }
3218 : :
3219 : :
3220 : : /*
3221 : : StartBuildFormalParameters - Initialises the quadruple stack for
3222 : : Formal Parameters.
3223 : :
3224 : : The Stack:
3225 : :
3226 : : Entry Exit
3227 : :
3228 : : <- Ptr
3229 : : +------------+
3230 : : Empty | 0 |
3231 : : |------------|
3232 : : */
3233 : :
3234 : 2871064 : extern "C" void P2SymBuild_StartBuildFormalParameters (void)
3235 : : {
3236 : 2871064 : M2Quads_PushT (static_cast<unsigned int> (0));
3237 : 2871064 : M2Quads_Annotate ((const char *) "%1d||running total of no. of parameters", 39);
3238 : 2871064 : }
3239 : :
3240 : :
3241 : : /*
3242 : : EndBuildFormalParameters - Resets the quadruple stack after building
3243 : : Formal Parameters.
3244 : :
3245 : : The Stack:
3246 : :
3247 : : Entry Exit
3248 : :
3249 : : Ptr ->
3250 : : +------------+
3251 : : | NoOfParam | <- Ptr
3252 : : |------------| +------------+
3253 : : | ProcSym | | ProcSym |
3254 : : |------------| |------------|
3255 : : */
3256 : :
3257 : 2871064 : extern "C" void P2SymBuild_EndBuildFormalParameters (void)
3258 : : {
3259 : 2871064 : SymbolTable_ProcedureKind kind;
3260 : 2871064 : SymbolTable_ProcedureKind curkind;
3261 : 2871064 : unsigned int tok;
3262 : 2871064 : unsigned int NoOfPar;
3263 : 2871064 : unsigned int ProcSym;
3264 : :
3265 : 2871064 : M2Quads_PopT (&NoOfPar);
3266 : 2871064 : M2Quads_PopTtok (&ProcSym, &tok);
3267 : 2871064 : M2Quads_PushTtok (ProcSym, tok);
3268 : 2871064 : M2Quads_Annotate ((const char *) "%1s(%1d)||procedure start symbol", 32);
3269 : 2871064 : M2Debug_Assert (SymbolTable_IsProcedure (ProcSym));
3270 : 2871064 : curkind = SymbolTable_GetProcedureKind (ProcSym, tok);
3271 : 14355320 : for (kind=SymbolTable_ProperProcedure; kind<=SymbolTable_DefProcedure; kind= static_cast<SymbolTable_ProcedureKind>(static_cast<int>(kind+1)))
3272 : : {
3273 : 8613192 : if (((SymbolTable_GetProcedureParametersDefined (ProcSym, kind)) && (curkind != kind)) && ((SymbolTable_NoOfParam (ProcSym, kind)) != NoOfPar))
3274 : : {
3275 : 18 : ParameterMismatch (tok, ProcSym, NoOfPar, kind, curkind);
3276 : : }
3277 : : }
3278 : : /* All parameter seen so set procedure defined. */
3279 : 2871064 : SymbolTable_PutProcedureParametersDefined (ProcSym, curkind);
3280 : 2871064 : M2Debug_Assert (SymbolTable_IsProcedure (M2Quads_OperandT (1)));
3281 : 2871064 : }
3282 : :
3283 : :
3284 : : /*
3285 : : BuildProcedureHeading - Builds a procedure heading for the definition
3286 : : module procedures.
3287 : :
3288 : : Operation only performed if compiling a
3289 : : definition module.
3290 : :
3291 : : The Stack:
3292 : :
3293 : : Entry Exit
3294 : :
3295 : : Ptr ->
3296 : : +------------+
3297 : : | ProcSym |
3298 : : |------------|
3299 : : | NameStart |
3300 : : |------------|
3301 : : Empty
3302 : :
3303 : : */
3304 : :
3305 : 2871064 : extern "C" void P2SymBuild_BuildProcedureHeading (void)
3306 : : {
3307 : 2871064 : unsigned int tok;
3308 : 2871064 : unsigned int ProcSym;
3309 : 2871064 : NameKey_Name NameStart;
3310 : :
3311 : 2871064 : ProcSym = static_cast<unsigned int> (M2Quads_OperandT (1));
3312 : 2871064 : tok = static_cast<unsigned int> (M2Quads_OperandTok (1));
3313 : 2871064 : SymbolTable_PutProcedureParametersDefined (ProcSym, SymbolTable_GetProcedureKind (ProcSym, tok));
3314 : 2871064 : if (M2Comp_CompilingDefinitionModule ())
3315 : : {
3316 : 1927561 : M2Quads_PopT (&ProcSym);
3317 : 1927561 : M2Debug_Assert (SymbolTable_IsProcedure (ProcSym));
3318 : 1927561 : M2Quads_PopT (&NameStart);
3319 : 1927561 : SymbolTable_EndScope ();
3320 : : }
3321 : 2871064 : }
3322 : :
3323 : :
3324 : : /*
3325 : : BuildFunction - Builds a procedures return type.
3326 : : Procedure becomes a function.
3327 : :
3328 : : The Stack:
3329 : :
3330 : : Entry Exit
3331 : :
3332 : : Ptr ->
3333 : : +------------+
3334 : : | TypeSym | <- Ptr
3335 : : |------------| +------------+
3336 : : | ProcSym | | ProcSym |
3337 : : |------------| |------------|
3338 : : */
3339 : :
3340 : 1146818 : extern "C" void P2SymBuild_BuildFunction (void)
3341 : : {
3342 : 1146818 : unsigned int tok;
3343 : 1146818 : unsigned int ProcSym;
3344 : 1146818 : unsigned int typetok;
3345 : 1146818 : unsigned int RetType;
3346 : :
3347 : 1146818 : M2Quads_PopTtok (&RetType, &typetok);
3348 : 1146818 : M2Quads_PopTtok (&ProcSym, &tok);
3349 : 1146818 : M2Quads_PushTtok (ProcSym, tok);
3350 : 1146818 : SymbolTable_PutFunction (typetok, ProcSym, SymbolTable_GetProcedureKind (ProcSym, tok), RetType);
3351 : 1146818 : CheckOptFunction (tok, ProcSym, SymbolTable_GetProcedureKind (ProcSym, tok), false);
3352 : 1146818 : CheckProcedureReturn (RetType, typetok);
3353 : 1146818 : }
3354 : :
3355 : :
3356 : : /*
3357 : : BuildOptFunction - Builds a procedures optional return type.
3358 : : Procedure becomes a function and the user
3359 : : can either call it as a function or a procedure.
3360 : :
3361 : : The Stack:
3362 : :
3363 : : Entry Exit
3364 : :
3365 : : Ptr ->
3366 : : +------------+
3367 : : | TypeSym | <- Ptr
3368 : : |------------| +------------+
3369 : : | ProcSym | | ProcSym |
3370 : : |------------| |------------|
3371 : : */
3372 : :
3373 : 121146 : extern "C" void P2SymBuild_BuildOptFunction (void)
3374 : : {
3375 : 121146 : unsigned int typetok;
3376 : 121146 : unsigned int tok;
3377 : 121146 : unsigned int RetType;
3378 : 121146 : unsigned int ProcSym;
3379 : :
3380 : 121146 : M2Quads_PopTtok (&RetType, &typetok);
3381 : 121146 : M2Quads_PopTtok (&ProcSym, &tok);
3382 : 121146 : SymbolTable_PutOptFunction (typetok, ProcSym, SymbolTable_GetProcedureKind (ProcSym, tok), RetType);
3383 : 121146 : CheckOptFunction (tok, ProcSym, SymbolTable_GetProcedureKind (ProcSym, tok), true);
3384 : 121146 : M2Quads_PushTtok (ProcSym, tok);
3385 : 121146 : }
3386 : :
3387 : :
3388 : : /*
3389 : : BuildFPSection - Builds a Formal Parameter in a procedure.
3390 : :
3391 : : The Stack:
3392 : :
3393 : : Entry Exit
3394 : :
3395 : : Ptr ->
3396 : : +------------+
3397 : : | ParamTotal |
3398 : : |------------|
3399 : : | TypeSym |
3400 : : |------------|
3401 : : | Array/Nul |
3402 : : |------------|
3403 : : | NoOfIds |
3404 : : |------------|
3405 : : | Id 1 |
3406 : : |------------|
3407 : : . .
3408 : : . .
3409 : : . .
3410 : : |------------|
3411 : : | Id n | <- Ptr
3412 : : |------------| +------------+
3413 : : | Var / Nul | | ParamTotal |
3414 : : |------------| |------------|
3415 : : | ProcSym | | ProcSym |
3416 : : |------------| |------------|
3417 : : */
3418 : :
3419 : 4853017 : extern "C" void P2SymBuild_BuildFPSection (void)
3420 : : {
3421 : 4853017 : SymbolTable_ProcedureKind kind;
3422 : 4853017 : SymbolTable_ProcedureKind curkind;
3423 : 4853017 : unsigned int tok;
3424 : 4853017 : unsigned int top;
3425 : 4853017 : unsigned int ProcSym;
3426 : 4853017 : unsigned int ParamTotal;
3427 : :
3428 : 4853017 : top = M2Quads_Top ();
3429 : 4853017 : M2Quads_PopT (&ParamTotal);
3430 : 4853017 : ProcSym = (unsigned int ) (M2Quads_OperandT ((3+((unsigned int ) (M2Quads_OperandT (3))))+2));
3431 : 4853017 : tok = (unsigned int ) (M2Quads_OperandTok ((3+((unsigned int ) (M2Quads_OperandT (3))))+2));
3432 : 4853017 : Debug (ProcSym, (const char *) "foo", 3);
3433 : 4853017 : curkind = SymbolTable_GetProcedureKind (ProcSym, tok);
3434 : 4853017 : M2Quads_PushT (ParamTotal);
3435 : 4853017 : M2Quads_Annotate ((const char *) "%1d||running total of no. of parameters", 39);
3436 : 9706034 : M2Debug_Assert ((SymbolTable_IsProcedure (ProcSym)) || (SymbolTable_IsProcType (ProcSym)));
3437 : 4853017 : M2Debug_Assert (top == (M2Quads_Top ()));
3438 : 4853017 : ProcSym = (unsigned int ) (M2Quads_OperandT (((3+((unsigned int ) (M2Quads_OperandT (3+1))))+2)+1));
3439 : 9706034 : M2Debug_Assert ((SymbolTable_IsProcedure (ProcSym)) || (SymbolTable_IsProcType (ProcSym)));
3440 : 4853017 : if (! (SymbolTable_GetProcedureParametersDefined (ProcSym, curkind)))
3441 : : {
3442 : 4853017 : BuildFormalParameterSection (curkind);
3443 : : }
3444 : 19412068 : for (kind=SymbolTable_ProperProcedure; kind<=SymbolTable_DefProcedure; kind= static_cast<SymbolTable_ProcedureKind>(static_cast<int>(kind+1)))
3445 : : {
3446 : : /* Check against any previous declaration. */
3447 : 14559051 : if ((kind != curkind) && (SymbolTable_GetProcedureParametersDefined (ProcSym, kind)))
3448 : : {
3449 : 989625 : M2Debug_Assert (top == (M2Quads_Top ()));
3450 : 989625 : CheckFormalParameterSection (curkind, kind);
3451 : 989625 : M2Debug_Assert (top == (M2Quads_Top ()));
3452 : : }
3453 : 14559051 : ProcSym = (unsigned int ) (M2Quads_OperandT (((3+((unsigned int ) (M2Quads_OperandT (3+1))))+2)+1));
3454 : 29118102 : M2Debug_Assert ((SymbolTable_IsProcedure (ProcSym)) || (SymbolTable_IsProcType (ProcSym)));
3455 : : }
3456 : 4853017 : RemoveFPParameters ();
3457 : 4853017 : M2Debug_Assert (SymbolTable_IsProcedure (M2Quads_OperandT (2)));
3458 : 4853017 : }
3459 : :
3460 : :
3461 : : /*
3462 : : BuildVarArgs - indicates that the ProcSym takes varargs
3463 : : after ParamTotal.
3464 : : <- Ptr
3465 : : +------------+ +------------+
3466 : : | ParamTotal | | ParamTotal |
3467 : : |------------| |------------|
3468 : : | ProcSym | | ProcSym |
3469 : : |------------| |------------|
3470 : :
3471 : : */
3472 : :
3473 : 10740 : extern "C" void P2SymBuild_BuildVarArgs (void)
3474 : : {
3475 : 10740 : SymbolTable_ProcedureKind kind;
3476 : 10740 : unsigned int tok;
3477 : 10740 : unsigned int ProcSym;
3478 : 10740 : unsigned int ParamTotal;
3479 : :
3480 : 10740 : M2Quads_PopT (&ParamTotal);
3481 : 10740 : M2Quads_PopTtok (&ProcSym, &tok);
3482 : 10740 : kind = SymbolTable_GetProcedureKind (ProcSym, tok);
3483 : 10740 : if (SymbolTable_UsesOptArg (ProcSym, kind))
3484 : : {
3485 : 0 : M2Error_WriteFormat0 ((const char *) "procedure can use either a single optional argument or a single vararg section ... at the end of the formal parameter list", 122);
3486 : : }
3487 : 10740 : if (SymbolTable_UsesVarArgs (ProcSym))
3488 : : {
3489 : 0 : M2Error_WriteFormat0 ((const char *) "procedure can only have one vararg section ... at the end of the formal parameter list", 86);
3490 : : }
3491 : 10740 : SymbolTable_PutUseVarArgs (ProcSym);
3492 : 10740 : if (SymbolTable_IsDefImp (SymbolTable_GetCurrentModule ()))
3493 : : {
3494 : : /* avoid dangling else. */
3495 : 10740 : if (! (SymbolTable_IsDefinitionForC (SymbolTable_GetCurrentModule ())))
3496 : : {
3497 : 0 : M2Error_WriteFormat0 ((const char *) "the definition module must be declared as DEFINITION MODULE FOR \"C\" if varargs are to be used", 93);
3498 : : }
3499 : : }
3500 : : else
3501 : : {
3502 : 0 : M2Error_WriteFormat0 ((const char *) "varargs can only be used in the module declared as DEFINITION MODULE FOR \"C\"", 76);
3503 : : }
3504 : 10740 : M2Quads_PushTtok (ProcSym, tok);
3505 : 10740 : M2Quads_PushT (ParamTotal);
3506 : 10740 : }
3507 : :
3508 : :
3509 : : /*
3510 : : BuildFormalVarArgs - indicates that the procedure type takes varargs.
3511 : :
3512 : : <- Ptr
3513 : : +------------+ +------------+
3514 : : | ProcSym | | ProcSym |
3515 : : |------------| |------------|
3516 : :
3517 : : */
3518 : :
3519 : 0 : extern "C" void P2SymBuild_BuildFormalVarArgs (void)
3520 : : {
3521 : 0 : unsigned int ProcSym;
3522 : :
3523 : 0 : M2Quads_PopT (&ProcSym);
3524 : 0 : if (SymbolTable_UsesVarArgs (ProcSym))
3525 : : {
3526 : 0 : M2Error_WriteFormat0 ((const char *) "procedure type can only have one vararg section ... at the end of the formal parameter list", 91);
3527 : : }
3528 : 0 : SymbolTable_PutUseVarArgs (ProcSym);
3529 : 0 : if (SymbolTable_IsDefImp (SymbolTable_GetCurrentModule ()))
3530 : : {
3531 : : /* avoid dangling else. */
3532 : 0 : if (! (SymbolTable_IsDefinitionForC (SymbolTable_GetCurrentModule ())))
3533 : : {
3534 : 0 : M2Error_WriteFormat0 ((const char *) "the definition module must be declared as DEFINITION MODULE FOR \"C\" if varargs are to be used", 93);
3535 : : }
3536 : : }
3537 : : else
3538 : : {
3539 : 0 : M2Error_WriteFormat0 ((const char *) "varargs can only be used in the module declared as DEFINITION MODULE FOR \"C\"", 76);
3540 : : }
3541 : 0 : M2Quads_PushT (ProcSym);
3542 : 0 : }
3543 : :
3544 : :
3545 : : /*
3546 : : BuildOptArg - indicates that the ProcSym takes a single optarg
3547 : : after ParamTotal.
3548 : :
3549 : : <- Ptr
3550 : : +------------+ +------------+
3551 : : | ParamTotal | | ParamTotal |
3552 : : |------------| |------------|
3553 : : | ProcSym | | ProcSym |
3554 : : |------------| |------------|
3555 : : */
3556 : :
3557 : 16743 : extern "C" void P2SymBuild_BuildOptArg (void)
3558 : : {
3559 : 16743 : SymbolTable_ProcedureKind kind;
3560 : 16743 : unsigned int tok;
3561 : 16743 : unsigned int ProcSym;
3562 : 16743 : unsigned int ParamTotal;
3563 : :
3564 : 16743 : M2Quads_PopT (&ParamTotal);
3565 : 16743 : M2Quads_PopTtok (&ProcSym, &tok);
3566 : 16743 : kind = SymbolTable_GetProcedureKind (ProcSym, tok);
3567 : 16743 : if (SymbolTable_UsesVarArgs (ProcSym))
3568 : : {
3569 : 0 : M2Error_WriteFormat0 ((const char *) "procedure can not use an optional argument after a vararg ...", 61);
3570 : : }
3571 : 16743 : SymbolTable_PutUseOptArg (ProcSym, kind);
3572 : 16743 : M2Quads_PushTtok (ProcSym, tok);
3573 : 16743 : M2Quads_PushT (ParamTotal);
3574 : 16743 : }
3575 : :
3576 : :
3577 : : /*
3578 : : StartBuildProcedure - Builds a Procedure.
3579 : :
3580 : : The Stack:
3581 : :
3582 : : Entry Exit
3583 : :
3584 : : <- Ptr
3585 : : +------------+
3586 : : Ptr -> | ProcSym |
3587 : : +------------+ |------------|
3588 : : | Name | | Name |
3589 : : |------------| |------------|
3590 : : */
3591 : :
3592 : 2871064 : extern "C" void P2SymBuild_StartBuildProcedure (void)
3593 : : {
3594 : 2871064 : NameKey_Name name;
3595 : 2871064 : unsigned int ProcSym;
3596 : 2871064 : unsigned int tokno;
3597 : :
3598 : 2871064 : M2Quads_PopTtok (&name, &tokno);
3599 : 2871064 : M2Quads_PushTtok (name, tokno); /* name saved for the EndBuildProcedure name check */
3600 : 2871064 : M2Quads_Annotate ((const char *) "%1n|(%1d)||procedure name saved by StartBuildProcedure", 54); /* name saved for the EndBuildProcedure name check */
3601 : 2871064 : ProcSym = SymbolTable_GetDeclareSym (tokno, name);
3602 : 2871064 : if (SymbolTable_IsUnknown (ProcSym))
3603 : : {
3604 : : /* May have been compiled in the definition or implementation module.
3605 : : Note we always see an implementation module before its corresponding
3606 : : definition module. */
3607 : 0 : ProcSym = SymbolTable_MakeProcedure (tokno, name);
3608 : : }
3609 : 2871064 : else if (SymbolTable_IsProcedure (ProcSym))
3610 : : {
3611 : : /* avoid dangling else. */
3612 : 2871064 : SymbolTable_PutDeclared (tokno, ProcSym);
3613 : : }
3614 : : else
3615 : : {
3616 : : /* avoid dangling else. */
3617 : 0 : M2Error_ErrorStringAt2 (FormatStrings_Sprintf1 (DynamicStrings_Mark (DynamicStrings_InitString ((const char *) "procedure name (%a) has been declared as another object elsewhere", 65)), (const unsigned char *) &name, (sizeof (name)-1)), tokno, SymbolTable_GetDeclaredMod (ProcSym));
3618 : : }
3619 : 2871064 : if (M2Comp_CompilingDefinitionModule ())
3620 : : {
3621 : 1927561 : SymbolTable_PutExportUnImplemented (tokno, ProcSym); /* Defined but not yet implemented */
3622 : : }
3623 : : else
3624 : : {
3625 : 943503 : SymbolTable_CheckForExportedImplementation (ProcSym); /* May be exported procedure */
3626 : : }
3627 : 2871064 : M2Quads_PushTtok (ProcSym, tokno);
3628 : 2871064 : M2Quads_Annotate ((const char *) "%1s(%1d)||procedure start symbol", 32);
3629 : 2871064 : SymbolTable_StartScope (ProcSym);
3630 : 2871064 : M2Error_EnterProcedureScope (name);
3631 : 2871064 : }
3632 : :
3633 : :
3634 : : /*
3635 : : EndBuildProcedure - Ends building a Procedure.
3636 : : It checks the start procedure name matches the end
3637 : : procedure name.
3638 : :
3639 : : The Stack:
3640 : :
3641 : : (Procedure Not Defined in definition module)
3642 : :
3643 : : Entry Exit
3644 : :
3645 : : Ptr ->
3646 : : +------------+
3647 : : | NameEnd |
3648 : : |------------|
3649 : : | ProcSym |
3650 : : |------------|
3651 : : | NameStart |
3652 : : |------------|
3653 : : Empty
3654 : : */
3655 : :
3656 : 943455 : extern "C" void P2SymBuild_EndBuildProcedure (void)
3657 : : {
3658 : 943455 : NameKey_Name NameEnd;
3659 : 943455 : NameKey_Name NameStart;
3660 : 943455 : unsigned int tok;
3661 : 943455 : unsigned int ProcSym;
3662 : 943455 : SymbolTable_ProcedureKind kind;
3663 : :
3664 : 943455 : M2Quads_PopT (&NameEnd);
3665 : 943455 : M2Quads_PopTtok (&ProcSym, &tok);
3666 : 943455 : M2Debug_Assert (SymbolTable_IsProcedure (ProcSym));
3667 : 943455 : kind = SymbolTable_GetProcedureKind (ProcSym, tok);
3668 : 943455 : M2Quads_PopT (&NameStart);
3669 : 943455 : if (NameEnd != NameStart)
3670 : : {
3671 : 0 : M2Error_WriteFormat2 ((const char *) "end procedure name does not match beginning %a name %a", 54, (const unsigned char *) &NameStart, (sizeof (NameStart)-1), (const unsigned char *) &NameEnd, (sizeof (NameEnd)-1));
3672 : : }
3673 : 943455 : SymbolTable_PutProcedureParameterHeapVars (ProcSym);
3674 : 943455 : SymbolTable_PutProcedureDefined (ProcSym, kind);
3675 : 943455 : SymbolTable_EndScope ();
3676 : 943455 : M2Error_LeaveErrorScope ();
3677 : 943455 : }
3678 : :
3679 : :
3680 : : /*
3681 : : EndBuildForward - ends building a forward procedure.
3682 : : */
3683 : :
3684 : 48 : extern "C" void P2SymBuild_EndBuildForward (void)
3685 : : {
3686 : 48 : M2Quads_PopN (2);
3687 : 48 : SymbolTable_EndScope ();
3688 : 48 : M2Error_LeaveErrorScope ();
3689 : 48 : }
3690 : :
3691 : :
3692 : : /*
3693 : : BuildNoReturnAttribute - provide an interface to the symbol table module.
3694 : : */
3695 : :
3696 : 446155 : extern "C" void P2SymBuild_BuildNoReturnAttribute (void)
3697 : : {
3698 : 446155 : SymbolTable_ProcedureKind kind;
3699 : 446155 : unsigned int ProcSym;
3700 : 446155 : unsigned int tok;
3701 : :
3702 : 446155 : M2Quads_PopTtok (&ProcSym, &tok);
3703 : 446155 : M2Quads_PushTtok (ProcSym, tok);
3704 : 446155 : kind = SymbolTable_GetProcedureKind (ProcSym, tok);
3705 : 446155 : M2Debug_Assert (SymbolTable_IsProcedure (ProcSym));
3706 : 446155 : SymbolTable_PutProcedureNoReturn (ProcSym, kind, true);
3707 : 446155 : }
3708 : :
3709 : :
3710 : : /*
3711 : : CheckProcedure - checks to see that the top of stack procedure
3712 : : has not been declared as a procedure function.
3713 : :
3714 : : The Stack:
3715 : :
3716 : : Entry Exit
3717 : :
3718 : : Ptr -> <- Ptr
3719 : : +------------+ +------------+
3720 : : | ProcSym | | ProcSym |
3721 : : |------------| |------------|
3722 : : */
3723 : :
3724 : 1466260 : extern "C" void P2SymBuild_CheckProcedure (void)
3725 : : {
3726 : 1466260 : CheckProcedureReturn (SymbolTable_NulSym, M2LexBuf_UnknownTokenNo);
3727 : 1466260 : }
3728 : :
3729 : :
3730 : : /*
3731 : : BuildPointerType - builds a pointer type.
3732 : : The Stack:
3733 : :
3734 : : Entry Exit
3735 : : ===== ====
3736 : :
3737 : :
3738 : : Ptr -> <- Ptr
3739 : : +------------+ +-------------+
3740 : : | Type | | PointerType |
3741 : : |------------| |-------------|
3742 : : | Name | | Name |
3743 : : |------------| |-------------|
3744 : : */
3745 : :
3746 : 76166 : extern "C" void P2SymBuild_BuildPointerType (unsigned int pointerpos)
3747 : : {
3748 : 76166 : unsigned int combined;
3749 : 76166 : unsigned int namepos;
3750 : 76166 : unsigned int typepos;
3751 : 76166 : NameKey_Name name;
3752 : 76166 : unsigned int Type;
3753 : 76166 : unsigned int PtrToType;
3754 : :
3755 : 76166 : M2Quads_PopTtok (&Type, &typepos);
3756 : 76166 : M2Quads_PopTtok (&name, &namepos);
3757 : 76166 : name = SymbolTable_CheckAnonymous (name);
3758 : 76166 : combined = M2LexBuf_MakeVirtual2Tok (pointerpos, typepos);
3759 : 76166 : PtrToType = SymbolTable_MakePointer (combined, name);
3760 : 76166 : SymbolTable_PutPointer (PtrToType, Type);
3761 : 76166 : SymbolTable_CheckForExportedImplementation (PtrToType); /* May be an exported hidden type */
3762 : 76166 : M2Quads_PushTtok (name, namepos); /* May be an exported hidden type */
3763 : 76166 : M2Quads_Annotate ((const char *) "%1n|%3d||pointer type name", 26);
3764 : 76166 : M2Quads_PushTtok (PtrToType, combined);
3765 : 76166 : M2Quads_Annotate ((const char *) "%1s(%1d)|%3d||pointer type", 26);
3766 : 76166 : }
3767 : :
3768 : :
3769 : : /*
3770 : : BuildSetType - builds a set type.
3771 : : The Stack:
3772 : :
3773 : : Entry Exit
3774 : : ===== ====
3775 : :
3776 : :
3777 : : Ptr -> <- Ptr
3778 : : +------------+ +-------------+
3779 : : | Type | | SetType |
3780 : : |------------| |-------------|
3781 : : | Name | | Name |
3782 : : |------------| |-------------|
3783 : : */
3784 : :
3785 : 1802 : extern "C" void P2SymBuild_BuildSetType (unsigned int setpos, bool ispacked)
3786 : : {
3787 : 1802 : unsigned int combined;
3788 : 1802 : unsigned int namepos;
3789 : 1802 : unsigned int typepos;
3790 : 1802 : NameKey_Name name;
3791 : 1802 : unsigned int Type;
3792 : 1802 : unsigned int SetType;
3793 : :
3794 : 1802 : M2Quads_PopTtok (&Type, &typepos);
3795 : 1802 : M2Quads_PopTtok (&name, &namepos);
3796 : 1802 : combined = M2LexBuf_MakeVirtual2Tok (setpos, typepos);
3797 : 1802 : SetType = SymbolTable_MakeSet (combined, name);
3798 : 1802 : SymbolTable_CheckForExportedImplementation (SetType); /* May be an exported hidden type */
3799 : 1802 : SymbolTable_PutSet (SetType, Type, ispacked); /* May be an exported hidden type */
3800 : 1802 : M2Quads_PushTtok (name, namepos);
3801 : 1802 : M2Quads_Annotate ((const char *) "%1n||set type name", 18);
3802 : 1802 : M2Quads_PushTtok (SetType, combined);
3803 : 1802 : M2Quads_Annotate ((const char *) "%1s(%1d)|%3d||set type|token no", 31);
3804 : 1802 : }
3805 : :
3806 : :
3807 : : /*
3808 : : BuildRecord - Builds a record type.
3809 : : The Stack:
3810 : :
3811 : : Entry Exit
3812 : : ===== ====
3813 : :
3814 : :
3815 : : <- Ptr
3816 : : +-----------+
3817 : : Ptr -> | RecordSym |
3818 : : +------------------+ |-----------|
3819 : : | Name | | Name |
3820 : : |------------------| |-----------|
3821 : : */
3822 : :
3823 : 48560 : extern "C" void P2SymBuild_BuildRecord (void)
3824 : : {
3825 : 48560 : unsigned int tokno;
3826 : 48560 : NameKey_Name name;
3827 : 48560 : unsigned int RecordType;
3828 : :
3829 : 48560 : name = static_cast<NameKey_Name> (M2Quads_OperandT (1));
3830 : 48560 : name = SymbolTable_CheckAnonymous (name);
3831 : 48560 : tokno = static_cast<unsigned int> (M2Quads_OperandTok (1));
3832 : 48560 : RecordType = SymbolTable_MakeRecord (tokno, name);
3833 : 48560 : SymbolTable_CheckForExportedImplementation (RecordType); /* May be an exported hidden type */
3834 : 48560 : M2Quads_PushT (RecordType);
3835 : : /* ; WriteKey(name) ; WriteString(' RECORD made') ; WriteLn */
3836 : 48560 : M2Quads_Annotate ((const char *) "%1s(%1d)||record type", 21);
3837 : 48560 : }
3838 : :
3839 : :
3840 : : /*
3841 : : BuildFieldRecord - Builds a field into a record sym.
3842 : : The Stack:
3843 : :
3844 : :
3845 : : Entry Exit
3846 : : ===== ====
3847 : :
3848 : : Ptr ->
3849 : : +-------------+
3850 : : | NoOfPragmas |
3851 : : |-------------|
3852 : : | Const1 |
3853 : : |-------------|
3854 : : | PragmaName1 |
3855 : : |-------------|
3856 : : | Type | Name |
3857 : : |-------------|
3858 : : | n |
3859 : : |-------------|
3860 : : | Id 1 |
3861 : : |-------------|
3862 : : . .
3863 : : . .
3864 : : . .
3865 : : |-------------|
3866 : : | Id n | <- Ptr
3867 : : |-------------| +-------------+
3868 : : | RecordSym | | RecordSym |
3869 : : |-------------| |-------------|
3870 : : | RecordName | | RecordName |
3871 : : |-------------| |-------------|
3872 : : */
3873 : :
3874 : 221286 : extern "C" void P2SymBuild_BuildFieldRecord (void)
3875 : : {
3876 : 221286 : NameKey_Name n1;
3877 : 221286 : unsigned int tok;
3878 : 221286 : unsigned int fsym;
3879 : 221286 : unsigned int Field;
3880 : 221286 : unsigned int Varient;
3881 : 221286 : unsigned int Parent;
3882 : 221286 : unsigned int Type;
3883 : 221286 : unsigned int NoOfPragmas;
3884 : 221286 : unsigned int NoOfFields;
3885 : 221286 : unsigned int Record;
3886 : 221286 : unsigned int i;
3887 : :
3888 : 221286 : M2Quads_PopT (&NoOfPragmas);
3889 : 221286 : Type = static_cast<unsigned int> (M2Quads_OperandT ((NoOfPragmas*2)+1));
3890 : : /* name := OperandF(NoOfPragmas*2+1) ; */
3891 : 221286 : NoOfFields = static_cast<unsigned int> (M2Quads_OperandT ((NoOfPragmas*2)+2));
3892 : 221286 : Record = static_cast<unsigned int> (M2Quads_OperandT (((NoOfPragmas*2)+NoOfFields)+3));
3893 : 221286 : if (SymbolTable_IsRecord (Record))
3894 : : {
3895 : : Parent = Record;
3896 : : Varient = SymbolTable_NulSym;
3897 : : }
3898 : : else
3899 : : {
3900 : : /* Record maybe FieldVarient */
3901 : 576 : Parent = SymbolTable_GetRecord (SymbolTable_GetParent (Record));
3902 : 570 : M2Debug_Assert (SymbolTable_IsFieldVarient (Record));
3903 : 570 : Varient = static_cast<unsigned int> (M2Quads_OperandT (((NoOfPragmas*2)+NoOfFields)+4));
3904 : 570 : M2Debug_Assert (SymbolTable_IsVarient (Varient));
3905 : 570 : SymbolTable_PutFieldVarient (Record, Varient);
3906 : 570 : if (Debugging)
3907 : : {
3908 : : n1 = SymbolTable_GetSymName (Record);
3909 : : StrIO_WriteString ((const char *) "Record ", 7);
3910 : : NameKey_WriteKey (n1);
3911 : : StrIO_WriteString ((const char *) " has varient ", 13);
3912 : : n1 = SymbolTable_GetSymName (Varient);
3913 : : NameKey_WriteKey (n1);
3914 : : StrIO_WriteLn ();
3915 : : }
3916 : : }
3917 : 221280 : Field = SymbolTable_NulSym;
3918 : 221280 : i = 1;
3919 : 474988 : while (i <= NoOfFields)
3920 : : {
3921 : 253708 : if (Debugging)
3922 : : {
3923 : : n1 = SymbolTable_GetSymName (Record);
3924 : : StrIO_WriteString ((const char *) "Record ", 7);
3925 : : NameKey_WriteKey (n1);
3926 : : StrIO_WriteString ((const char *) " ", 2);
3927 : : NameKey_WriteKey (M2Quads_OperandT ((((NoOfPragmas*2)+NoOfFields)+3)-i));
3928 : : StrIO_WriteString ((const char *) " is a Field with type ", 22);
3929 : : NameKey_WriteKey (SymbolTable_GetSymName (Type));
3930 : : StrIO_WriteLn ();
3931 : : }
3932 : 253708 : fsym = SymbolTable_GetLocalSym (Parent, M2Quads_OperandT ((((NoOfPragmas*2)+NoOfFields)+3)-i));
3933 : 253708 : if (fsym == SymbolTable_NulSym)
3934 : : {
3935 : 253702 : Field = SymbolTable_PutFieldRecord (Record, M2Quads_OperandT ((((NoOfPragmas*2)+NoOfFields)+3)-i), Type, Varient);
3936 : 253702 : HandleRecordFieldPragmas (Record, Field, NoOfPragmas);
3937 : : }
3938 : : else
3939 : : {
3940 : 6 : M2MetaError_MetaErrors2 ((const char *) "record field {%1ad} has already been declared inside a {%2Dd} {%2a}", 67, (const char *) "attempting to declare a duplicate record field", 46, fsym, Parent);
3941 : : }
3942 : : /* adjust the location of declaration to the one on the stack (rather than GetTokenNo). */
3943 : 253708 : tok = static_cast<unsigned int> (M2Quads_OperandTok ((((NoOfPragmas*2)+NoOfFields)+3)-i));
3944 : 253708 : if ((tok != M2LexBuf_UnknownTokenNo) && (Field != SymbolTable_NulSym))
3945 : : {
3946 : 253702 : SymbolTable_PutDeclared (tok, Field);
3947 : : }
3948 : 253708 : i += 1;
3949 : : }
3950 : 221280 : M2Quads_PopN (((NoOfPragmas*2)+NoOfFields)+3);
3951 : 221280 : M2Quads_PushT (Record);
3952 : 221280 : if (SymbolTable_IsRecord (Record))
3953 : : {
3954 : 220710 : M2Quads_Annotate ((const char *) "%1s(%1d)||record type", 21);
3955 : : }
3956 : : else
3957 : : {
3958 : 570 : M2Debug_Assert (SymbolTable_IsFieldVarient (Record));
3959 : 570 : M2Quads_Annotate ((const char *) "%1s(%1d)||varient field type", 28);
3960 : : }
3961 : 221280 : }
3962 : :
3963 : :
3964 : : /*
3965 : : StartBuildVarient - Builds a varient symbol on top of a record sym.
3966 : : The Stack:
3967 : :
3968 : :
3969 : : Entry Exit
3970 : : ===== ====
3971 : :
3972 : : <- Ptr
3973 : : +-------------+
3974 : : Ptr -> | VarientSym |
3975 : : +-------------+ |-------------|
3976 : : | RecordSym | | RecordSym |
3977 : : |-------------| |-------------|
3978 : : | RecordName | | RecordName |
3979 : : |-------------| |-------------|
3980 : : */
3981 : :
3982 : 276 : extern "C" void P2SymBuild_StartBuildVarient (void)
3983 : : {
3984 : 276 : unsigned int tokno;
3985 : 276 : unsigned int RecordSym;
3986 : 276 : unsigned int Sym;
3987 : :
3988 : 276 : RecordSym = static_cast<unsigned int> (M2Quads_OperandT (1));
3989 : 276 : tokno = static_cast<unsigned int> (M2Quads_OperandTok (1));
3990 : 276 : Sym = SymbolTable_MakeVarient (tokno, RecordSym);
3991 : 276 : M2Quads_PushT (Sym);
3992 : 276 : M2Quads_Annotate ((const char *) "%1s(%1d)||varient type", 22);
3993 : 276 : }
3994 : :
3995 : :
3996 : : /*
3997 : : EndBuildVarient - Removes the varient symbol from the stack.
3998 : : The Stack:
3999 : :
4000 : : Entry Exit
4001 : : ===== ====
4002 : :
4003 : : Ptr ->
4004 : : +-------------+
4005 : : | VarientSym | <- Ptr
4006 : : |-------------| +-------------+
4007 : : | RecordSym | | RecordSym |
4008 : : |-------------| |-------------|
4009 : : | RecordName | | RecordName |
4010 : : |-------------| |-------------|
4011 : : */
4012 : :
4013 : 276 : extern "C" void P2SymBuild_EndBuildVarient (void)
4014 : : {
4015 : 276 : unsigned int Sym;
4016 : :
4017 : 276 : M2Quads_PopT (&Sym);
4018 : 276 : }
4019 : :
4020 : :
4021 : : /*
4022 : : BuildVarientSelector - Builds a field into a record sym.
4023 : : The Stack:
4024 : :
4025 : :
4026 : : Entry Exit
4027 : : ===== ====
4028 : :
4029 : : Ptr ->
4030 : : +-------------+
4031 : : | Type |
4032 : : |-------------|
4033 : : | Tag | <- Ptr
4034 : : |-------------| +-------------+
4035 : : | RecordSym | | RecordSym |
4036 : : |-------------| |-------------|
4037 : : */
4038 : :
4039 : 276 : extern "C" void P2SymBuild_BuildVarientSelector (void)
4040 : : {
4041 : 276 : unsigned int tagtok;
4042 : 276 : NameKey_Name tag;
4043 : 276 : unsigned int Field;
4044 : 276 : unsigned int Type;
4045 : 276 : unsigned int Varient;
4046 : 276 : unsigned int VarField;
4047 : 276 : unsigned int Record;
4048 : :
4049 : 276 : M2Quads_PopT (&Type);
4050 : 276 : M2Quads_PopTtok (&tag, &tagtok);
4051 : 276 : Record = static_cast<unsigned int> (M2Quads_OperandT (1));
4052 : 276 : if (SymbolTable_IsRecord (Record))
4053 : : {
4054 : 0 : Varient = SymbolTable_NulSym;
4055 : 0 : M2Error_InternalError ((const char *) "not expecting a record symbol", 29);
4056 : : }
4057 : 276 : else if (SymbolTable_IsVarient (Record))
4058 : : {
4059 : : /* avoid dangling else. */
4060 : 276 : Varient = Record;
4061 : 276 : VarField = SymbolTable_GetParent (Varient);
4062 : 276 : if ((Type == SymbolTable_NulSym) && (tag == NameKey_NulName))
4063 : : {
4064 : 0 : M2MetaError_MetaError1 ((const char *) "expecting a tag field in the declaration of a varient record {%1Ua}", 67, Record);
4065 : : }
4066 : 276 : else if (Type == SymbolTable_NulSym)
4067 : : {
4068 : : /* avoid dangling else. */
4069 : 12 : SymbolTable_PutVarientTag (Varient, SymbolTable_RequestSym (tagtok, tag));
4070 : : }
4071 : : else
4072 : : {
4073 : : /* avoid dangling else. */
4074 : 264 : Field = SymbolTable_PutFieldRecord (VarField, tag, Type, Varient);
4075 : 264 : SymbolTable_PutVarientTag (Varient, Field);
4076 : 264 : if (Debugging)
4077 : : {
4078 : : StrIO_WriteString ((const char *) "varient field ", 14);
4079 : : NameKey_WriteKey (SymbolTable_GetSymName (VarField));
4080 : : StrIO_WriteString ((const char *) "varient ", 8);
4081 : : NameKey_WriteKey (SymbolTable_GetSymName (Varient));
4082 : : StrIO_WriteLn ();
4083 : : }
4084 : : }
4085 : : }
4086 : : else
4087 : : {
4088 : : /* avoid dangling else. */
4089 : : /* Record maybe FieldVarient */
4090 : 0 : M2Debug_Assert (SymbolTable_IsFieldVarient (Record));
4091 : 0 : Varient = static_cast<unsigned int> (M2Quads_OperandT (1+2));
4092 : 0 : M2Debug_Assert (SymbolTable_IsVarient (Varient));
4093 : 0 : SymbolTable_PutFieldVarient (Record, Varient);
4094 : 0 : if (Debugging)
4095 : : {
4096 : : StrIO_WriteString ((const char *) "record ", 7);
4097 : : NameKey_WriteKey (SymbolTable_GetSymName (Record));
4098 : : StrIO_WriteString ((const char *) "varient ", 8);
4099 : : NameKey_WriteKey (SymbolTable_GetSymName (Varient));
4100 : : StrIO_WriteLn ();
4101 : : }
4102 : 0 : if ((Type == SymbolTable_NulSym) && (tag == NameKey_NulName))
4103 : : {
4104 : 0 : M2MetaError_MetaError1 ((const char *) "expecting a tag field in the declaration of a varient record {%1Ua}", 67, Record);
4105 : : }
4106 : 0 : else if (Type == SymbolTable_NulSym)
4107 : : {
4108 : : /* avoid dangling else. */
4109 : 0 : SymbolTable_PutVarientTag (Varient, SymbolTable_RequestSym (tagtok, tag));
4110 : : }
4111 : : else
4112 : : {
4113 : : /* avoid dangling else. */
4114 : 0 : Field = SymbolTable_PutFieldRecord (Record, tag, Type, Varient);
4115 : 0 : SymbolTable_PutVarientTag (Varient, Field);
4116 : 0 : if (Debugging)
4117 : : {
4118 : : StrIO_WriteString ((const char *) "record ", 7);
4119 : : NameKey_WriteKey (SymbolTable_GetSymName (Record));
4120 : : StrIO_WriteString ((const char *) "varient ", 8);
4121 : : NameKey_WriteKey (SymbolTable_GetSymName (Varient));
4122 : : StrIO_WriteLn ();
4123 : : }
4124 : : }
4125 : : }
4126 : 276 : }
4127 : :
4128 : :
4129 : : /*
4130 : : StartBuildVarientFieldRecord - Builds a varient field into a varient sym.
4131 : : The Stack:
4132 : :
4133 : :
4134 : : Entry Exit
4135 : : ===== ====
4136 : :
4137 : : <- Ptr
4138 : : +-------------+
4139 : : Ptr -> | VarientField|
4140 : : +-------------+ |-------------|
4141 : : | VarientSym | | VarientSym |
4142 : : |-------------| |-------------|
4143 : : */
4144 : :
4145 : 666 : extern "C" void P2SymBuild_StartBuildVarientFieldRecord (void)
4146 : : {
4147 : 666 : unsigned int VarientSym;
4148 : 666 : unsigned int FieldSym;
4149 : :
4150 : 666 : VarientSym = static_cast<unsigned int> (M2Quads_OperandT (1));
4151 : 666 : FieldSym = SymbolTable_MakeFieldVarient (SymbolTable_CheckAnonymous (NameKey_NulName), VarientSym);
4152 : 666 : M2Quads_Annotate ((const char *) "%1s(%1d)||varient sym", 21);
4153 : 666 : M2Quads_PushT (FieldSym);
4154 : 666 : M2Quads_Annotate ((const char *) "%1s(%1d)||varient field type", 28);
4155 : 666 : M2Debug_Assert (SymbolTable_IsFieldVarient (FieldSym));
4156 : 666 : SymbolTable_PutFieldVarient (FieldSym, VarientSym);
4157 : 666 : M2Quads_AddVarientFieldToList (FieldSym);
4158 : 666 : }
4159 : :
4160 : :
4161 : : /*
4162 : : EndBuildVarientFieldRecord - Removes a varient field from the stack.
4163 : : The Stack:
4164 : :
4165 : :
4166 : : Entry Exit
4167 : : ===== ====
4168 : :
4169 : : Ptr ->
4170 : : +-------------+
4171 : : | VarientField| <- Ptr
4172 : : |-------------| +-------------+
4173 : : | VarientSym | | VarientSym |
4174 : : |-------------| |-------------|
4175 : : */
4176 : :
4177 : 666 : extern "C" void P2SymBuild_EndBuildVarientFieldRecord (void)
4178 : : {
4179 : 666 : unsigned int FieldSym;
4180 : :
4181 : 666 : M2Quads_PopT (&FieldSym);
4182 : 666 : }
4183 : :
4184 : :
4185 : : /*
4186 : : BuildNulName - Pushes a NulName onto the top of the stack.
4187 : : The Stack:
4188 : :
4189 : :
4190 : : Entry Exit
4191 : :
4192 : : <- Ptr
4193 : : Empty +------------+
4194 : : | NulName |
4195 : : |------------|
4196 : : */
4197 : :
4198 : 1166598 : extern "C" void P2SymBuild_BuildNulName (void)
4199 : : {
4200 : 1166598 : M2Quads_PushTtok (static_cast<unsigned int> (NameKey_NulName), M2LexBuf_GetTokenNo ());
4201 : 1166598 : M2Quads_Annotate ((const char *) "%1n|%3d||NulName|token no", 25);
4202 : 1166598 : }
4203 : :
4204 : :
4205 : : /*
4206 : : BuildTypeEnd - Pops the type Type and Name.
4207 : : The Stack:
4208 : :
4209 : :
4210 : : Entry Exit
4211 : :
4212 : :
4213 : : Ptr ->
4214 : : +-------------+
4215 : : | Type | Name | Empty
4216 : : |-------------|
4217 : : */
4218 : :
4219 : 122053 : extern "C" void P2SymBuild_BuildTypeEnd (void)
4220 : : {
4221 : 122053 : unsigned int Type;
4222 : 122053 : NameKey_Name name;
4223 : :
4224 : 122053 : M2Quads_PopTF (&Type, &name);
4225 : 122053 : }
4226 : :
4227 : :
4228 : : /*
4229 : : StartBuildArray - Builds an array type.
4230 : : The Stack:
4231 : :
4232 : : Entry Exit
4233 : : ===== ====
4234 : :
4235 : : <- Ptr
4236 : : +-----------+
4237 : : Ptr -> | ArraySym |
4238 : : +------------+ |-----------|
4239 : : | Name | | Name |
4240 : : |------------| |-----------|
4241 : : */
4242 : :
4243 : 82832 : extern "C" void P2SymBuild_StartBuildArray (void)
4244 : : {
4245 : 82832 : unsigned int tok;
4246 : 82832 : NameKey_Name name;
4247 : 82832 : unsigned int ArrayType;
4248 : :
4249 : 82832 : name = static_cast<NameKey_Name> (M2Quads_OperandT (1));
4250 : 82832 : tok = static_cast<unsigned int> (M2Quads_OperandTok (1));
4251 : 82832 : ArrayType = SymbolTable_MakeArray (tok, name);
4252 : 82832 : SymbolTable_CheckForExportedImplementation (ArrayType); /* May be an exported hidden type */
4253 : 82832 : M2Quads_PushTtok (ArrayType, tok); /* May be an exported hidden type */
4254 : : /* ; WriteKey(Name) ; WriteString(' ARRAY made') ; WriteLn */
4255 : 82832 : M2Quads_Annotate ((const char *) "%1s(%1d)|%3d||array type|token no", 33);
4256 : 82832 : }
4257 : :
4258 : :
4259 : : /*
4260 : : EndBuildArray - Builds an array type.
4261 : : The Stack:
4262 : :
4263 : : Entry Exit
4264 : : ===== ====
4265 : :
4266 : : Ptr ->
4267 : : +------------+
4268 : : | TypeSym | <- Ptr
4269 : : |------------| +------------+
4270 : : | ArraySym | | ArraySym |
4271 : : |------------| |------------|
4272 : : | Name | | Name |
4273 : : |------------| |------------|
4274 : : */
4275 : :
4276 : 82832 : extern "C" void P2SymBuild_EndBuildArray (void)
4277 : : {
4278 : 82832 : unsigned int typetok;
4279 : 82832 : unsigned int arraytok;
4280 : 82832 : unsigned int combinedtok;
4281 : 82832 : unsigned int TypeSym;
4282 : 82832 : unsigned int ArraySym;
4283 : :
4284 : 82832 : M2Quads_PopTtok (&TypeSym, &typetok);
4285 : 82832 : M2Quads_PopTtok (&ArraySym, &arraytok);
4286 : 82832 : M2Debug_Assert (SymbolTable_IsArray (ArraySym));
4287 : 82832 : combinedtok = M2LexBuf_MakeVirtual2Tok (arraytok, typetok);
4288 : 82832 : SymbolTable_PutArray (ArraySym, TypeSym);
4289 : 82832 : SymbolTable_PutDeclared (combinedtok, ArraySym);
4290 : 82832 : M2Quads_PushTtok (ArraySym, combinedtok);
4291 : 82832 : M2Quads_Annotate ((const char *) "%1s(%1d)||array type", 20);
4292 : 82832 : }
4293 : :
4294 : :
4295 : : /*
4296 : : BuildFieldArray - Builds a field into an array sym.
4297 : : The Stack:
4298 : :
4299 : :
4300 : : Entry Exit
4301 : : ===== ====
4302 : :
4303 : : Ptr ->
4304 : : +-------------+
4305 : : | Type | Name | <- Ptr
4306 : : |-------------| +-------------+
4307 : : | ArraySym | | ArraySym |
4308 : : |-------------| |-------------|
4309 : : | ArrayName | | ArrayName |
4310 : : |-------------| |-------------|
4311 : : */
4312 : :
4313 : 82832 : extern "C" void P2SymBuild_BuildFieldArray (void)
4314 : : {
4315 : 82832 : unsigned int typetok;
4316 : 82832 : unsigned int arraytok;
4317 : 82832 : unsigned int Subscript;
4318 : 82832 : unsigned int Type;
4319 : 82832 : unsigned int Array;
4320 : 82832 : NameKey_Name name;
4321 : :
4322 : 82832 : M2Quads_PopTFtok (&Type, &name, &typetok);
4323 : 82832 : M2Quads_PopTtok (&Array, &arraytok);
4324 : 82832 : M2Debug_Assert (SymbolTable_IsArray (Array));
4325 : 82832 : Subscript = SymbolTable_MakeSubscript ();
4326 : : /*
4327 : : We cannot Assert(IsSubrange(Type)) as the subrange type might be
4328 : : declared later on in the file.
4329 : : We also note it could be an ordinal type or enumerated type.
4330 : : Therefore we must save this information and deal with the
4331 : : different cases in M2GCCDeclare.mod and M2GenGCC.mod.
4332 : : However this works to our advantage as it preserves the
4333 : : actual declaration as specified by the source file.
4334 : : */
4335 : 82832 : SymbolTable_PutSubscript (Subscript, Type);
4336 : 82832 : SymbolTable_PutArraySubscript (Array, Subscript);
4337 : 82832 : M2Quads_PushTtok (Array, arraytok);
4338 : : /* ; WriteString('Field Placed in Array') ; WriteLn */
4339 : 82832 : M2Quads_Annotate ((const char *) "%1s(%1d)||array type", 20);
4340 : 82832 : }
4341 : :
4342 : :
4343 : : /*
4344 : : BuildArrayComma - converts ARRAY [..], [..] OF into ARRAY [..] OF ARRAY [..]
4345 : :
4346 : :
4347 : : Ptr -> <- Ptr
4348 : : +-------------+ +-------------+
4349 : : | ArraySym1 | | ArraySym2 |
4350 : : |-------------| |-------------|
4351 : : | ArrayName | | ArrayName |
4352 : : |-------------| |-------------|
4353 : : */
4354 : :
4355 : 138 : extern "C" void P2SymBuild_BuildArrayComma (void)
4356 : : {
4357 : 138 : unsigned int Nothing;
4358 : 138 : unsigned int ArraySym1;
4359 : 138 : unsigned int ArraySym2;
4360 : :
4361 : 138 : M2Quads_PushT (static_cast<unsigned int> (NameKey_NulName));
4362 : 138 : P2SymBuild_StartBuildArray ();
4363 : 138 : M2Quads_PopT (&ArraySym2);
4364 : 138 : M2Quads_PopT (&Nothing);
4365 : 138 : M2Quads_PushT (ArraySym2);
4366 : 138 : P2SymBuild_EndBuildArray ();
4367 : 138 : M2Quads_PopT (&ArraySym1);
4368 : 138 : M2Quads_PushT (ArraySym2);
4369 : 138 : M2Quads_Annotate ((const char *) "%1s(%1d)||array type comma", 26);
4370 : 138 : }
4371 : :
4372 : :
4373 : : /*
4374 : : BuildProcedureType - builds a procedure type symbol.
4375 : : The Stack:
4376 : :
4377 : :
4378 : : <- Ptr
4379 : : +-------------+
4380 : : Ptr -> | ProcTypeSym |
4381 : : +-------------+ |-------------|
4382 : : | Name | | Name |
4383 : : |-------------| |-------------|
4384 : : */
4385 : :
4386 : 53430 : extern "C" void P2SymBuild_BuildProcedureType (void)
4387 : : {
4388 : 53430 : unsigned int tok;
4389 : 53430 : NameKey_Name name;
4390 : 53430 : unsigned int ProcTypeSym;
4391 : :
4392 : 53430 : name = static_cast<NameKey_Name> (M2Quads_OperandT (1));
4393 : 53430 : tok = static_cast<unsigned int> (M2Quads_OperandTok (1));
4394 : 53430 : ProcTypeSym = SymbolTable_MakeProcType (tok, name);
4395 : 53430 : SymbolTable_CheckForExportedImplementation (ProcTypeSym); /* May be an exported hidden type */
4396 : 53430 : M2Quads_Annotate ((const char *) "%1n||procedure type name", 24); /* May be an exported hidden type */
4397 : 53430 : M2Quads_PushTtok (ProcTypeSym, tok);
4398 : 53430 : M2Quads_Annotate ((const char *) "%1s(%1d)|%3d||proc type|token no", 32);
4399 : 53430 : }
4400 : :
4401 : :
4402 : : /*
4403 : : BuildFormalType - Builds a Formal Parameter in a procedure type.
4404 : :
4405 : : The Stack:
4406 : :
4407 : : Entry Exit
4408 : :
4409 : : Ptr ->
4410 : : +------------+
4411 : : | TypeSym |
4412 : : |------------|
4413 : : | Array/Nul |
4414 : : |------------|
4415 : : | Var / Nul | <- Ptr
4416 : : |------------| +--------------+
4417 : : | ProcTypeSym| | ProcTypeSym |
4418 : : |------------| |--------------|
4419 : : */
4420 : :
4421 : 76175 : extern "C" void P2SymBuild_BuildFormalType (void)
4422 : : {
4423 : 76175 : unsigned int tok;
4424 : 76175 : NameKey_Name Array;
4425 : 76175 : NameKey_Name Var;
4426 : 76175 : unsigned int TypeSym;
4427 : 76175 : unsigned int UnboundedSym;
4428 : 76175 : unsigned int ProcTypeSym;
4429 : :
4430 : 76175 : M2Quads_PopT (&TypeSym);
4431 : 76175 : M2Quads_PopT (&Array);
4432 : 76175 : M2Quads_PopT (&Var);
4433 : 76175 : M2Quads_PopT (&ProcTypeSym);
4434 : 76175 : tok = M2LexBuf_GetTokenNo ();
4435 : 152350 : M2Debug_Assert ((Array == M2Reserved_ArrayTok) || (Array == M2Reserved_NulTok));
4436 : 76175 : M2Debug_Assert (SymbolTable_IsProcType (ProcTypeSym));
4437 : 152350 : M2Debug_Assert ((Var == M2Reserved_VarTok) || (Var == M2Reserved_NulTok));
4438 : 76175 : if (Array == M2Reserved_ArrayTok)
4439 : : {
4440 : 360 : UnboundedSym = SymbolTable_MakeUnbounded (tok, TypeSym, 1);
4441 : 360 : TypeSym = UnboundedSym;
4442 : : }
4443 : 76175 : if (Var == M2Reserved_VarTok)
4444 : : {
4445 : : /* VAR parameter */
4446 : 6008 : SymbolTable_PutProcTypeVarParam (ProcTypeSym, TypeSym, SymbolTable_IsUnbounded (TypeSym));
4447 : : }
4448 : : else
4449 : : {
4450 : : /* Non VAR parameter */
4451 : 70167 : SymbolTable_PutProcTypeParam (ProcTypeSym, TypeSym, SymbolTable_IsUnbounded (TypeSym));
4452 : : }
4453 : 76175 : M2Quads_PushT (ProcTypeSym);
4454 : 76175 : M2Quads_Annotate ((const char *) "%1s(%1d)||proc type", 19);
4455 : 76175 : }
4456 : :
4457 : :
4458 : : /*
4459 : : SeenUnknown - sets the operand type to unknown.
4460 : : */
4461 : :
4462 : 13569701 : extern "C" void P2SymBuild_SeenUnknown (void)
4463 : : {
4464 : 13569701 : type = M2Const_unknown;
4465 : 13569701 : }
4466 : :
4467 : :
4468 : : /*
4469 : : SeenCast - sets the operand type to cast.
4470 : : */
4471 : :
4472 : 0 : extern "C" void P2SymBuild_SeenCast (unsigned int sym)
4473 : : {
4474 : 0 : type = M2Const_cast;
4475 : 0 : castType = sym;
4476 : 0 : M2Debug_Assert (SymbolTable_IsAModula2Type (sym));
4477 : 0 : }
4478 : :
4479 : :
4480 : : /*
4481 : : SeenSet - sets the operand type to set.
4482 : : */
4483 : :
4484 : 350 : extern "C" void P2SymBuild_SeenSet (void)
4485 : : {
4486 : 350 : SetTypeTo (M2Const_set);
4487 : 350 : SaveRememberedConstructor ();
4488 : 350 : }
4489 : :
4490 : :
4491 : : /*
4492 : : SeenConstructor - sets the operand type to constructor.
4493 : : */
4494 : :
4495 : 21296 : extern "C" void P2SymBuild_SeenConstructor (void)
4496 : : {
4497 : 21296 : SetTypeTo (M2Const_constructor);
4498 : 21296 : SaveRememberedConstructor ();
4499 : 21296 : }
4500 : :
4501 : :
4502 : : /*
4503 : : SeenArray - sets the operand type to array.
4504 : : */
4505 : :
4506 : 30 : extern "C" void P2SymBuild_SeenArray (void)
4507 : : {
4508 : 30 : SetTypeTo (M2Const_array);
4509 : 30 : }
4510 : :
4511 : :
4512 : : /*
4513 : : SeenString - sets the operand type to string.
4514 : : */
4515 : :
4516 : 12082 : extern "C" void P2SymBuild_SeenString (void)
4517 : : {
4518 : 12082 : SetTypeTo (M2Const_str);
4519 : 12082 : }
4520 : :
4521 : :
4522 : : /*
4523 : : SeenBoolean - sets the operand type to a BOOLEAN.
4524 : : */
4525 : :
4526 : 0 : extern "C" void P2SymBuild_SeenBoolean (void)
4527 : : {
4528 : 0 : type = M2Const_boolean;
4529 : 0 : }
4530 : :
4531 : :
4532 : : /*
4533 : : SeenZType - sets the operand type to a Z type.
4534 : : */
4535 : :
4536 : 0 : extern "C" void P2SymBuild_SeenZType (void)
4537 : : {
4538 : 0 : type = M2Const_ztype;
4539 : 0 : }
4540 : :
4541 : :
4542 : : /*
4543 : : SeenRType - sets the operand type to a R type.
4544 : : */
4545 : :
4546 : 0 : extern "C" void P2SymBuild_SeenRType (void)
4547 : : {
4548 : 0 : type = M2Const_rtype;
4549 : 0 : }
4550 : :
4551 : :
4552 : : /*
4553 : : SeenCType - sets the operand type to a C type.
4554 : : */
4555 : :
4556 : 0 : extern "C" void P2SymBuild_SeenCType (void)
4557 : : {
4558 : 0 : type = M2Const_ctype;
4559 : 0 : }
4560 : :
4561 : :
4562 : : /*
4563 : : DetermineType - assigns the top of stack symbol with the type of
4564 : : constant expression, if known.
4565 : : */
4566 : :
4567 : 237123 : extern "C" void P2SymBuild_DetermineType (void)
4568 : : {
4569 : 237123 : unsigned int Sym;
4570 : :
4571 : 237123 : Sym = static_cast<unsigned int> (M2Quads_OperandT (1));
4572 : 237123 : switch (type)
4573 : : {
4574 : 12 : case M2Const_set:
4575 : 12 : SymbolTable_PutConstSet (Sym);
4576 : 12 : break;
4577 : :
4578 : 1062 : case M2Const_str:
4579 : 1062 : SymbolTable_PutConstStringKnown (M2LexBuf_GetTokenNo (), Sym, NameKey_MakeKey ((const char *) "", 0), false, false);
4580 : 1062 : break;
4581 : :
4582 : 4070 : case M2Const_array:
4583 : 4070 : case M2Const_constructor:
4584 : 4070 : SymbolTable_PutConstructor (Sym);
4585 : 4070 : break;
4586 : :
4587 : 0 : case M2Const_cast:
4588 : 0 : SymbolTable_PutConst (Sym, castType);
4589 : 0 : break;
4590 : :
4591 : : case M2Const_unknown:
4592 : : break;
4593 : :
4594 : :
4595 : : default:
4596 : : break;
4597 : : }
4598 : 237123 : }
4599 : :
4600 : :
4601 : : /*
4602 : : PushType -
4603 : : */
4604 : :
4605 : 12383002 : extern "C" void P2SymBuild_PushType (void)
4606 : : {
4607 : 12383002 : M2StackWord_PushWord (TypeStack, static_cast<unsigned int> (type));
4608 : 12383002 : }
4609 : :
4610 : :
4611 : : /*
4612 : : PopType -
4613 : : */
4614 : :
4615 : 12383002 : extern "C" void P2SymBuild_PopType (void)
4616 : : {
4617 : 12383002 : type = static_cast<M2Const_constType> (M2StackWord_PopWord (TypeStack));
4618 : 12383002 : }
4619 : :
4620 : :
4621 : : /*
4622 : : PushRememberConstant -
4623 : : */
4624 : :
4625 : 27392 : extern "C" void P2SymBuild_PushRememberConstant (void)
4626 : : {
4627 : 27392 : M2StackWord_PushWord (RememberStack, RememberedConstant);
4628 : 27392 : P2SymBuild_RememberConstant (SymbolTable_NulSym);
4629 : 27392 : }
4630 : :
4631 : :
4632 : : /*
4633 : : PopRememberConstant -
4634 : : */
4635 : :
4636 : 27392 : extern "C" void P2SymBuild_PopRememberConstant (void)
4637 : : {
4638 : 27392 : RememberedConstant = static_cast<unsigned int> (M2StackWord_PopWord (RememberStack));
4639 : 27392 : }
4640 : :
4641 : :
4642 : : /*
4643 : : RememberConstant -
4644 : : */
4645 : :
4646 : 264515 : extern "C" void P2SymBuild_RememberConstant (unsigned int sym)
4647 : : {
4648 : 264515 : RememberedConstant = sym;
4649 : 264515 : }
4650 : :
4651 : 14232 : extern "C" void _M2_P2SymBuild_init (__attribute__((unused)) int argc, __attribute__((unused)) char *argv[], __attribute__((unused)) char *envp[])
4652 : : {
4653 : 14232 : alignTypeNo = 0;
4654 : 14232 : TypeStack = M2StackWord_InitStackWord ();
4655 : 14232 : RememberStack = M2StackWord_InitStackWord ();
4656 : 14232 : BlockStack = M2StackWord_InitStackWord ();
4657 : 14232 : castType = SymbolTable_NulSym;
4658 : 14232 : }
4659 : :
4660 : 0 : extern "C" void _M2_P2SymBuild_fini (__attribute__((unused)) int argc, __attribute__((unused)) char *argv[], __attribute__((unused)) char *envp[])
4661 : : {
4662 : 0 : }
|
