OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [ada/] [sem.adb] - Blame information for rev 281

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 281 jeremybenn
------------------------------------------------------------------------------
2
--                                                                          --
3
--                         GNAT COMPILER COMPONENTS                         --
4
--                                                                          --
5
--                                  S E M                                   --
6
--                                                                          --
7
--                                 B o d y                                  --
8
--                                                                          --
9
--          Copyright (C) 1992-2009, Free Software Foundation, Inc.         --
10
--                                                                          --
11
-- GNAT is free software;  you can  redistribute it  and/or modify it under --
12
-- terms of the  GNU General Public License as published  by the Free Soft- --
13
-- ware  Foundation;  either version 3,  or (at your option) any later ver- --
14
-- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
15
-- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
16
-- or FITNESS FOR A PARTICULAR PURPOSE.                                     --
17
--                                                                          --
18
-- You should have received a copy of the GNU General Public License along  --
19
-- with this program; see file COPYING3.  If not see                        --
20
-- <http://www.gnu.org/licenses/>.                                          --
21
--                                                                          --
22
-- GNAT was originally developed  by the GNAT team at  New York University. --
23
-- Extensive contributions were provided by Ada Core Technologies Inc.      --
24
--                                                                          --
25
------------------------------------------------------------------------------
26
 
27
with Atree;    use Atree;
28
with Debug;    use Debug;
29
with Debug_A;  use Debug_A;
30
with Elists;   use Elists;
31
with Errout;   use Errout;
32
with Expander; use Expander;
33
with Fname;    use Fname;
34
with HLO;      use HLO;
35
with Lib;      use Lib;
36
with Lib.Load; use Lib.Load;
37
with Nlists;   use Nlists;
38
with Output;   use Output;
39
with Sem_Attr; use Sem_Attr;
40
with Sem_Ch2;  use Sem_Ch2;
41
with Sem_Ch3;  use Sem_Ch3;
42
with Sem_Ch4;  use Sem_Ch4;
43
with Sem_Ch5;  use Sem_Ch5;
44
with Sem_Ch6;  use Sem_Ch6;
45
with Sem_Ch7;  use Sem_Ch7;
46
with Sem_Ch8;  use Sem_Ch8;
47
with Sem_Ch9;  use Sem_Ch9;
48
with Sem_Ch10; use Sem_Ch10;
49
with Sem_Ch11; use Sem_Ch11;
50
with Sem_Ch12; use Sem_Ch12;
51
with Sem_Ch13; use Sem_Ch13;
52
with Sem_Prag; use Sem_Prag;
53
with Sem_Util; use Sem_Util;
54
with Sinfo;    use Sinfo;
55
with Stand;    use Stand;
56
with Uintp;    use Uintp;
57
with Uname;    use Uname;
58
 
59
with Unchecked_Deallocation;
60
 
61
pragma Warnings (Off, Sem_Util);
62
--  Suppress warnings of unused with for Sem_Util (used only in asserts)
63
 
64
package body Sem is
65
 
66
   Debug_Unit_Walk : Boolean renames Debug_Flag_Dot_WW;
67
   --  Controls debugging printouts for Walk_Library_Items
68
 
69
   Outer_Generic_Scope : Entity_Id := Empty;
70
   --  Global reference to the outer scope that is generic. In a non
71
   --  generic context, it is empty. At the moment, it is only used
72
   --  for avoiding freezing of external references in generics.
73
 
74
   Comp_Unit_List : Elist_Id := No_Elist;
75
   --  Used by Walk_Library_Items. This is a list of N_Compilation_Unit nodes
76
   --  processed by Semantics, in an appropriate order. Initialized to
77
   --  No_Elist, because it's too early to call New_Elmt_List; we will set it
78
   --  to New_Elmt_List on first use.
79
 
80
   generic
81
      with procedure Action (Withed_Unit : Node_Id);
82
   procedure Walk_Withs_Immediate (CU : Node_Id; Include_Limited : Boolean);
83
   --  Walk all the with clauses of CU, and call Action for the with'ed
84
   --  unit. Ignore limited withs, unless Include_Limited is True.
85
   --  CU must be an N_Compilation_Unit.
86
 
87
   generic
88
      with procedure Action (Withed_Unit : Node_Id);
89
   procedure Walk_Withs (CU : Node_Id; Include_Limited : Boolean);
90
   --  Same as Walk_Withs_Immediate, but also include with clauses on subunits
91
   --  of this unit, since they count as dependences on their parent library
92
   --  item. CU must be an N_Compilation_Unit whose Unit is not an N_Subunit.
93
 
94
   procedure Write_Unit_Info
95
     (Unit_Num : Unit_Number_Type;
96
      Item     : Node_Id;
97
      Prefix   : String := "";
98
      Withs    : Boolean := False);
99
   --  Print out debugging information about the unit. Prefix precedes the rest
100
   --  of the printout. If Withs is True, we print out units with'ed by this
101
   --  unit (not counting limited withs).
102
 
103
   -------------
104
   -- Analyze --
105
   -------------
106
 
107
   procedure Analyze (N : Node_Id) is
108
   begin
109
      Debug_A_Entry ("analyzing  ", N);
110
 
111
      --  Immediate return if already analyzed
112
 
113
      if Analyzed (N) then
114
         Debug_A_Exit ("analyzing  ", N, "  (done, analyzed already)");
115
         return;
116
      end if;
117
 
118
      --  Otherwise processing depends on the node kind
119
 
120
      case Nkind (N) is
121
 
122
         when N_Abort_Statement =>
123
            Analyze_Abort_Statement (N);
124
 
125
         when N_Abstract_Subprogram_Declaration =>
126
            Analyze_Abstract_Subprogram_Declaration (N);
127
 
128
         when N_Accept_Alternative =>
129
            Analyze_Accept_Alternative (N);
130
 
131
         when N_Accept_Statement =>
132
            Analyze_Accept_Statement (N);
133
 
134
         when N_Aggregate =>
135
            Analyze_Aggregate (N);
136
 
137
         when N_Allocator =>
138
            Analyze_Allocator (N);
139
 
140
         when N_And_Then =>
141
            Analyze_Short_Circuit (N);
142
 
143
         when N_Assignment_Statement =>
144
            Analyze_Assignment (N);
145
 
146
         when N_Asynchronous_Select =>
147
            Analyze_Asynchronous_Select (N);
148
 
149
         when N_At_Clause =>
150
            Analyze_At_Clause (N);
151
 
152
         when N_Attribute_Reference =>
153
            Analyze_Attribute (N);
154
 
155
         when N_Attribute_Definition_Clause   =>
156
            Analyze_Attribute_Definition_Clause (N);
157
 
158
         when N_Block_Statement =>
159
            Analyze_Block_Statement (N);
160
 
161
         when N_Case_Statement =>
162
            Analyze_Case_Statement (N);
163
 
164
         when N_Character_Literal =>
165
            Analyze_Character_Literal (N);
166
 
167
         when N_Code_Statement =>
168
            Analyze_Code_Statement (N);
169
 
170
         when N_Compilation_Unit =>
171
            Analyze_Compilation_Unit (N);
172
 
173
         when N_Component_Declaration =>
174
            Analyze_Component_Declaration (N);
175
 
176
         when N_Conditional_Expression =>
177
            Analyze_Conditional_Expression (N);
178
 
179
         when N_Conditional_Entry_Call =>
180
            Analyze_Conditional_Entry_Call (N);
181
 
182
         when N_Delay_Alternative =>
183
            Analyze_Delay_Alternative (N);
184
 
185
         when N_Delay_Relative_Statement =>
186
            Analyze_Delay_Relative (N);
187
 
188
         when N_Delay_Until_Statement =>
189
            Analyze_Delay_Until (N);
190
 
191
         when N_Entry_Body =>
192
            Analyze_Entry_Body (N);
193
 
194
         when N_Entry_Body_Formal_Part =>
195
            Analyze_Entry_Body_Formal_Part (N);
196
 
197
         when N_Entry_Call_Alternative =>
198
            Analyze_Entry_Call_Alternative (N);
199
 
200
         when N_Entry_Declaration =>
201
            Analyze_Entry_Declaration (N);
202
 
203
         when N_Entry_Index_Specification     =>
204
            Analyze_Entry_Index_Specification (N);
205
 
206
         when N_Enumeration_Representation_Clause =>
207
            Analyze_Enumeration_Representation_Clause (N);
208
 
209
         when N_Exception_Declaration =>
210
            Analyze_Exception_Declaration (N);
211
 
212
         when N_Exception_Renaming_Declaration =>
213
            Analyze_Exception_Renaming (N);
214
 
215
         when N_Exit_Statement =>
216
            Analyze_Exit_Statement (N);
217
 
218
         when N_Expanded_Name =>
219
            Analyze_Expanded_Name (N);
220
 
221
         when N_Explicit_Dereference =>
222
            Analyze_Explicit_Dereference (N);
223
 
224
         when N_Extended_Return_Statement =>
225
            Analyze_Extended_Return_Statement (N);
226
 
227
         when N_Extension_Aggregate =>
228
            Analyze_Aggregate (N);
229
 
230
         when N_Formal_Object_Declaration =>
231
            Analyze_Formal_Object_Declaration (N);
232
 
233
         when N_Formal_Package_Declaration =>
234
            Analyze_Formal_Package (N);
235
 
236
         when N_Formal_Subprogram_Declaration =>
237
            Analyze_Formal_Subprogram (N);
238
 
239
         when N_Formal_Type_Declaration =>
240
            Analyze_Formal_Type_Declaration (N);
241
 
242
         when N_Free_Statement =>
243
            Analyze_Free_Statement (N);
244
 
245
         when N_Freeze_Entity =>
246
            Analyze_Freeze_Entity (N);
