1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
------------------------------------------------------------------------------
-- --
-- GNAT COMPILER COMPONENTS --
-- --
-- F R O N T E N D --
-- --
-- B o d y --
-- --
-- $Revision: 1.38 $ --
-- --
-- Copyright (C) 1992-1997 Free Software Foundation, Inc. --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
-- ware Foundation; either version 2, or (at your option) any later ver- --
-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
-- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
-- for more details. You should have received a copy of the GNU General --
-- Public License distributed with GNAT; see file COPYING. If not, write --
-- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
-- MA 02111-1307, USA. --
-- --
-- GNAT was originally developed by the GNAT team at New York University. --
-- It is now maintained by Ada Core Technologies Inc (http://www.gnat.com). --
-- --
------------------------------------------------------------------------------
with Atree; use Atree;
with Debug; use Debug;
with Elists;
with Errout;
with Fname;
with Inline; use Inline;
with Lib; use Lib;
with Lib.Load; use Lib.Load;
with Namet; use Namet;
with Nlists; use Nlists;
with Opt; use Opt;
with Output; use Output;
with Par;
with Rtsfind;
with Sprint;
with Scn; use Scn;
with Sem; use Sem;
with Sem_Ch8; use Sem_Ch8;
with Sem_Elab; use Sem_Elab;
with Sem_Prag; use Sem_Prag;
with Sinfo; use Sinfo;
with Sinput; use Sinput;
with Sinput.L; use Sinput.L;
with CStand;
with Treepr;
with Types; use Types;
with Usage;
procedure Frontend is
begin
-- Carry out package initializations. These are initializations which
-- might logically be performed at elaboration time, were it not for
-- the fact that we may be doing things more than once in the big loop
-- over files. Like elaboration, the order in which these calls are
-- made is in some cases important. For example, Lib cannot be
-- initialized until Namet, since it uses names table entries.
Rtsfind.Initialize;
Atree.Initialize;
Nlists.Initialize;
Elists.Initialize;
Lib.Load.Initialize;
Sem_Ch8.Initialize;
Fname.Initialize;
-- Create package Standard
CStand.Create_Standard;
-- Read and process gnat.adc file if one is present
declare
Src_Ind : Source_File_Index;
Pragmas : List_Id;
Prag : Node_Id;
begin
Name_Buffer (1 .. 8) := "gnat.adc";
Name_Len := 8;
Src_Ind := Load_Source_File (Name_Enter);
if Src_Ind /= No_Source_File then
Initialize_Scanner (No_Unit, Src_Ind);
Pragmas := Par (Configuration_Pragmas => True);
if Pragmas /= Error_List then
Prag := First (Pragmas);
while Present (Prag) loop
Analyze_Pragma (Prag);
Prag := Next (Prag);
end loop;
end if;
end if;
end;
-- Initialize the scanner. Note that we do this after the call to
-- Create_Standard, which uses the scanner in its processing of
-- floating-point bounds.
Initialize_Scanner (Main_Unit, Source_Index (Main_Unit));
-- Output header if in verbose mode or full list mode
if Verbose_Mode or Full_List then
Write_Eol;
if Operating_Mode = Generate_Code then
Write_Str ("Compiling: ");
else
Write_Str ("Checking: ");
end if;
Write_Name (Full_File_Name (Current_Source_File));
if not Debug_Flag_7 then
Write_Str (" (source file time stamp: ");
Write_Time_Stamp (Current_Source_File);
Write_Char (')');
end if;
Write_Eol;
end if;
-- Here we call the parser to parse the compilation unit (or units in
-- the check syntax mode, but in that case we won't go on to the
-- semantics in any case).
declare
Discard : List_Id;
begin
Discard := Par (Configuration_Pragmas => False);
end;
-- The main unit is now loaded, and subunits of it can be loaded,
-- without reporting spurious loading circularities.
Set_Loading (Main_Unit, False);
-- Now on to the semantics. We skip the semantics if we are in syntax
-- only mode, or if we encountered a fatal error during the parsing.
if Operating_Mode /= Check_Syntax
and then not Fatal_Error (Main_Unit)
then
-- Reset Operating_Mode to Check_Semantics for subunits. We cannot
-- actually generate code for subunits, so we suppress expansion.
-- This also corrects certain problems that occur if we try to
-- incorporate subunits at a lower level.
if Operating_Mode = Generate_Code
and then Nkind (Unit (Cunit (Main_Unit))) = N_Subunit
then
Operating_Mode := Check_Semantics;
end if;
-- Analyze (and possibly expand) main unit
Scope_Suppress := Suppress_Options;
Semantics (Cunit (Main_Unit));
-- Cleanup processing after completing main analysis
Instantiate_Bodies;
if Inline_Active or else Inline_All then
Analyze_Inlined_Bodies;
end if;
Check_Elab_Calls;
if List_Units then
Lib.List;
end if;
end if;
Treepr.Tree_Dump;
Sprint.Source_Dump;
end Frontend;
|