247
 
248
         when N_Full_Type_Declaration =>
249
            Analyze_Type_Declaration (N);
250
 
251
         when N_Function_Call =>
252
            Analyze_Function_Call (N);
253
 
254
         when N_Function_Instantiation =>
255
            Analyze_Function_Instantiation (N);
256
 
257
         when N_Generic_Function_Renaming_Declaration =>
258
            Analyze_Generic_Function_Renaming (N);
259
 
260
         when N_Generic_Package_Declaration =>
261
            Analyze_Generic_Package_Declaration (N);
262
 
263
         when N_Generic_Package_Renaming_Declaration =>
264
            Analyze_Generic_Package_Renaming (N);
265
 
266
         when N_Generic_Procedure_Renaming_Declaration =>
267
            Analyze_Generic_Procedure_Renaming (N);
268
 
269
         when N_Generic_Subprogram_Declaration =>
270
            Analyze_Generic_Subprogram_Declaration (N);
271
 
272
         when N_Goto_Statement =>
273
            Analyze_Goto_Statement (N);
274
 
275
         when N_Handled_Sequence_Of_Statements =>
276
            Analyze_Handled_Statements (N);
277
 
278
         when N_Identifier =>
279
            Analyze_Identifier (N);
280
 
281
         when N_If_Statement =>
282
            Analyze_If_Statement (N);
283
 
284
         when N_Implicit_Label_Declaration =>
285
            Analyze_Implicit_Label_Declaration (N);
286
 
287
         when N_In =>
288
            Analyze_Membership_Op (N);
289
 
290
         when N_Incomplete_Type_Declaration =>
291
            Analyze_Incomplete_Type_Decl (N);
292
 
293
         when N_Indexed_Component =>
294
            Analyze_Indexed_Component_Form (N);
295
 
296
         when N_Integer_Literal =>
297
            Analyze_Integer_Literal (N);
298
 
299
         when N_Itype_Reference =>
300
            Analyze_Itype_Reference (N);
301
 
302
         when N_Label =>
303
            Analyze_Label (N);
304
 
305
         when N_Loop_Statement =>
306
            Analyze_Loop_Statement (N);
307
 
308
         when N_Not_In =>
309
            Analyze_Membership_Op (N);
310
 
311
         when N_Null =>
312
            Analyze_Null (N);
313
 
314
         when N_Null_Statement =>
315
            Analyze_Null_Statement (N);
316
 
317
         when N_Number_Declaration =>
318
            Analyze_Number_Declaration (N);
319
 
320
         when N_Object_Declaration =>
321
            Analyze_Object_Declaration (N);
322
 
323
         when N_Object_Renaming_Declaration  =>
324
            Analyze_Object_Renaming (N);
325
 
326
         when N_Operator_Symbol =>
327
            Analyze_Operator_Symbol (N);
328
 
329
         when N_Op_Abs =>
330
            Analyze_Unary_Op (N);
331
 
332
         when N_Op_Add =>
333
            Analyze_Arithmetic_Op (N);
334
 
335
         when N_Op_And =>
336
            Analyze_Logical_Op (N);
337
 
338
         when N_Op_Concat =>
339
            Analyze_Concatenation (N);
340
 
341
         when N_Op_Divide =>
342
            Analyze_Arithmetic_Op (N);
343
 
344
         when N_Op_Eq =>
345
            Analyze_Equality_Op (N);
346
 
347
         when N_Op_Expon =>
348
            Analyze_Arithmetic_Op (N);
349
 
350
         when N_Op_Ge =>
351
            Analyze_Comparison_Op (N);
352
 
353
         when N_Op_Gt =>
354
            Analyze_Comparison_Op (N);
355
 
356
         when N_Op_Le =>
357
            Analyze_Comparison_Op (N);
358
 
359
         when N_Op_Lt =>
360
            Analyze_Comparison_Op (N);
361
 
362
         when N_Op_Minus =>
363
            Analyze_Unary_Op (N);
364
 
365
         when N_Op_Mod =>
366
            Analyze_Arithmetic_Op (N);
367
 
368
         when N_Op_Multiply =>
369
            Analyze_Arithmetic_Op (N);
370
 
371
         when N_Op_Ne =>
372
            Analyze_Equality_Op (N);
373
 
374
         when N_Op_Not =>
375
            Analyze_Negation (N);
376
 
377
         when N_Op_Or =>
378
            Analyze_Logical_Op (N);
379
 
380
         when N_Op_Plus =>
381
            Analyze_Unary_Op (N);
382
 
383
         when N_Op_Rem =>
384
            Analyze_Arithmetic_Op (N);
385
 
386
         when N_Op_Rotate_Left =>
387
            Analyze_Arithmetic_Op (N);
388
 
389
         when N_Op_Rotate_Right =>
390
            Analyze_Arithmetic_Op (N);
391
 
392
         when N_Op_Shift_Left =>
393
            Analyze_Arithmetic_Op (N);
394
 
395
         when N_Op_Shift_Right =>
396
            Analyze_Arithmetic_Op (N);
397
 
398
         when N_Op_Shift_Right_Arithmetic =>
399
            Analyze_Arithmetic_Op (N);
400
 
401
         when N_Op_Subtract =>
402
            Analyze_Arithmetic_Op (N);
403
 
404
         when N_Op_Xor =>
405
            Analyze_Logical_Op (N);
406
 
407
         when N_Or_Else =>
408
            Analyze_Short_Circuit (N);
409
 
410
         when N_Others_Choice =>
411
            Analyze_Others_Choice (N);
412
 
413
         when N_Package_Body =>
414
            Analyze_Package_Body (N);
415
 
416
         when N_Package_Body_Stub =>
417
            Analyze_Package_Body_Stub (N);
418
 
419
         when N_Package_Declaration =>
420
            Analyze_Package_Declaration (N);
421
 
422
         when N_Package_Instantiation =>
423
            Analyze_Package_Instantiation (N);
424
 
425
         when N_Package_Renaming_Declaration =>
426
            Analyze_Package_Renaming (N);
427
 
428
         when N_Package_Specification =>
429
            Analyze_Package_Specification (N);
430
 
431
         when N_Parameter_Association =>
432
            Analyze_Parameter_Association (N);
433
 
434
         when N_Pragma =>
435
            Analyze_Pragma (N);
436
 
437
         when N_Private_Extension_Declaration =>
438
            Analyze_Private_Extension_Declaration (N);
439
 
440
         when N_Private_Type_Declaration =>
441
            Analyze_Private_Type_Declaration (N);
442
 
443
         when N_Procedure_Call_Statement =>
444
            Analyze_Procedure_Call (N);
445
 
446
         when N_Procedure_Instantiation =>
447
            Analyze_Procedure_Instantiation (N);
448
 
449
         when N_Protected_Body =>
450
            Analyze_Protected_Body (N);
451
 
452
         when N_Protected_Body_Stub =>
453
            Analyze_Protected_Body_Stub (N);
454
 
455
         when N_Protected_Definition =>
456
            Analyze_Protected_Definition (N);
457
 
458
         when N_Protected_Type_Declaration =>
459
            Analyze_Protected_Type (N);
460
 
461
         when N_Qualified_Expression =>
462
            Analyze_Qualified_Expression (N);
463
 
464
         when N_Raise_Statement =>
465
            Analyze_Raise_Statement (N);
466
 
467
         when N_Raise_xxx_Error =>
468
            Analyze_Raise_xxx_Error (N);
469
 
470
         when N_Range =>
471
            Analyze_Range (N);
472
 
473
         when N_Range_Constraint =>
474
            Analyze_Range (Range_Expression (N));
475
 
476
         when N_Real_Literal =>
477
            Analyze_Real_Literal (N);
478
 
479
         when N_Record_Representation_Clause =>
480
            Analyze_Record_Representation_Clause (N);
481
 
482
         when N_Reference =>
483
            Analyze_Reference (N);
484
 
485
         when N_Requeue_Statement =>
486
            Analyze_Requeue (N);
487
 
488
         when N_Simple_Return_Statement =>
489
            Analyze_Simple_Return_Statement (N);
490
 
491
         when N_Selected_Component =>
492
            Find_Selected_Component (N);
493
            --  ??? why not Analyze_Selected_Component, needs comments
494
 
495
         when N_Selective_Accept =>
496
            Analyze_Selective_Accept (N);
497
 
498
         when N_Single_Protected_Declaration =>
499
            Analyze_Single_Protected (N);
500
 
501
         when N_Single_Task_Declaration =>
502
            Analyze_Single_Task (N);
503
 
504
         when N_Slice =>
505
            Analyze_Slice (N);
506
 
507
         when N_String_Literal =>
508
            Analyze_String_Literal (N);
509
 
510
         when N_Subprogram_Body =>
511
            Analyze_Subprogram_Body (N);
512
 
513
         when N_Subprogram_Body_Stub =>
514
            Analyze_Subprogram_Body_Stub (N);
515
 
516
         when N_Subprogram_Declaration =>
517
            Analyze_Subprogram_Declaration (N);
518
 
519
         when N_Subprogram_Info =>
520
            Analyze_Subprogram_Info (N);
521
 
522
         when N_Subprogram_Renaming_Declaration =>
523
            Analyze_Subprogram_Renaming (N);
524
 
525
         when N_Subtype_Declaration =>
526
            Analyze_Subtype_Declaration (N);
527
 
528
         when N_Subtype_Indication =>
529
            Analyze_Subtype_Indication (N);
530
 
531
         when N_Subunit =>
532
            Analyze_Subunit (N);
533
 
534
         when N_Task_Body =>
535
            Analyze_Task_Body (N);
536
 
537
         when N_Task_Body_Stub =>
538
            Analyze_Task_Body_Stub (N);
539
 
540
         when N_Task_Definition =>
541
            Analyze_Task_Definition (N);
542
 
543
         when N_Task_Type_Declaration =>
544
            Analyze_Task_Type (N);
545
 
546
         when N_Terminate_Alternative =>
547
            Analyze_Terminate_Alternative (N);
548
 
549
         when N_Timed_Entry_Call =>
550
            Analyze_Timed_Entry_Call (N);
551
 
552
         when N_Triggering_Alternative =>
553
            Analyze_Triggering_Alternative (N);
554
 
555
         when N_Type_Conversion =>
556
            Analyze_Type_Conversion (N);
557
 
558
         when N_Unchecked_Expression =>
559
            Analyze_Unchecked_Expression (N);
560
 
561
         when N_Unchecked_Type_Conversion =>
562
            Analyze_Unchecked_Type_Conversion (N);
563
 
564
         when N_Use_Package_Clause =>
565
            Analyze_Use_Package (N);
566
 
567
         when N_Use_Type_Clause =>
568
            Analyze_Use_Type (N);
569
 
570
         when N_Validate_Unchecked_Conversion =>
571
            null;
572
 
573
         when N_Variant_Part =>
574
            Analyze_Variant_Part (N);
575
 
576
         when N_With_Clause =>
577
            Analyze_With_Clause (N);
578
 
579
         --  A call to analyze the Empty node is an error, but most likely
580
         --  it is an error caused by an attempt to analyze a malformed
581
         --  piece of tree caused by some other error, so if there have
582
         --  been any other errors, we just ignore it, otherwise it is
583
         --  a real internal error which we complain about.
584
 
585
         --  We must also consider the case of call to a runtime function
586
         --  that is not available in the configurable runtime.
587
 
588
         when N_Empty =>
589
            pragma Assert (Serious_Errors_Detected /= 0
590
              or else Configurable_Run_Time_Violations /= 0);
591
            null;
592
 
593
         --  A call to analyze the error node is simply ignored, to avoid
594
         --  causing cascaded errors (happens of course only in error cases)
595
 
596
         when N_Error =>
597
            null;
598
 
599
         --  Push/Pop nodes normally don't come through an analyze call. An
600
         --  exception is the dummy ones bracketing a subprogram body. In any
601
         --  case there is nothing to be done to analyze such nodes.
602
 
603
         when N_Push_Pop_xxx_Label =>
604
            null;
605
 
606
         --  SCIL nodes don't need analysis because they are decorated when
607
         --  they are built. They are added to the tree by Insert_Actions and
608
         --  the call to analyze them is generated when the full list is
609
         --  analyzed.
610
 
611
         when
612
           N_SCIL_Dispatch_Table_Object_Init        |
613
           N_SCIL_Dispatch_Table_Tag_Init           |
614
           N_SCIL_Dispatching_Call                  |
615
           N_SCIL_Membership_Test                   |
616
           N_SCIL_Tag_Init                          =>
617
            null;
618
 
619
         --  For the remaining node types, we generate compiler abort, because
620
         --  these nodes are always analyzed within the Sem_Chn routines and
621
         --  there should never be a case of making a call to the main Analyze
622
         --  routine for these node kinds. For example, an N_Access_Definition
623
         --  node appears only in the context of a type declaration, and is
624
         --  processed by the analyze routine for type declarations.
625
 
626
         when
627
           N_Abortable_Part                         |
628
           N_Access_Definition                      |
629
           N_Access_Function_Definition             |
630
           N_Access_Procedure_Definition            |
631
           N_Access_To_Object_Definition            |
632
           N_Case_Statement_Alternative             |
633
           N_Compilation_Unit_Aux                   |
634
           N_Component_Association                  |
635
           N_Component_Clause                       |
636
           N_Component_Definition                   |
637
           N_Component_List                         |
638
           N_Constrained_Array_Definition           |
639
           N_Decimal_Fixed_Point_Definition         |
640
           N_Defining_Character_Literal             |
641
           N_Defining_Identifier                    |
642
           N_Defining_Operator_Symbol               |
643
           N_Defining_Program_Unit_Name             |
644
           N_Delta_Constraint                       |
645
           N_Derived_Type_Definition                |
646
           N_Designator                             |
647
           N_Digits_Constraint                      |
648
           N_Discriminant_Association               |
649
           N_Discriminant_Specification             |
650
           N_Elsif_Part                             |
651
           N_Entry_Call_Statement                   |
652
           N_Enumeration_Type_Definition            |
653
           N_Exception_Handler                      |
654
           N_Floating_Point_Definition              |
655
           N_Formal_Decimal_Fixed_Point_Definition  |
656
           N_Formal_Derived_Type_Definition         |
657
           N_Formal_Discrete_Type_Definition        |
658
           N_Formal_Floating_Point_Definition       |
659
           N_Formal_Modular_Type_Definition         |
660
           N_Formal_Ordinary_Fixed_Point_Definition |
661
           N_Formal_Private_Type_Definition         |
662
           N_Formal_Signed_Integer_Type_Definition  |
663
           N_Function_Specification                 |
664
           N_Generic_Association                    |
665
           N_Index_Or_Discriminant_Constraint       |
666
           N_Iteration_Scheme                       |
667
           N_Loop_Parameter_Specification           |
668
           N_Mod_Clause                             |
669
           N_Modular_Type_Definition                |
670
           N_Ordinary_Fixed_Point_Definition        |
671
           N_Parameter_Specification                |
672
           N_Pragma_Argument_Association            |
673
           N_Procedure_Specification                |
674
           N_Real_Range_Specification               |
675
           N_Record_Definition                      |
676
           N_Signed_Integer_Type_Definition         |
677
           N_Unconstrained_Array_Definition         |
678
           N_Unused_At_Start                        |
679
           N_Unused_At_End                          |
680
           N_Variant                                =>
681
 
682
            raise Program_Error;
683
      end case;
684
 
685
      Debug_A_Exit ("analyzing  ", N, "  (done)");
686
 
687
      --  Now that we have analyzed the node, we call the expander to perform
688
      --  possible expansion. We skip this for subexpressions, because we don't
689
      --  have the type yet, and the expander will need to know the type before
690
      --  it can do its job. For subexpression nodes, the call to the expander
691
      --  happens in Sem_Res.Resolve. A special exception is Raise_xxx_Error,
692
      --  which can appear in a statement context, and needs expanding now in
693
      --  the case (distinguished by Etype, as documented in Sinfo).
694
 
695
      --  The Analyzed flag is also set at this point for non-subexpression
696
      --  nodes (in the case of subexpression nodes, we can't set the flag yet,
697
      --  since resolution and expansion have not yet been completed). Note
698
      --  that for N_Raise_xxx_Error we have to distinguish the expression
699
      --  case from the statement case.
700
 
701
      if Nkind (N) not in N_Subexpr
702
        or else (Nkind (N) in N_Raise_xxx_Error
703
                  and then Etype (N) = Standard_Void_Type)
704
      then
705
         Expand (N);
706
      end if;
707
   end Analyze;
708
 
709
   --  Version with check(s) suppressed
710
 
711
   procedure Analyze (N : Node_Id; Suppress : Check_Id) is
712
   begin
713
      if Suppress = All_Checks then
714
         declare
715
            Svg : constant Suppress_Array := Scope_Suppress;
716
         begin
717
            Scope_Suppress := (others => True);
718
            Analyze (N);
719
            Scope_Suppress := Svg;
720
         end;
721
 
722
      else
723
         declare
724
            Svg : constant Boolean := Scope_Suppress (Suppress);
725
         begin
726
            Scope_Suppress (Suppress) := True;
727
            Analyze (N);
728
            Scope_Suppress (Suppress) := Svg;
729
         end;
730
      end if;
731
   end Analyze;
732
 
733
   ------------------
734
   -- Analyze_List --
735
   ------------------
736
 
737
   procedure Analyze_List (L : List_Id) is
738
      Node : Node_Id;
739
 
740
   begin
741
      Node := First (L);
742
      while Present (Node) loop
743
         Analyze (Node);
744
         Next (Node);
745
      end loop;
746
   end Analyze_List;
747
 
748
   --  Version with check(s) suppressed
749
 
750
   procedure Analyze_List (L : List_Id; Suppress : Check_Id) is
751
   begin
752
      if Suppress = All_Checks then
753
         declare
754
            Svg : constant Suppress_Array := Scope_Suppress;
755
         begin
756
            Scope_Suppress := (others => True);
757
            Analyze_List (L);
758
            Scope_Suppress := Svg;
759
         end;
760
 
761
      else
762
         declare
763
            Svg : constant Boolean := Scope_Suppress (Suppress);
764
         begin
765
            Scope_Suppress (Suppress) := True;
766
            Analyze_List (L);
767
            Scope_Suppress (Suppress) := Svg;
768
         end;
769
      end if;
770
   end Analyze_List;
771
 
772
   --------------------------
773
   -- Copy_Suppress_Status --
774
   --------------------------
775
 
776
   procedure Copy_Suppress_Status
777
     (C    : Check_Id;
778
      From : Entity_Id;
779
      To   : Entity_Id)
780
   is
781
      Found : Boolean;
782
      pragma Warnings (Off, Found);
783
 
784
      procedure Search_Stack
785
        (Top   : Suppress_Stack_Entry_Ptr;
786
         Found : out Boolean);
787
      --  Search given suppress stack for matching entry for entity. If found
788
      --  then set Checks_May_Be_Suppressed on To, and push an appropriate
789
      --  entry for To onto the local suppress stack.
790
 
791
      ------------------
792
      -- Search_Stack --
793
      ------------------
794
 
795
      procedure Search_Stack
796
        (Top   : Suppress_Stack_Entry_Ptr;
797
         Found : out Boolean)
798
      is
799
         Ptr : Suppress_Stack_Entry_Ptr;
800
 
801
      begin
802
         Ptr := Top;
803
         while Ptr /= null loop
804
            if Ptr.Entity = From
805
              and then (Ptr.Check = All_Checks or else Ptr.Check = C)
806
            then
807
               if Ptr.Suppress then
808
                  Set_Checks_May_Be_Suppressed (To, True);
809
                  Push_Local_Suppress_Stack_Entry
810
                    (Entity   => To,
811
                     Check    => C,
812
                     Suppress => True);
813
                  Found := True;
814
                  return;
815
               end if;
816
            end if;
817
 
818
            Ptr := Ptr.Prev;
819
         end loop;
820
 
821
         Found := False;
822
         return;
823
      end Search_Stack;
824
 
825
   --  Start of processing for Copy_Suppress_Status
826
 
827
   begin
828
      if not Checks_May_Be_Suppressed (From) then
829
         return;
830
      end if;
831
 
832
      --  First search the local entity suppress stack, we search this in
833
      --  reverse order so that we get the innermost entry that applies to
834
      --  this case if there are nested entries. Note that for the purpose
835
      --  of this procedure we are ONLY looking for entries corresponding
836
      --  to a two-argument Suppress, where the second argument matches From.
837
 
838
      Search_Stack (Global_Suppress_Stack_Top, Found);
839
 
840
      if Found then
841
         return;
842
      end if;
843
 
844
      --  Now search the global entity suppress table for a matching entry
845
      --  We also search this in reverse order so that if there are multiple
846
      --  pragmas for the same entity, the last one applies.
847
 
848
      Search_Stack (Local_Suppress_Stack_Top, Found);
849
   end Copy_Suppress_Status;
850
 
851
   -------------------------
852
   -- Enter_Generic_Scope --
853
   -------------------------
854
 
855
   procedure Enter_Generic_Scope (S : Entity_Id) is
856
   begin
857
      if No (Outer_Generic_Scope) then
858
         Outer_Generic_Scope := S;
859
      end if;
860
   end Enter_Generic_Scope;
861
 
862
   ------------------------
863
   -- Exit_Generic_Scope --
864
   ------------------------
865
 
866
   procedure Exit_Generic_Scope  (S : Entity_Id) is
867
   begin
868
      if S = Outer_Generic_Scope then
869
         Outer_Generic_Scope := Empty;
870
      end if;
871
   end Exit_Generic_Scope;
872
 
873
   -----------------------
874
   -- Explicit_Suppress --
875
   -----------------------
876
 
877
   function Explicit_Suppress (E : Entity_Id; C : Check_Id) return Boolean is
878
      Ptr : Suppress_Stack_Entry_Ptr;
879
 
880
   begin
881
      if not Checks_May_Be_Suppressed (E) then
882
         return False;
883
 
884
      else
885
         Ptr := Global_Suppress_Stack_Top;
886
         while Ptr /= null loop
887
            if Ptr.Entity = E
888
              and then (Ptr.Check = All_Checks or else Ptr.Check = C)
889
            then
890
               return Ptr.Suppress;
891
            end if;
892
 
893
            Ptr := Ptr.Prev;
894
         end loop;
895
      end if;
896
 
897
      return False;
898
   end Explicit_Suppress;
899
 
900
   -----------------------------
901
   -- External_Ref_In_Generic --
902
   -----------------------------
903
 
904
   function External_Ref_In_Generic (E : Entity_Id) return Boolean is
905
      Scop : Entity_Id;
906
 
907
   begin
908
      --  Entity is global if defined outside of current outer_generic_scope:
909
      --  Either the entity has a smaller depth that the outer generic, or it
910
      --  is in a different compilation unit, or it is defined within a unit
911
      --  in the same compilation, that is not within the outer_generic.
912
 
913
      if No (Outer_Generic_Scope) then
914
         return False;
915
 
916
      elsif Scope_Depth (Scope (E)) < Scope_Depth (Outer_Generic_Scope)
917
        or else not In_Same_Source_Unit (E, Outer_Generic_Scope)
918
      then
919
         return True;
920
 
921
      else
922
         Scop := Scope (E);
923
 
924
         while Present (Scop) loop
925
            if Scop = Outer_Generic_Scope then
926
               return False;
927
            elsif Scope_Depth (Scop) < Scope_Depth (Outer_Generic_Scope) then
928
               return True;
929
            else
930
               Scop := Scope (Scop);
931
            end if;
932
         end loop;
933
 
934
         return True;
935
      end if;
936
   end External_Ref_In_Generic;
937
 
938
   ----------------
939
   -- Initialize --
940
   ----------------
941
 
942
   procedure Initialize is
943
      Next : Suppress_Stack_Entry_Ptr;
944
 
945
      procedure Free is new Unchecked_Deallocation
946
        (Suppress_Stack_Entry, Suppress_Stack_Entry_Ptr);
947
 
948
   begin
949
      --  Free any global suppress stack entries from a previous invocation
950
      --  of the compiler (in the normal case this loop does nothing).
951
 
952
      while Suppress_Stack_Entries /= null loop
953
         Next := Global_Suppress_Stack_Top.Next;
954
         Free (Suppress_Stack_Entries);
955
         Suppress_Stack_Entries := Next;
956
      end loop;
957
 
958
      Local_Suppress_Stack_Top := null;
959
      Global_Suppress_Stack_Top := null;
960
 
961
      --  Clear scope stack, and reset global variables
962
 
963
      Scope_Stack.Init;
964
      Unloaded_Subunits := False;
965
   end Initialize;
966
 
967
   ------------------------------
968
   -- Insert_After_And_Analyze --
969
   ------------------------------
970
 
971
   procedure Insert_After_And_Analyze (N : Node_Id; M : Node_Id) is
972
      Node : Node_Id;
973
 
974
   begin
975
      if Present (M) then
976
 
977
         --  If we are not at the end of the list, then the easiest
978
         --  coding is simply to insert before our successor
979
 
980
         if Present (Next (N)) then
981
            Insert_Before_And_Analyze (Next (N), M);
982
 
983
         --  Case of inserting at the end of the list
984
 
985
         else
986
            --  Capture the Node_Id of the node to be inserted. This Node_Id
987
            --  will still be the same after the insert operation.
988
 
989
            Node := M;
990
            Insert_After (N, M);
991
 
992
            --  Now just analyze from the inserted node to the end of
993
            --  the new list (note that this properly handles the case
994
            --  where any of the analyze calls result in the insertion of
995
            --  nodes after the analyzed node, expecting analysis).
996
 
997
            while Present (Node) loop
998
               Analyze (Node);
999
               Mark_Rewrite_Insertion (Node);
1000
               Next (Node);
1001
            end loop;
1002
         end if;
1003
      end if;
1004
   end Insert_After_And_Analyze;
1005
 
1006
   --  Version with check(s) suppressed
1007
 
1008
   procedure Insert_After_And_Analyze
1009
     (N        : Node_Id;
1010
      M        : Node_Id;
1011
      Suppress : Check_Id)
1012
   is
1013
   begin
1014
      if Suppress = All_Checks then
1015
         declare
1016
            Svg : constant Suppress_Array := Scope_Suppress;
1017
         begin
1018
            Scope_Suppress := (others => True);
1019
            Insert_After_And_Analyze (N, M);
1020
            Scope_Suppress := Svg;
1021
         end;
1022
 
1023
      else
1024
         declare
1025
            Svg : constant Boolean := Scope_Suppress (Suppress);
1026
         begin
1027
            Scope_Suppress (Suppress) := True;
1028
            Insert_After_And_Analyze (N, M);
1029
            Scope_Suppress (Suppress) := Svg;
1030
         end;
1031
      end if;
1032
   end Insert_After_And_Analyze;
1033
 
1034
   -------------------------------
1035
   -- Insert_Before_And_Analyze --
1036
   -------------------------------
1037
 
1038
   procedure Insert_Before_And_Analyze (N : Node_Id; M : Node_Id) is
1039
      Node : Node_Id;
1040
 
1041
   begin
1042
      if Present (M) then
1043
 
1044
         --  Capture the Node_Id of the first list node to be inserted.
1045
         --  This will still be the first node after the insert operation,
1046
         --  since Insert_List_After does not modify the Node_Id values.
1047
 
1048
         Node := M;
1049
         Insert_Before (N, M);
1050
 
1051
         --  The insertion does not change the Id's of any of the nodes in
1052
         --  the list, and they are still linked, so we can simply loop from
1053
         --  the original first node until we meet the node before which the
1054
         --  insertion is occurring. Note that this properly handles the case
1055
         --  where any of the analyzed nodes insert nodes after themselves,
1056
         --  expecting them to get analyzed.
1057
 
1058
         while Node /= N loop
1059
            Analyze (Node);
1060
            Mark_Rewrite_Insertion (Node);
1061
            Next (Node);
1062
         end loop;
1063
      end if;
1064
   end Insert_Before_And_Analyze;
1065
 
1066
   --  Version with check(s) suppressed
1067
 
1068
   procedure Insert_Before_And_Analyze
1069
     (N        : Node_Id;
1070
      M        : Node_Id;
1071
      Suppress : Check_Id)
1072
   is
1073
   begin
1074
      if Suppress = All_Checks then
1075
         declare
1076
            Svg : constant Suppress_Array := Scope_Suppress;
1077
         begin
1078
            Scope_Suppress := (others => True);
1079
            Insert_Before_And_Analyze (N, M);
1080
            Scope_Suppress := Svg;
1081
         end;
1082
 
1083
      else
1084
         declare
1085
            Svg : constant Boolean := Scope_Suppress (Suppress);
1086
         begin
1087
            Scope_Suppress (Suppress) := True;
1088
            Insert_Before_And_Analyze (N, M);
1089
            Scope_Suppress (Suppress) := Svg;
1090
         end;
1091
      end if;
1092
   end Insert_Before_And_Analyze;
1093
 
1094
   -----------------------------------
1095
   -- Insert_List_After_And_Analyze --
1096
   -----------------------------------
1097
 
1098
   procedure Insert_List_After_And_Analyze (N : Node_Id; L : List_Id) is
1099
      After : constant Node_Id := Next (N);
1100
      Node  : Node_Id;
1101
 
1102
   begin
1103
      if Is_Non_Empty_List (L) then
1104
 
1105
         --  Capture the Node_Id of the first list node to be inserted.
1106
         --  This will still be the first node after the insert operation,
1107
         --  since Insert_List_After does not modify the Node_Id values.
1108
 
1109
         Node := First (L);
1110
         Insert_List_After (N, L);
1111
 
1112
         --  Now just analyze from the original first node until we get to
1113
         --  the successor of the original insertion point (which may be
1114
         --  Empty if the insertion point was at the end of the list). Note
1115
         --  that this properly handles the case where any of the analyze
1116
         --  calls result in the insertion of nodes after the analyzed
1117
         --  node (possibly calling this routine recursively).
1118
 
1119
         while Node /= After loop
1120
            Analyze (Node);
1121
            Mark_Rewrite_Insertion (Node);
1122
            Next (Node);
1123
         end loop;
1124
      end if;
1125
   end Insert_List_After_And_Analyze;
1126
 
1127
   --  Version with check(s) suppressed
1128
 
1129
   procedure Insert_List_After_And_Analyze
1130
     (N : Node_Id; L : List_Id; Suppress : Check_Id)
1131
   is
1132
   begin
1133
      if Suppress = All_Checks then
1134
         declare
1135
            Svg : constant Suppress_Array := Scope_Suppress;
1136
         begin
1137
            Scope_Suppress := (others => True);
1138
            Insert_List_After_And_Analyze (N, L);
1139
            Scope_Suppress := Svg;
1140
         end;
1141
 
1142
      else
1143
         declare
1144
            Svg : constant Boolean := Scope_Suppress (Suppress);
1145
         begin
1146
            Scope_Suppress (Suppress) := True;
1147
            Insert_List_After_And_Analyze (N, L);
1148
            Scope_Suppress (Suppress) := Svg;
1149
         end;
1150
      end if;
1151
   end Insert_List_After_And_Analyze;
1152
 
1153
   ------------------------------------
1154
   -- Insert_List_Before_And_Analyze --
1155
   ------------------------------------
1156
 
1157
   procedure Insert_List_Before_And_Analyze (N : Node_Id; L : List_Id) is
1158
      Node : Node_Id;
1159
 
1160
   begin
1161
      if Is_Non_Empty_List (L) then
1162
 
1163
         --  Capture the Node_Id of the first list node to be inserted.
1164
         --  This will still be the first node after the insert operation,
1165
         --  since Insert_List_After does not modify the Node_Id values.
1166
 
1167
         Node := First (L);
1168
         Insert_List_Before (N, L);
1169
 
1170
         --  The insertion does not change the Id's of any of the nodes in
1171
         --  the list, and they are still linked, so we can simply loop from
1172
         --  the original first node until we meet the node before which the
1173
         --  insertion is occurring. Note that this properly handles the case
1174
         --  where any of the analyzed nodes insert nodes after themselves,
1175
         --  expecting them to get analyzed.
1176
 
1177
         while Node /= N loop
1178
            Analyze (Node);
1179
            Mark_Rewrite_Insertion (Node);
1180
            Next (Node);
1181
         end loop;
1182
      end if;
1183
   end Insert_List_Before_And_Analyze;
1184
 
1185
   --  Version with check(s) suppressed
1186
 
1187
   procedure Insert_List_Before_And_Analyze
1188
     (N : Node_Id; L : List_Id; Suppress : Check_Id)
1189
   is
1190
   begin
1191
      if Suppress = All_Checks then
1192
         declare
1193
            Svg : constant Suppress_Array := Scope_Suppress;
1194
         begin
1195
            Scope_Suppress := (others => True);
1196
            Insert_List_Before_And_Analyze (N, L);
1197
            Scope_Suppress := Svg;
1198
         end;
1199
 
1200
      else
1201
         declare
1202
            Svg : constant Boolean := Scope_Suppress (Suppress);
1203
         begin
1204
            Scope_Suppress (Suppress) := True;
1205
            Insert_List_Before_And_Analyze (N, L);
1206
            Scope_Suppress (Suppress) := Svg;
1207
         end;
1208
      end if;
1209
   end Insert_List_Before_And_Analyze;
1210
 
1211
   -------------------------
1212
   -- Is_Check_Suppressed --
1213
   -------------------------
1214
 
1215
   function Is_Check_Suppressed (E : Entity_Id; C : Check_Id) return Boolean is
1216
 
1217
      Ptr : Suppress_Stack_Entry_Ptr;
1218
 
1219
   begin
1220
      --  First search the local entity suppress stack, we search this from the
1221
      --  top of the stack down, so that we get the innermost entry that
1222
      --  applies to this case if there are nested entries.
1223
 
1224
      Ptr := Local_Suppress_Stack_Top;
1225
      while Ptr /= null loop
1226
         if (Ptr.Entity = Empty or else Ptr.Entity = E)
1227
           and then (Ptr.Check = All_Checks or else Ptr.Check = C)
1228
         then
1229
            return Ptr.Suppress;
1230
         end if;
1231
 
1232
         Ptr := Ptr.Prev;
1233
      end loop;
1234
 
1235
      --  Now search the global entity suppress table for a matching entry
1236
      --  We also search this from the top down so that if there are multiple
1237
      --  pragmas for the same entity, the last one applies (not clear what
1238
      --  or whether the RM specifies this handling, but it seems reasonable).
1239
 
1240
      Ptr := Global_Suppress_Stack_Top;
1241
      while Ptr /= null loop
1242
         if (Ptr.Entity = Empty or else Ptr.Entity = E)
1243
           and then (Ptr.Check = All_Checks or else Ptr.Check = C)
1244
         then
1245
            return Ptr.Suppress;
1246
         end if;
1247
 
1248
         Ptr := Ptr.Prev;
1249
      end loop;
1250
 
1251
      --  If we did not find a matching entry, then use the normal scope
1252
      --  suppress value after all (actually this will be the global setting
1253
      --  since it clearly was not overridden at any point). For a predefined
1254
      --  check, we test the specific flag. For a user defined check, we check
1255
      --  the All_Checks flag.
1256
 
1257
      if C in Predefined_Check_Id then
1258
         return Scope_Suppress (C);
1259
      else
1260
         return Scope_Suppress (All_Checks);
1261
      end if;
1262
   end Is_Check_Suppressed;
1263
 
1264
   ----------
1265
   -- Lock --
1266
   ----------
1267
 
1268
   procedure Lock is
1269
   begin
1270
      Scope_Stack.Locked := True;
1271
      Scope_Stack.Release;
1272
   end Lock;
1273
 
1274
   --------------------------------------
1275
   -- Push_Global_Suppress_Stack_Entry --
1276
   --------------------------------------
1277
 
1278
   procedure Push_Global_Suppress_Stack_Entry
1279
     (Entity   : Entity_Id;
1280
      Check    : Check_Id;
1281
      Suppress : Boolean)
1282
   is
1283
   begin
1284
      Global_Suppress_Stack_Top :=
1285
        new Suppress_Stack_Entry'
1286
          (Entity   => Entity,
1287
           Check    => Check,
1288
           Suppress => Suppress,
1289
           Prev     => Global_Suppress_Stack_Top,
1290
           Next     => Suppress_Stack_Entries);
1291
      Suppress_Stack_Entries := Global_Suppress_Stack_Top;
1292
      return;
1293
 
1294
   end Push_Global_Suppress_Stack_Entry;
1295
 
1296
   -------------------------------------
1297
   -- Push_Local_Suppress_Stack_Entry --
1298
   -------------------------------------
1299
 
1300
   procedure Push_Local_Suppress_Stack_Entry
1301
     (Entity   : Entity_Id;
1302
      Check    : Check_Id;
1303
      Suppress : Boolean)
1304
   is
1305
   begin
1306
      Local_Suppress_Stack_Top :=
1307
        new Suppress_Stack_Entry'
1308
          (Entity   => Entity,
1309
           Check    => Check,
1310
           Suppress => Suppress,
1311
           Prev     => Local_Suppress_Stack_Top,
1312
           Next     => Suppress_Stack_Entries);
1313
      Suppress_Stack_Entries := Local_Suppress_Stack_Top;
1314
 
1315
      return;
1316
   end Push_Local_Suppress_Stack_Entry;
1317
 
1318
   ---------------
1319
   -- Semantics --
1320
   ---------------
1321
 
1322
   procedure Semantics (Comp_Unit : Node_Id) is
1323
 
1324
      --  The following locations save the corresponding global flags and
1325
      --  variables so that they can be restored on completion. This is
1326
      --  needed so that calls to Rtsfind start with the proper default
1327
      --  values for these variables, and also that such calls do not
1328
      --  disturb the settings for units being analyzed at a higher level.
1329
 
1330
      S_Current_Sem_Unit : constant Unit_Number_Type := Current_Sem_Unit;
1331
      S_Full_Analysis    : constant Boolean          := Full_Analysis;
1332
      S_GNAT_Mode        : constant Boolean          := GNAT_Mode;
1333
      S_Global_Dis_Names : constant Boolean          := Global_Discard_Names;
1334
      S_In_Spec_Expr     : constant Boolean          := In_Spec_Expression;
1335
      S_Inside_A_Generic : constant Boolean          := Inside_A_Generic;
1336
      S_New_Nodes_OK     : constant Int              := New_Nodes_OK;
1337
      S_Outer_Gen_Scope  : constant Entity_Id        := Outer_Generic_Scope;
1338
 
1339
      Generic_Main : constant Boolean :=
1340
                       Nkind (Unit (Cunit (Main_Unit)))
1341
                         in N_Generic_Declaration;
1342
      --  If the main unit is generic, every compiled unit, including its
1343
      --  context, is compiled with expansion disabled.
1344
 
1345
      Save_Config_Switches : Config_Switches_Type;
1346
      --  Variable used to save values of config switches while we analyze
1347
      --  the new unit, to be restored on exit for proper recursive behavior.
1348
 
1349
      procedure Do_Analyze;
1350
      --  Procedure to analyze the compilation unit. This is called more
1351
      --  than once when the high level optimizer is activated.
1352
 
1353
      ----------------
1354
      -- Do_Analyze --
1355
      ----------------
1356
 
1357
      procedure Do_Analyze is
1358
      begin
1359
         Save_Scope_Stack;
1360
         Push_Scope (Standard_Standard);
1361
         Scope_Suppress := Suppress_Options;
1362
         Scope_Stack.Table
1363
           (Scope_Stack.Last).Component_Alignment_Default := Calign_Default;
1364
         Scope_Stack.Table
1365
           (Scope_Stack.Last).Is_Active_Stack_Base := True;
1366
         Outer_Generic_Scope := Empty;
1367
 
1368
         --  Now analyze the top level compilation unit node
1369
 
1370
         Analyze (Comp_Unit);
1371
 
1372
         --  Check for scope mismatch on exit from compilation
1373
 
1374
         pragma Assert (Current_Scope = Standard_Standard
1375
                          or else Comp_Unit = Cunit (Main_Unit));
1376
 
1377
         --  Then pop entry for Standard, and pop implicit types
1378
 
1379
         Pop_Scope;
1380
         Restore_Scope_Stack;
1381
      end Do_Analyze;
1382
 
1383
      Already_Analyzed : constant Boolean := Analyzed (Comp_Unit);
1384
 
1385
   --  Start of processing for Semantics
1386
 
1387
   begin
1388
      if Debug_Unit_Walk then
1389
         if Already_Analyzed then
1390
            Write_Str ("(done)");
1391
         end if;
1392
 
1393
         Write_Unit_Info
1394
           (Get_Cunit_Unit_Number (Comp_Unit),
1395
            Unit (Comp_Unit),
1396
            Prefix => "--> ");
1397
         Indent;
1398
      end if;
1399
 
1400
      Compiler_State   := Analyzing;
1401
      Current_Sem_Unit := Get_Cunit_Unit_Number (Comp_Unit);
1402
 
1403
      --  Compile predefined units with GNAT_Mode set to True, to properly
1404
      --  process the categorization stuff. However, do not set GNAT_Mode
1405
      --  to True for the renamings units (Text_IO, IO_Exceptions, Direct_IO,
1406
      --  Sequential_IO) as this would prevent pragma Extend_System from being
1407
      --  taken into account, for example when Text_IO is renaming DEC.Text_IO.
1408
 
1409
      --  Cleaner might be to do the kludge at the point of excluding the
1410
      --  pragma (do not exclude for renamings ???)
1411
 
1412
      if Is_Predefined_File_Name
1413
           (Unit_File_Name (Current_Sem_Unit), Renamings_Included => False)
1414
      then
1415
         GNAT_Mode := True;
1416
      end if;
1417
 
1418
      if Generic_Main then
1419
         Expander_Mode_Save_And_Set (False);
1420
      else
1421
         Expander_Mode_Save_And_Set
1422
           (Operating_Mode = Generate_Code or Debug_Flag_X);
1423
      end if;
1424
 
1425
      Full_Analysis      := True;
1426
      Inside_A_Generic   := False;
1427
      In_Spec_Expression := False;
1428
 
1429
      Set_Comes_From_Source_Default (False);
1430
      Save_Opt_Config_Switches (Save_Config_Switches);
1431
      Set_Opt_Config_Switches
1432
        (Is_Internal_File_Name (Unit_File_Name (Current_Sem_Unit)),
1433
         Current_Sem_Unit = Main_Unit);
1434
 
1435
      --  Only do analysis of unit that has not already been analyzed
1436
 
1437
      if not Analyzed (Comp_Unit) then
1438
         Initialize_Version (Current_Sem_Unit);
1439
         if HLO_Active then
1440
            Expander_Mode_Save_And_Set (False);
1441
            New_Nodes_OK := 1;
1442
            Do_Analyze;
1443
            Reset_Analyzed_Flags (Comp_Unit);
1444
            Expander_Mode_Restore;
1445
            High_Level_Optimize (Comp_Unit);
1446
            New_Nodes_OK := 0;
1447
         end if;
1448
 
1449
         --  Do analysis, and then append the compilation unit onto the
1450
         --  Comp_Unit_List, if appropriate. This is done after analysis, so
1451
         --  if this unit depends on some others, they have already been
1452
         --  appended. We ignore bodies, except for the main unit itself. We
1453
         --  have also to guard against ill-formed subunits that have an
1454
         --  improper context.
1455
 
1456
         Do_Analyze;
1457
 
1458
         if Present (Comp_Unit)
1459
           and then Nkind (Unit (Comp_Unit)) in N_Proper_Body
1460
           and then not In_Extended_Main_Source_Unit (Comp_Unit)
1461
         then
1462
            null;
1463
 
1464
         else
1465
            --  Initialize if first time
1466
 
1467
            if No (Comp_Unit_List) then
1468
               Comp_Unit_List := New_Elmt_List;
1469
            end if;
1470
 
1471
            Append_Elmt (Comp_Unit, Comp_Unit_List);
1472
 
1473
            if Debug_Unit_Walk then
1474
               Write_Str ("Appending ");
1475
               Write_Unit_Info
1476
                 (Get_Cunit_Unit_Number (Comp_Unit), Unit (Comp_Unit));
1477
            end if;
1478
         end if;
1479
      end if;
1480
 
1481
      --  Save indication of dynamic elaboration checks for ALI file
1482
 
1483
      Set_Dynamic_Elab (Current_Sem_Unit, Dynamic_Elaboration_Checks);
1484
 
1485
      --  Restore settings of saved switches to entry values
1486
 
1487
      Current_Sem_Unit     := S_Current_Sem_Unit;
1488
      Full_Analysis        := S_Full_Analysis;
1489
      Global_Discard_Names := S_Global_Dis_Names;
1490
      GNAT_Mode            := S_GNAT_Mode;
1491
      In_Spec_Expression   := S_In_Spec_Expr;
1492
      Inside_A_Generic     := S_Inside_A_Generic;
1493
      New_Nodes_OK         := S_New_Nodes_OK;
1494
      Outer_Generic_Scope  := S_Outer_Gen_Scope;
1495
 
1496
      Restore_Opt_Config_Switches (Save_Config_Switches);
1497
      Expander_Mode_Restore;
1498
 
1499
      if Debug_Unit_Walk then
1500
         Outdent;
1501
 
1502
         if Already_Analyzed then
1503
            Write_Str ("(done)");
1504
         end if;
1505
 
1506
         Write_Unit_Info
1507
           (Get_Cunit_Unit_Number (Comp_Unit),
1508
            Unit (Comp_Unit),
1509
            Prefix => "<-- ");
1510
      end if;
1511
   end Semantics;
1512
 
1513
   ------------------------
1514
   -- Walk_Library_Items --
1515
   ------------------------
1516
 
1517
   procedure Walk_Library_Items is
1518
      type Unit_Number_Set is array (Main_Unit .. Last_Unit) of Boolean;
1519
      pragma Pack (Unit_Number_Set);
1520
      Seen, Done : Unit_Number_Set := (others => False);
1521
      --  Seen (X) is True after we have seen unit X in the walk. This is used
1522
      --  to prevent processing the same unit more than once. Done (X) is True
1523
      --  after we have fully processed X, and is used only for debugging
1524
      --  printouts and assertions.
1525
 
1526
      Do_Main : Boolean := False;
1527
      --  Flag to delay processing the main body until after all other units.
1528
      --  This is needed because the spec of the main unit may appear in the
1529
      --  context of some other unit. We do not want this to force processing
1530
      --  of the main body before all other units have been processed.
1531
 
1532
      procedure Do_Action (CU : Node_Id; Item : Node_Id);
1533
      --  Calls Action, with some validity checks
1534
 
1535
      procedure Do_Unit_And_Dependents (CU : Node_Id; Item : Node_Id);
1536
      --  Calls Do_Action, first on the units with'ed by this one, then on
1537
      --  this unit. If it's an instance body, do the spec first. If it is
1538
      --  an instance spec, do the body last.
1539
 
1540
      ---------------
1541
      -- Do_Action --
1542
      ---------------
1543
 
1544
      procedure Do_Action (CU : Node_Id; Item : Node_Id) is
1545
      begin
1546
         --  This calls Action at the end. All the preceding code is just
1547
         --  assertions and debugging output.
1548
 
1549
         pragma Assert (No (CU) or else Nkind (CU) = N_Compilation_Unit);
1550
 
1551
         case Nkind (Item) is
1552
            when N_Generic_Subprogram_Declaration        |
1553
                 N_Generic_Package_Declaration           |
1554
                 N_Package_Declaration                   |
1555
                 N_Subprogram_Declaration                |
1556
                 N_Subprogram_Renaming_Declaration       |
1557
                 N_Package_Renaming_Declaration          |
1558
                 N_Generic_Function_Renaming_Declaration |
1559
                 N_Generic_Package_Renaming_Declaration  |
1560
                 N_Generic_Procedure_Renaming_Declaration =>
1561
 
1562
               --  Specs are OK
1563
 
1564
               null;
1565
 
1566
            when N_Package_Body  =>
1567
 
1568
               --  Package bodies are processed immediately after the
1569
               --  corresponding spec.
1570
 
1571
               null;
1572
 
1573
            when  N_Subprogram_Body =>
1574
 
1575
               --  A subprogram body must be the main unit
1576
 
1577
               pragma Assert (Acts_As_Spec (CU)
1578
                               or else CU = Cunit (Main_Unit));
1579
               null;
1580
 
1581
            --  All other cases cannot happen
1582
 
1583
            when N_Function_Instantiation  |
1584
                 N_Procedure_Instantiation |
1585
                 N_Package_Instantiation   =>
1586
               pragma Assert (False, "instantiation");
1587
               null;
1588
 
1589
            when N_Subunit =>
1590
               pragma Assert (False, "subunit");
1591
               null;
1592
 
1593
            when others =>
1594
               pragma Assert (False);
1595
               null;
1596
         end case;
1597
 
1598
         if Present (CU) then
1599
            pragma Assert (Item /= Stand.Standard_Package_Node);
1600
            pragma Assert (Item = Unit (CU));
1601
 
1602
            declare
1603
               Unit_Num : constant Unit_Number_Type :=
1604
                            Get_Cunit_Unit_Number (CU);
1605
 
1606
               procedure Assert_Done (Withed_Unit : Node_Id);
1607
               --  Assert Withed_Unit is already Done, unless it's a body. It
1608
               --  might seem strange for a with_clause to refer to a body, but
1609
               --  this happens in the case of a generic instantiation, which
1610
               --  gets transformed into the instance body (and the instance
1611
               --  spec is also created). With clauses pointing to the
1612
               --  instantiation end up pointing to the instance body.
1613
 
1614
               -----------------
1615
               -- Assert_Done --
1616
               -----------------
1617
 
1618
               procedure Assert_Done (Withed_Unit : Node_Id) is
1619
               begin
1620
                  if not Done (Get_Cunit_Unit_Number (Withed_Unit)) then
1621
                     if not Nkind_In
1622
                              (Unit (Withed_Unit),
1623
                                 N_Generic_Package_Declaration,
1624
                                 N_Package_Body,
1625
                                 N_Subprogram_Body)
1626
                     then
1627
                        Write_Unit_Name
1628
                          (Unit_Name (Get_Cunit_Unit_Number (Withed_Unit)));
1629
                        Write_Str (" not yet walked!");
1630
 
1631
                        if Get_Cunit_Unit_Number (Withed_Unit) = Unit_Num then
1632
                           Write_Str (" (self-ref)");
1633
                        end if;
1634
 
1635
                        Write_Eol;
1636
 
1637
                        pragma Assert (False);
1638
                     end if;
1639
                  end if;
1640
               end Assert_Done;
1641
 
1642
               procedure Assert_Withed_Units_Done is
1643
                 new Walk_Withs (Assert_Done);
1644
 
1645
            begin
1646
               if Debug_Unit_Walk then
1647
                  Write_Unit_Info (Unit_Num, Item, Withs => True);
1648
               end if;
1649
 
1650
               --  Main unit should come last (except in the case where we
1651
               --  skipped System_Aux_Id, in which case we missed the things it
1652
               --  depends on).
1653
 
1654
               pragma Assert
1655
                 (not Done (Main_Unit) or else Present (System_Aux_Id));
1656
 
1657
               --  We shouldn't do the same thing twice
1658
 
1659
               pragma Assert (not Done (Unit_Num));
1660
 
1661
               --  Everything we depend upon should already be done
1662
 
1663
               pragma Debug
1664
                 (Assert_Withed_Units_Done (CU, Include_Limited => False));
1665
            end;
1666
 
1667
         else
1668
            --  Must be Standard, which has no entry in the units table
1669
 
1670
            pragma Assert (Item = Stand.Standard_Package_Node);
1671
 
1672
            if Debug_Unit_Walk then
1673
               Write_Line ("Standard");
1674
            end if;
1675
         end if;
1676
 
1677
         Action (Item);
1678
      end Do_Action;
1679
 
1680
      ----------------------------
1681
      -- Do_Unit_And_Dependents --
1682
      ----------------------------
1683
 
1684
      procedure Do_Unit_And_Dependents (CU : Node_Id; Item : Node_Id) is
1685
         Unit_Num : constant Unit_Number_Type :=
1686
                      Get_Cunit_Unit_Number (CU);
1687
 
1688
         procedure Do_Withed_Unit (Withed_Unit : Node_Id);
1689
         --  Pass the buck to Do_Unit_And_Dependents
1690
 
1691
         --------------------
1692
         -- Do_Withed_Unit --
1693
         --------------------
1694
 
1695
         procedure Do_Withed_Unit (Withed_Unit : Node_Id) is
1696
            Save_Do_Main : constant Boolean := Do_Main;
1697
 
1698
         begin
1699
            --  Do not process the main unit if coming from a with_clause,
1700
            --  as would happen with a parent body that has a child spec
1701
            --  in its context.
1702
 
1703
            Do_Main := False;
1704
            Do_Unit_And_Dependents (Withed_Unit, Unit (Withed_Unit));
1705
            Do_Main := Save_Do_Main;
1706
         end Do_Withed_Unit;
1707
 
1708
         procedure Do_Withed_Units is new Walk_Withs (Do_Withed_Unit);
1709
 
1710
      --  Start of processing for Do_Unit_And_Dependents
1711
 
1712
      begin
1713
         if not Seen (Unit_Num) then
1714
 
1715
            --  Process the with clauses
1716
 
1717
            Do_Withed_Units (CU, Include_Limited => False);
1718
 
1719
            --  Process the unit if it is a spec. If it is the main unit,
1720
            --  process it only if we have done all other units.
1721
 
1722
            if not Nkind_In (Item, N_Package_Body, N_Subprogram_Body)
1723
              or else Acts_As_Spec (CU)
1724
            then
1725
               if CU = Cunit (Main_Unit) and then not Do_Main then
1726
                  Seen (Unit_Num) := False;
1727
 
1728
               else
1729
                  Seen (Unit_Num) := True;
1730
                  Do_Action (CU, Item);
1731
                  Done (Unit_Num) := True;
1732
               end if;
1733
            end if;
1734
         end if;
1735
 
1736
         --  Process bodies. The spec, if present, has been processed already.
1737
         --  A body appears if it is the main, or the body of a spec that is
1738
         --  in the context of the main unit, and that is instantiated, or else
1739
         --  contains a generic that is instantiated, or a subprogram that is
1740
         --  or a subprogram that is inlined in the main unit.
1741
 
1742
         --  We exclude bodies that may appear in a circular dependency list,
1743
         --  where spec A depends on spec B and body of B depends on spec A.
1744
         --  This is not an elaboration issue, but body B must be excluded
1745
         --  from the processing.
1746
 
1747
         declare
1748
            Body_Unit :  Node_Id := Empty;
1749
            Body_Num  : Unit_Number_Type;
1750
 
1751
            function Circular_Dependence (B : Node_Id) return Boolean;
1752
            --  Check whether this body depends on a spec that is pending,
1753
            --  that is to say has been seen but not processed yet.
1754
 
1755
            -------------------------
1756
            -- Circular_Dependence --
1757
            -------------------------
1758
 
1759
            function Circular_Dependence (B : Node_Id) return Boolean is
1760
               Item : Node_Id;
1761
               UN   : Unit_Number_Type;
1762
 
1763
            begin
1764
               Item := First (Context_Items (B));
1765
               while Present (Item) loop
1766
                  if Nkind (Item) = N_With_Clause then
1767
                     UN := Get_Cunit_Unit_Number (Library_Unit (Item));
1768
 
1769
                     if Seen (UN)
1770
                       and then not Done (UN)
1771
                     then
1772
                        return True;
1773
                     end if;
1774
                  end if;
1775
 
1776
                  Next (Item);
1777
               end loop;
1778
 
1779
               return False;
1780
            end Circular_Dependence;
1781
 
1782
         begin
1783
            if Nkind (Item) = N_Package_Declaration then
1784
               Body_Unit := Library_Unit (CU);
1785
 
1786
            elsif Nkind_In (Item, N_Package_Body, N_Subprogram_Body) then
1787
               Body_Unit := CU;
1788
            end if;
1789
 
1790
            if Present (Body_Unit)
1791
 
1792
              --  Since specs and bodies are not done at the same time,
1793
              --  guard against listing a body more than once. Bodies are
1794
              --  only processed when the main unit is being processed,
1795
              --  after all other units in the list. The DEC extension
1796
              --  to System is excluded because of circularities.
1797
 
1798
              and then not Seen (Get_Cunit_Unit_Number (Body_Unit))
1799
              and then
1800
                (No (System_Aux_Id)
1801
                   or else Unit_Num /= Get_Source_Unit (System_Aux_Id))
1802
              and then not Circular_Dependence (Body_Unit)
1803
              and then Do_Main
1804
            then
1805
               Body_Num := Get_Cunit_Unit_Number (Body_Unit);
1806
               Seen (Body_Num) := True;
1807
               Do_Action (Body_Unit, Unit (Body_Unit));
1808
               Done (Body_Num) := True;
1809
            end if;
1810
         end;
1811
      end Do_Unit_And_Dependents;
1812
 
1813
      --  Local Declarations
1814
 
1815
      Cur : Elmt_Id;
1816
 
1817
   --  Start of processing for Walk_Library_Items
1818
 
1819
   begin
1820
      if Debug_Unit_Walk then
1821
         Write_Line ("Walk_Library_Items:");
1822
         Indent;
1823
      end if;
1824
 
1825
      --  Do Standard first, then walk the Comp_Unit_List
1826
 
1827
      Do_Action (Empty, Standard_Package_Node);
1828
 
1829
      --  First place the context of all instance bodies on the corresponding
1830
      --  spec, because it may be needed to analyze the code at the place of
1831
      --  the instantiation.
1832
 
1833
      Cur := First_Elmt (Comp_Unit_List);
1834
      while Present (Cur) loop
1835
         declare
1836
            CU : constant Node_Id := Node (Cur);
1837
            N  : constant Node_Id := Unit (CU);
1838
 
1839
         begin
1840
            if Nkind (N) = N_Package_Body
1841
              and then Is_Generic_Instance (Defining_Entity (N))
1842
            then
1843
               Append_List
1844
                 (Context_Items (CU), Context_Items (Library_Unit (CU)));
1845
            end if;
1846
 
1847
            Next_Elmt (Cur);
1848
         end;
1849
      end loop;
1850
 
1851
      --  Now traverse compilation units in order
1852
 
1853
      Cur := First_Elmt (Comp_Unit_List);
1854
      while Present (Cur) loop
1855
         declare
1856
            CU : constant Node_Id := Node (Cur);
1857
            N  : constant Node_Id := Unit (CU);
1858
 
1859
         begin
1860
            pragma Assert (Nkind (CU) = N_Compilation_Unit);
1861
 
1862
            case Nkind (N) is
1863
 
1864
               --  If it's a body, ignore it. Bodies appear in the list only
1865
               --  because of inlining/instantiations, and they are processed
1866
               --  immediately after the corresponding specs. The main unit is
1867
               --  processed separately after all other units.
1868
 
1869
               when N_Package_Body | N_Subprogram_Body =>
1870
                  null;
1871
 
1872
               --  It's a spec, so just do it
1873
 
1874
               when others =>
1875
                  Do_Unit_And_Dependents (CU, N);
1876
            end case;
1877
         end;
1878
 
1879
         Next_Elmt (Cur);
1880
      end loop;
1881
 
1882
      if not Done (Main_Unit) then
1883
         Do_Main := True;
1884
 
1885
         declare
1886
            Main_CU : constant Node_Id := Cunit (Main_Unit);
1887
 
1888
         begin
1889
            --  If the main unit is an instantiation, the body appears before
1890
            --  the instance spec, which is added later to the unit list. Do
1891
            --  the spec if present, body will follow.
1892
 
1893
            if Nkind (Original_Node (Unit (Main_CU)))
1894
                 in N_Generic_Instantiation
1895
              and then Present (Library_Unit (Main_CU))
1896
            then
1897
               Do_Unit_And_Dependents
1898
                 (Library_Unit (Main_CU), Unit (Library_Unit (Main_CU)));
1899
            else
1900
               Do_Unit_And_Dependents (Main_CU, Unit (Main_CU));
1901
            end if;
1902
         end;
1903
      end if;
1904
 
1905
      if Debug_Unit_Walk then
1906
         if Done /= (Done'Range => True) then
1907
            Write_Eol;
1908
            Write_Line ("Ignored units:");
1909
 
1910
            Indent;
1911
 
1912
            for Unit_Num in Done'Range loop
1913
               if not Done (Unit_Num) then
1914
                  Write_Unit_Info
1915
                    (Unit_Num, Unit (Cunit (Unit_Num)), Withs => True);
1916
               end if;
1917
            end loop;
1918
 
1919
            Outdent;
1920
         end if;
1921
      end if;
1922
 
1923
      pragma Assert (Done (Main_Unit));
1924
 
1925
      if Debug_Unit_Walk then
1926
         Outdent;
1927
         Write_Line ("end Walk_Library_Items.");
1928
      end if;
1929
   end Walk_Library_Items;
1930
 
1931
   ----------------
1932
   -- Walk_Withs --
1933
   ----------------
1934
 
1935
   procedure Walk_Withs (CU : Node_Id; Include_Limited : Boolean) is
1936
      pragma Assert (Nkind (CU) = N_Compilation_Unit);
1937
      pragma Assert (Nkind (Unit (CU)) /= N_Subunit);
1938
 
1939
      procedure Walk_Immediate is new Walk_Withs_Immediate (Action);
1940
 
1941
   begin
1942
      --  First walk the withs immediately on the library item
1943
 
1944
      Walk_Immediate (CU, Include_Limited);
1945
 
1946
      --  For a body, we must also check for any subunits which belong to it
1947
      --  and which have context clauses of their own, since these with'ed
1948
      --  units are part of its own dependencies.
1949
 
1950
      if Nkind (Unit (CU)) in N_Unit_Body then
1951
         for S in Main_Unit .. Last_Unit loop
1952
 
1953
            --  We are only interested in subunits. For preproc. data and def.
1954
            --  files, Cunit is Empty, so we need to test that first.
1955
 
1956
            if Cunit (S) /= Empty
1957
              and then Nkind (Unit (Cunit (S))) = N_Subunit
1958
            then
1959
               declare
1960
                  Pnode : Node_Id;
1961
 
1962
               begin
1963
                  Pnode := Library_Unit (Cunit (S));
1964
 
1965
                  --  In -gnatc mode, the errors in the subunits will not have
1966
                  --  been recorded, but the analysis of the subunit may have
1967
                  --  failed, so just quit.
1968
 
1969
                  if No (Pnode) then
1970
                     exit;
1971
                  end if;
1972
 
1973
                  --  Find ultimate parent of the subunit
1974
 
1975
                  while Nkind (Unit (Pnode)) = N_Subunit loop
1976
                     Pnode := Library_Unit (Pnode);
1977
                  end loop;
1978
 
1979
                  --  See if it belongs to current unit, and if so, include its
1980
                  --  with_clauses. Do not process main unit prematurely.
1981
 
1982
                  if Pnode = CU and then CU /= Cunit (Main_Unit) then
1983
                     Walk_Immediate (Cunit (S), Include_Limited);
1984
                  end if;
1985
               end;
1986
            end if;
1987
         end loop;
1988
      end if;
1989
   end Walk_Withs;
1990
 
1991
   --------------------------
1992
   -- Walk_Withs_Immediate --
1993
   --------------------------
1994
 
1995
   procedure Walk_Withs_Immediate (CU : Node_Id; Include_Limited : Boolean) is
1996
      pragma Assert (Nkind (CU) = N_Compilation_Unit);
1997
 
1998
      Context_Item : Node_Id;
1999
 
2000
   begin
2001
      Context_Item := First (Context_Items (CU));
2002
      while Present (Context_Item) loop
2003
         if Nkind (Context_Item) = N_With_Clause
2004
           and then (Include_Limited
2005
                     or else not Limited_Present (Context_Item))
2006
         then
2007
            Action (Library_Unit (Context_Item));
2008
         end if;
2009
 
2010
         Context_Item := Next (Context_Item);
2011
      end loop;
2012
   end Walk_Withs_Immediate;
2013
 
2014
   ---------------------
2015
   -- Write_Unit_Info --
2016
   ---------------------
2017
 
2018
   procedure Write_Unit_Info
2019
     (Unit_Num : Unit_Number_Type;
2020
      Item     : Node_Id;
2021
      Prefix   : String := "";
2022
      Withs    : Boolean := False)
2023
   is
2024
   begin
2025
      Write_Str (Prefix);
2026
      Write_Unit_Name (Unit_Name (Unit_Num));
2027
      Write_Str (", unit ");
2028
      Write_Int (Int (Unit_Num));
2029
      Write_Str (", ");
2030
      Write_Int (Int (Item));
2031
      Write_Str ("=");
2032
      Write_Str (Node_Kind'Image (Nkind (Item)));
2033
 
2034
      if Item /= Original_Node (Item) then
2035
         Write_Str (", orig = ");
2036
         Write_Int (Int (Original_Node (Item)));
2037
         Write_Str ("=");
2038
         Write_Str (Node_Kind'Image (Nkind (Original_Node (Item))));
2039
      end if;
2040
 
2041
      Write_Eol;
2042
 
2043
      --  Skip the rest if we're not supposed to print the withs
2044
 
2045
      if not Withs then
2046
         return;
2047
      end if;
2048
 
2049
      declare
2050
         Context_Item : Node_Id;
2051
 
2052
      begin
2053
         Context_Item := First (Context_Items (Cunit (Unit_Num)));
2054
         while Present (Context_Item)
2055
           and then (Nkind (Context_Item) /= N_With_Clause
2056
                      or else Limited_Present (Context_Item))
2057
         loop
2058
            Context_Item := Next (Context_Item);
2059
         end loop;
2060
 
2061
         if Present (Context_Item) then
2062
            Indent;
2063
            Write_Line ("withs:");
2064
            Indent;
2065
 
2066
            while Present (Context_Item) loop
2067
               if Nkind (Context_Item) = N_With_Clause
2068
                 and then not Limited_Present (Context_Item)
2069
               then
2070
                  pragma Assert (Present (Library_Unit (Context_Item)));
2071
                  Write_Unit_Name
2072
                    (Unit_Name
2073
                       (Get_Cunit_Unit_Number (Library_Unit (Context_Item))));
2074
 
2075
                  if Implicit_With (Context_Item) then
2076
                     Write_Str (" -- implicit");
2077
                  end if;
2078
 
2079
                  Write_Eol;
2080
               end if;
2081
 
2082
               Context_Item := Next (Context_Item);
2083
            end loop;
2084
 
2085
            Outdent;
2086
            Write_Line ("end withs");
2087
            Outdent;
2088
         end if;
2089
      end;
2090
   end Write_Unit_Info;
2091
 
2092
end Sem;

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.