|
111
|
1 ------------------------------------------------------------------------------
|
|
|
2 -- --
|
|
|
3 -- GNAT COMPILER COMPONENTS --
|
|
|
4 -- --
|
|
|
5 -- P R E P C O M P --
|
|
|
6 -- --
|
|
|
7 -- B o d y --
|
|
|
8 -- --
|
|
131
|
9 -- Copyright (C) 2003-2018, Free Software Foundation, Inc. --
|
|
111
|
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. See the GNU General Public License --
|
|
|
17 -- for more details. You should have received a copy of the GNU General --
|
|
|
18 -- Public License distributed with GNAT; see file COPYING3. If not, go to --
|
|
|
19 -- http://www.gnu.org/licenses for a complete copy of the license. --
|
|
|
20 -- --
|
|
|
21 -- GNAT was originally developed by the GNAT team at New York University. --
|
|
|
22 -- Extensive contributions were provided by Ada Core Technologies Inc. --
|
|
|
23 -- --
|
|
|
24 ------------------------------------------------------------------------------
|
|
|
25
|
|
|
26 with Atree; use Atree;
|
|
|
27 with Errout; use Errout;
|
|
|
28 with Lib.Writ; use Lib.Writ;
|
|
|
29 with Opt; use Opt;
|
|
|
30 with Osint; use Osint;
|
|
|
31 with Prep; use Prep;
|
|
|
32 with Scans; use Scans;
|
|
|
33 with Scn; use Scn;
|
|
|
34 with Sinput.L; use Sinput.L;
|
|
|
35 with Stringt; use Stringt;
|
|
|
36 with Table;
|
|
|
37
|
|
|
38 package body Prepcomp is
|
|
|
39
|
|
|
40 No_Preprocessing : Boolean := True;
|
|
|
41 -- Set to False if there is at least one source that needs to be
|
|
|
42 -- preprocessed.
|
|
|
43
|
|
|
44 Source_Index_Of_Preproc_Data_File : Source_File_Index := No_Source_File;
|
|
|
45
|
|
|
46 -- The following variable should be a constant, but this is not possible
|
|
|
47 -- because its type GNAT.Dynamic_Tables.Instance has a component P of
|
|
|
48 -- uninitialized private type GNAT.Dynamic_Tables.Table_Private and there
|
|
|
49 -- are no exported values for this private type. Warnings are Off because
|
|
|
50 -- it is never assigned a value.
|
|
|
51
|
|
|
52 pragma Warnings (Off);
|
|
|
53 No_Mapping : Prep.Symbol_Table.Instance;
|
|
|
54 pragma Warnings (On);
|
|
|
55
|
|
|
56 type Preproc_Data is record
|
|
|
57 Mapping : Symbol_Table.Instance;
|
|
|
58 File_Name : File_Name_Type := No_File;
|
|
|
59 Deffile : String_Id := No_String;
|
|
|
60 Undef_False : Boolean := False;
|
|
|
61 Always_Blank : Boolean := False;
|
|
|
62 Comments : Boolean := False;
|
|
|
63 No_Deletion : Boolean := False;
|
|
|
64 List_Symbols : Boolean := False;
|
|
|
65 Processed : Boolean := False;
|
|
|
66 end record;
|
|
|
67 -- Structure to keep the preprocessing data for a file name or for the
|
|
|
68 -- default (when Name_Id = No_Name).
|
|
|
69
|
|
|
70 No_Preproc_Data : constant Preproc_Data :=
|
|
|
71 (Mapping => No_Mapping,
|
|
|
72 File_Name => No_File,
|
|
|
73 Deffile => No_String,
|
|
|
74 Undef_False => False,
|
|
|
75 Always_Blank => False,
|
|
|
76 Comments => False,
|
|
|
77 No_Deletion => False,
|
|
|
78 List_Symbols => False,
|
|
|
79 Processed => False);
|
|
|
80
|
|
|
81 Default_Data : Preproc_Data := No_Preproc_Data;
|
|
|
82 -- The preprocessing data to be used when no specific preprocessing data
|
|
|
83 -- is specified for a source.
|
|
|
84
|
|
|
85 Default_Data_Defined : Boolean := False;
|
|
|
86 -- True if source for which no specific preprocessing is specified need to
|
|
|
87 -- be preprocess with the Default_Data.
|
|
|
88
|
|
|
89 Current_Data : Preproc_Data := No_Preproc_Data;
|
|
|
90
|
|
|
91 package Preproc_Data_Table is new Table.Table
|
|
|
92 (Table_Component_Type => Preproc_Data,
|
|
|
93 Table_Index_Type => Int,
|
|
|
94 Table_Low_Bound => 1,
|
|
|
95 Table_Initial => 5,
|
|
|
96 Table_Increment => 100,
|
|
|
97 Table_Name => "Prepcomp.Preproc_Data_Table");
|
|
|
98 -- Table to store the specific preprocessing data
|
|
|
99
|
|
|
100 Command_Line_Symbols : Symbol_Table.Instance;
|
|
|
101 -- A table to store symbol definitions specified on the command line with
|
|
|
102 -- -gnateD switches.
|
|
|
103
|
|
|
104 package Dependencies is new Table.Table
|
|
|
105 (Table_Component_Type => Source_File_Index,
|
|
|
106 Table_Index_Type => Int,
|
|
|
107 Table_Low_Bound => 1,
|
|
|
108 Table_Initial => 10,
|
|
|
109 Table_Increment => 100,
|
|
|
110 Table_Name => "Prepcomp.Dependencies");
|
|
|
111 -- Table to store the dependencies on preprocessing files
|
|
|
112
|
|
|
113 procedure Add_Command_Line_Symbols;
|
|
|
114 -- Add the command line symbol definitions, if any, to Prep.Mapping table
|
|
|
115
|
|
|
116 procedure Skip_To_End_Of_Line;
|
|
|
117 -- Ignore errors and scan up to the next end of line or the end of file
|
|
|
118
|
|
|
119 ------------------------------
|
|
|
120 -- Add_Command_Line_Symbols --
|
|
|
121 ------------------------------
|
|
|
122
|
|
|
123 procedure Add_Command_Line_Symbols is
|
|
|
124 Symbol_Id : Prep.Symbol_Id;
|
|
|
125
|
|
|
126 begin
|
|
|
127 for J in 1 .. Symbol_Table.Last (Command_Line_Symbols) loop
|
|
|
128 Symbol_Id := Prep.Index_Of (Command_Line_Symbols.Table (J).Symbol);
|
|
|
129
|
|
|
130 if Symbol_Id = No_Symbol then
|
|
|
131 Symbol_Table.Increment_Last (Prep.Mapping);
|
|
|
132 Symbol_Id := Symbol_Table.Last (Prep.Mapping);
|
|
|
133 end if;
|
|
|
134
|
|
|
135 Prep.Mapping.Table (Symbol_Id) := Command_Line_Symbols.Table (J);
|
|
|
136 end loop;
|
|
|
137 end Add_Command_Line_Symbols;
|
|
|
138
|
|
|
139 --------------------
|
|
|
140 -- Add_Dependency --
|
|
|
141 --------------------
|
|
|
142
|
|
|
143 procedure Add_Dependency (S : Source_File_Index) is
|
|
|
144 begin
|
|
|
145 Dependencies.Increment_Last;
|
|
|
146 Dependencies.Table (Dependencies.Last) := S;
|
|
|
147 end Add_Dependency;
|
|
|
148
|
|
|
149 ----------------------
|
|
|
150 -- Add_Dependencies --
|
|
|
151 ----------------------
|
|
|
152
|
|
|
153 procedure Add_Dependencies is
|
|
|
154 begin
|
|
|
155 for Index in 1 .. Dependencies.Last loop
|
|
|
156 Add_Preprocessing_Dependency (Dependencies.Table (Index));
|
|
|
157 end loop;
|
|
|
158 end Add_Dependencies;
|
|
|
159
|
|
|
160 -------------------
|
|
|
161 -- Check_Symbols --
|
|
|
162 -------------------
|
|
|
163
|
|
|
164 procedure Check_Symbols is
|
|
|
165 begin
|
|
|
166 -- If there is at least one switch -gnateD specified
|
|
|
167
|
|
|
168 if Symbol_Table.Last (Command_Line_Symbols) >= 1 then
|
|
|
169 Current_Data := No_Preproc_Data;
|
|
|
170 No_Preprocessing := False;
|
|
|
171 Current_Data.Processed := True;
|
|
|
172
|
|
|
173 -- Start with an empty, initialized mapping table; use Prep.Mapping,
|
|
|
174 -- because Prep.Index_Of uses Prep.Mapping.
|
|
|
175
|
|
|
176 Prep.Mapping := No_Mapping;
|
|
|
177 Symbol_Table.Init (Prep.Mapping);
|
|
|
178
|
|
|
179 -- Add the command line symbols
|
|
|
180
|
|
|
181 Add_Command_Line_Symbols;
|
|
|
182
|
|
|
183 -- Put the resulting Prep.Mapping in Current_Data, and immediately
|
|
|
184 -- set Prep.Mapping to nil.
|
|
|
185
|
|
|
186 Current_Data.Mapping := Prep.Mapping;
|
|
|
187 Prep.Mapping := No_Mapping;
|
|
|
188
|
|
|
189 -- Set the default data
|
|
|
190
|
|
|
191 Default_Data := Current_Data;
|
|
|
192 Default_Data_Defined := True;
|
|
|
193 end if;
|
|
|
194 end Check_Symbols;
|
|
|
195
|
|
131
|
196 -----------------------------------
|
|
|
197 -- Parse_Preprocessing_Data_File --
|
|
|
198 -----------------------------------
|
|
111
|
199
|
|
|
200 procedure Parse_Preprocessing_Data_File (N : File_Name_Type) is
|
|
|
201 OK : Boolean := False;
|
|
|
202 Dash_Location : Source_Ptr;
|
|
|
203 Symbol_Data : Prep.Symbol_Data;
|
|
|
204 Symbol_Id : Prep.Symbol_Id;
|
|
|
205 T : constant Nat := Total_Errors_Detected;
|
|
|
206
|
|
|
207 begin
|
|
|
208 -- Load the preprocessing data file
|
|
|
209
|
|
|
210 Source_Index_Of_Preproc_Data_File := Load_Preprocessing_Data_File (N);
|
|
|
211
|
|
|
212 -- Fail if preprocessing data file cannot be found
|
|
|
213
|
|
|
214 if Source_Index_Of_Preproc_Data_File = No_Source_File then
|
|
|
215 Get_Name_String (N);
|
|
|
216 Fail ("preprocessing data file """
|
|
|
217 & Name_Buffer (1 .. Name_Len)
|
|
|
218 & """ not found");
|
|
|
219 end if;
|
|
|
220
|
|
|
221 -- Initialize scanner and set its behavior for processing a data file
|
|
|
222
|
|
|
223 Scn.Scanner.Initialize_Scanner (Source_Index_Of_Preproc_Data_File);
|
|
|
224 Scn.Scanner.Set_End_Of_Line_As_Token (True);
|
|
|
225 Scn.Scanner.Reset_Special_Characters;
|
|
|
226
|
|
|
227 For_Each_Line : loop
|
|
|
228 <<Scan_Line>>
|
|
|
229 Scan;
|
|
|
230
|
|
|
231 exit For_Each_Line when Token = Tok_EOF;
|
|
|
232
|
|
|
233 if Token = Tok_End_Of_Line then
|
|
|
234 goto Scan_Line;
|
|
|
235 end if;
|
|
|
236
|
|
|
237 -- Line is not empty
|
|
|
238
|
|
|
239 OK := False;
|
|
|
240 No_Preprocessing := False;
|
|
|
241 Current_Data := No_Preproc_Data;
|
|
|
242
|
|
|
243 case Token is
|
|
|
244 when Tok_Asterisk =>
|
|
|
245
|
|
|
246 -- Default data
|
|
|
247
|
|
|
248 if Default_Data_Defined then
|
|
|
249 Error_Msg
|
|
|
250 ("multiple default preprocessing data", Token_Ptr);
|
|
|
251
|
|
|
252 else
|
|
|
253 OK := True;
|
|
|
254 Default_Data_Defined := True;
|
|
|
255 end if;
|
|
|
256
|
|
|
257 when Tok_String_Literal =>
|
|
|
258
|
|
|
259 -- Specific data
|
|
|
260
|
|
|
261 String_To_Name_Buffer (String_Literal_Id);
|
|
|
262 Canonical_Case_File_Name (Name_Buffer (1 .. Name_Len));
|
|
|
263 Current_Data.File_Name := Name_Find;
|
|
|
264 OK := True;
|
|
|
265
|
|
|
266 for Index in 1 .. Preproc_Data_Table.Last loop
|
|
|
267 if Current_Data.File_Name =
|
|
|
268 Preproc_Data_Table.Table (Index).File_Name
|
|
|
269 then
|
|
|
270 Error_Msg_File_1 := Current_Data.File_Name;
|
|
|
271 Error_Msg
|
|
|
272 ("multiple preprocessing data for{", Token_Ptr);
|
|
|
273 OK := False;
|
|
|
274 exit;
|
|
|
275 end if;
|
|
|
276 end loop;
|
|
|
277
|
|
|
278 when others =>
|
|
|
279 Error_Msg ("`'*` or literal string expected", Token_Ptr);
|
|
|
280 end case;
|
|
|
281
|
|
|
282 -- If there is a problem, skip the line
|
|
|
283
|
|
|
284 if not OK then
|
|
|
285 Skip_To_End_Of_Line;
|
|
|
286 goto Scan_Line;
|
|
|
287 end if;
|
|
|
288
|
|
|
289 -- Scan past the * or the literal string
|
|
|
290
|
|
|
291 Scan;
|
|
|
292
|
|
|
293 -- A literal string in second position is a definition file
|
|
|
294
|
|
|
295 if Token = Tok_String_Literal then
|
|
|
296 Current_Data.Deffile := String_Literal_Id;
|
|
|
297 Current_Data.Processed := False;
|
|
|
298 Scan;
|
|
|
299
|
|
|
300 else
|
|
|
301 -- If there is no definition file, set Processed to True now
|
|
|
302
|
|
|
303 Current_Data.Processed := True;
|
|
|
304 end if;
|
|
|
305
|
|
|
306 -- Start with an empty, initialized mapping table; use Prep.Mapping,
|
|
|
307 -- because Prep.Index_Of uses Prep.Mapping.
|
|
|
308
|
|
|
309 Prep.Mapping := No_Mapping;
|
|
|
310 Symbol_Table.Init (Prep.Mapping);
|
|
|
311
|
|
|
312 -- Check the switches that may follow
|
|
|
313
|
|
|
314 while Token /= Tok_End_Of_Line and then Token /= Tok_EOF loop
|
|
|
315 if Token /= Tok_Minus then
|
|
|
316 Error_Msg -- CODEFIX
|
|
|
317 ("`'-` expected", Token_Ptr);
|
|
|
318 Skip_To_End_Of_Line;
|
|
|
319 goto Scan_Line;
|
|
|
320 end if;
|
|
|
321
|
|
|
322 -- Keep the location of the '-' for possible error reporting
|
|
|
323
|
|
|
324 Dash_Location := Token_Ptr;
|
|
|
325
|
|
|
326 -- Scan past the '-'
|
|
|
327
|
|
|
328 Scan;
|
|
|
329 OK := False;
|
|
|
330 Change_Reserved_Keyword_To_Symbol;
|
|
|
331
|
|
|
332 -- An identifier (or a reserved word converted to an
|
|
|
333 -- identifier) is expected and there must be no blank space
|
|
|
334 -- between the '-' and the identifier.
|
|
|
335
|
|
|
336 if Token = Tok_Identifier
|
|
|
337 and then Token_Ptr = Dash_Location + 1
|
|
|
338 then
|
|
|
339 Get_Name_String (Token_Name);
|
|
|
340
|
|
|
341 -- Check the character in the source, because the case is
|
|
|
342 -- significant.
|
|
|
343
|
|
|
344 case Sinput.Source (Token_Ptr) is
|
|
|
345 when 'a' =>
|
|
|
346
|
|
|
347 -- All source text preserved (also implies -u)
|
|
|
348
|
|
|
349 if Name_Len = 1 then
|
|
|
350 Current_Data.No_Deletion := True;
|
|
|
351 Current_Data.Undef_False := True;
|
|
|
352 OK := True;
|
|
|
353 end if;
|
|
|
354
|
|
|
355 when 'u' =>
|
|
|
356
|
|
|
357 -- Undefined symbol are False
|
|
|
358
|
|
|
359 if Name_Len = 1 then
|
|
|
360 Current_Data.Undef_False := True;
|
|
|
361 OK := True;
|
|
|
362 end if;
|
|
|
363
|
|
|
364 when 'b' =>
|
|
|
365
|
|
|
366 -- Blank lines
|
|
|
367
|
|
|
368 if Name_Len = 1 then
|
|
|
369 Current_Data.Always_Blank := True;
|
|
|
370 OK := True;
|
|
|
371 end if;
|
|
|
372
|
|
|
373 when 'c' =>
|
|
|
374
|
|
|
375 -- Comment removed lines
|
|
|
376
|
|
|
377 if Name_Len = 1 then
|
|
|
378 Current_Data.Comments := True;
|
|
|
379 OK := True;
|
|
|
380 end if;
|
|
|
381
|
|
|
382 when 's' =>
|
|
|
383
|
|
|
384 -- List symbols
|
|
|
385
|
|
|
386 if Name_Len = 1 then
|
|
|
387 Current_Data.List_Symbols := True;
|
|
|
388 OK := True;
|
|
|
389 end if;
|
|
|
390
|
|
|
391 when 'D' =>
|
|
|
392
|
|
|
393 -- Symbol definition
|
|
|
394
|
|
|
395 OK := Name_Len > 1;
|
|
|
396
|
|
|
397 if OK then
|
|
|
398
|
|
|
399 -- A symbol must be an Ada identifier; it cannot start
|
|
|
400 -- with an underline or a digit.
|
|
|
401
|
|
|
402 if Name_Buffer (2) = '_'
|
|
|
403 or else Name_Buffer (2) in '0' .. '9'
|
|
|
404 then
|
|
|
405 Error_Msg ("symbol expected", Token_Ptr + 1);
|
|
|
406 Skip_To_End_Of_Line;
|
|
|
407 goto Scan_Line;
|
|
|
408 end if;
|
|
|
409
|
|
|
410 -- Get the name id of the symbol
|
|
|
411
|
|
|
412 Symbol_Data.On_The_Command_Line := True;
|
|
|
413 Name_Buffer (1 .. Name_Len - 1) :=
|
|
|
414 Name_Buffer (2 .. Name_Len);
|
|
|
415 Name_Len := Name_Len - 1;
|
|
|
416 Symbol_Data.Symbol := Name_Find;
|
|
|
417
|
|
|
418 if Name_Buffer (1 .. Name_Len) = "if"
|
|
|
419 or else Name_Buffer (1 .. Name_Len) = "else"
|
|
|
420 or else Name_Buffer (1 .. Name_Len) = "elsif"
|
|
|
421 or else Name_Buffer (1 .. Name_Len) = "end"
|
|
|
422 or else Name_Buffer (1 .. Name_Len) = "not"
|
|
|
423 or else Name_Buffer (1 .. Name_Len) = "and"
|
|
|
424 or else Name_Buffer (1 .. Name_Len) = "then"
|
|
|
425 then
|
|
|
426 Error_Msg ("symbol expected", Token_Ptr + 1);
|
|
|
427 Skip_To_End_Of_Line;
|
|
|
428 goto Scan_Line;
|
|
|
429 end if;
|
|
|
430
|
|
|
431 -- Get the name id of the original symbol, with
|
|
|
432 -- possibly capital letters.
|
|
|
433
|
|
|
434 Name_Len := Integer (Scan_Ptr - Token_Ptr - 1);
|
|
|
435
|
|
|
436 for J in 1 .. Name_Len loop
|
|
|
437 Name_Buffer (J) :=
|
|
|
438 Sinput.Source (Token_Ptr + Text_Ptr (J));
|
|
|
439 end loop;
|
|
|
440
|
|
|
441 Symbol_Data.Original := Name_Find;
|
|
|
442
|
|
|
443 -- Scan past D<symbol>
|
|
|
444
|
|
|
445 Scan;
|
|
|
446
|
|
|
447 if Token /= Tok_Equal then
|
|
|
448 Error_Msg -- CODEFIX
|
|
|
449 ("`=` expected", Token_Ptr);
|
|
|
450 Skip_To_End_Of_Line;
|
|
|
451 goto Scan_Line;
|
|
|
452 end if;
|
|
|
453
|
|
|
454 -- Scan past '='
|
|
|
455
|
|
|
456 Scan;
|
|
|
457
|
|
|
458 -- Here any reserved word is OK
|
|
|
459
|
|
|
460 Change_Reserved_Keyword_To_Symbol
|
|
|
461 (All_Keywords => True);
|
|
|
462
|
|
|
463 -- Value can be an identifier (or a reserved word)
|
|
|
464 -- or a literal string.
|
|
|
465
|
|
|
466 case Token is
|
|
|
467 when Tok_String_Literal =>
|
|
|
468 Symbol_Data.Is_A_String := True;
|
|
|
469 Symbol_Data.Value := String_Literal_Id;
|
|
|
470
|
|
|
471 when Tok_Identifier =>
|
|
|
472 Symbol_Data.Is_A_String := False;
|
|
|
473 Start_String;
|
|
|
474
|
|
|
475 for J in Token_Ptr .. Scan_Ptr - 1 loop
|
|
|
476 Store_String_Char (Sinput.Source (J));
|
|
|
477 end loop;
|
|
|
478
|
|
|
479 Symbol_Data.Value := End_String;
|
|
|
480
|
|
|
481 when others =>
|
|
|
482 Error_Msg
|
|
|
483 ("literal string or identifier expected",
|
|
|
484 Token_Ptr);
|
|
|
485 Skip_To_End_Of_Line;
|
|
|
486 goto Scan_Line;
|
|
|
487 end case;
|
|
|
488
|
|
|
489 -- If symbol already exists, replace old definition
|
|
|
490 -- by new one.
|
|
|
491
|
|
|
492 Symbol_Id := Prep.Index_Of (Symbol_Data.Symbol);
|
|
|
493
|
|
|
494 -- Otherwise, add a new entry in the table
|
|
|
495
|
|
|
496 if Symbol_Id = No_Symbol then
|
|
|
497 Symbol_Table.Increment_Last (Prep.Mapping);
|
|
|
498 Symbol_Id := Symbol_Table.Last (Mapping);
|
|
|
499 end if;
|
|
|
500
|
|
|
501 Prep.Mapping.Table (Symbol_Id) := Symbol_Data;
|
|
|
502 end if;
|
|
|
503
|
|
|
504 when others =>
|
|
|
505 null;
|
|
|
506 end case;
|
|
|
507
|
|
|
508 Scan;
|
|
|
509 end if;
|
|
|
510
|
|
|
511 if not OK then
|
|
|
512 Error_Msg ("invalid switch", Dash_Location);
|
|
|
513 Skip_To_End_Of_Line;
|
|
|
514 goto Scan_Line;
|
|
|
515 end if;
|
|
|
516 end loop;
|
|
|
517
|
|
|
518 -- Add the command line symbols, if any, possibly replacing symbols
|
|
|
519 -- just defined.
|
|
|
520
|
|
|
521 Add_Command_Line_Symbols;
|
|
|
522
|
|
|
523 -- Put the resulting Prep.Mapping in Current_Data, and immediately
|
|
|
524 -- set Prep.Mapping to nil.
|
|
|
525
|
|
|
526 Current_Data.Mapping := Prep.Mapping;
|
|
|
527 Prep.Mapping := No_Mapping;
|
|
|
528
|
|
|
529 -- Record Current_Data
|
|
|
530
|
|
|
531 if Current_Data.File_Name = No_File then
|
|
|
532 Default_Data := Current_Data;
|
|
|
533
|
|
|
534 else
|
|
|
535 Preproc_Data_Table.Increment_Last;
|
|
|
536 Preproc_Data_Table.Table (Preproc_Data_Table.Last) := Current_Data;
|
|
|
537 end if;
|
|
|
538
|
|
|
539 Current_Data := No_Preproc_Data;
|
|
|
540 end loop For_Each_Line;
|
|
|
541
|
|
|
542 Scn.Scanner.Set_End_Of_Line_As_Token (False);
|
|
|
543
|
|
|
544 -- Fail if there were errors in the preprocessing data file
|
|
|
545
|
|
|
546 if Total_Errors_Detected > T then
|
|
|
547 Errout.Finalize (Last_Call => True);
|
|
|
548 Errout.Output_Messages;
|
|
|
549 Fail ("errors found in preprocessing data file """
|
|
|
550 & Get_Name_String (N) & """");
|
|
|
551 end if;
|
|
|
552
|
|
|
553 -- Record the dependency on the preprocessor data file
|
|
|
554
|
|
|
555 Add_Dependency (Source_Index_Of_Preproc_Data_File);
|
|
|
556 end Parse_Preprocessing_Data_File;
|
|
|
557
|
|
|
558 ---------------------------
|
|
|
559 -- Prepare_To_Preprocess --
|
|
|
560 ---------------------------
|
|
|
561
|
|
|
562 procedure Prepare_To_Preprocess
|
|
|
563 (Source : File_Name_Type;
|
|
|
564 Preprocessing_Needed : out Boolean)
|
|
|
565 is
|
|
|
566 Default : Boolean := False;
|
|
|
567 Index : Int := 0;
|
|
|
568
|
|
|
569 begin
|
|
|
570 -- By default, preprocessing is not needed
|
|
|
571
|
|
|
572 Preprocessing_Needed := False;
|
|
|
573
|
|
|
574 if No_Preprocessing then
|
|
|
575 return;
|
|
|
576 end if;
|
|
|
577
|
|
|
578 -- First, look for preprocessing data specific to the current source
|
|
|
579
|
|
|
580 for J in 1 .. Preproc_Data_Table.Last loop
|
|
|
581 if Preproc_Data_Table.Table (J).File_Name = Source then
|
|
|
582 Index := J;
|
|
|
583 Current_Data := Preproc_Data_Table.Table (J);
|
|
|
584 exit;
|
|
|
585 end if;
|
|
|
586 end loop;
|
|
|
587
|
|
|
588 -- If no specific preprocessing data, then take the default
|
|
|
589
|
|
|
590 if Index = 0 then
|
|
|
591 if Default_Data_Defined then
|
|
|
592 Current_Data := Default_Data;
|
|
|
593 Default := True;
|
|
|
594
|
|
|
595 else
|
|
|
596 -- If no default, then nothing to do
|
|
|
597
|
|
|
598 return;
|
|
|
599 end if;
|
|
|
600 end if;
|
|
|
601
|
|
|
602 -- Set the preprocessing flags according to the preprocessing data
|
|
|
603
|
|
|
604 if Current_Data.Comments and not Current_Data.Always_Blank then
|
|
|
605 Comment_Deleted_Lines := True;
|
|
|
606 Blank_Deleted_Lines := False;
|
|
|
607 else
|
|
|
608 Comment_Deleted_Lines := False;
|
|
|
609 Blank_Deleted_Lines := True;
|
|
|
610 end if;
|
|
|
611
|
|
|
612 No_Deletion := Current_Data.No_Deletion;
|
|
|
613 Undefined_Symbols_Are_False := Current_Data.Undef_False;
|
|
|
614 List_Preprocessing_Symbols := Current_Data.List_Symbols;
|
|
|
615
|
|
|
616 -- If not already done it, process the definition file
|
|
|
617
|
|
|
618 if Current_Data.Processed then
|
|
|
619
|
|
|
620 -- Set Prep.Mapping
|
|
|
621
|
|
|
622 Prep.Mapping := Current_Data.Mapping;
|
|
|
623
|
|
|
624 else
|
|
|
625 -- First put the mapping in Prep.Mapping, because Prep.Parse_Def_File
|
|
|
626 -- works on Prep.Mapping.
|
|
|
627
|
|
|
628 Prep.Mapping := Current_Data.Mapping;
|
|
|
629
|
|
|
630 String_To_Name_Buffer (Current_Data.Deffile);
|
|
|
631
|
|
|
632 declare
|
|
|
633 N : constant File_Name_Type := Name_Find;
|
|
|
634 Deffile : constant Source_File_Index := Load_Definition_File (N);
|
|
|
635 T : constant Nat := Total_Errors_Detected;
|
|
|
636
|
|
|
637 Add_Deffile : Boolean := True;
|
|
|
638
|
|
|
639 begin
|
|
|
640 if Deffile <= No_Source_File then
|
|
|
641 Fail
|
|
|
642 ("definition file """ & Get_Name_String (N) & """ not found");
|
|
|
643 end if;
|
|
|
644
|
|
|
645 -- Initialize the preprocessor and set the characteristics of the
|
|
|
646 -- scanner for a definition file.
|
|
|
647
|
|
|
648 Prep.Setup_Hooks
|
|
|
649 (Error_Msg => Errout.Error_Msg'Access,
|
|
|
650 Scan => Scn.Scanner.Scan'Access,
|
|
|
651 Set_Ignore_Errors => Errout.Set_Ignore_Errors'Access,
|
|
|
652 Put_Char => null,
|
|
|
653 New_EOL => null);
|
|
|
654
|
|
|
655 Scn.Scanner.Set_End_Of_Line_As_Token (True);
|
|
|
656 Scn.Scanner.Reset_Special_Characters;
|
|
|
657
|
|
|
658 -- Initialize the scanner and process the definition file
|
|
|
659
|
|
|
660 Scn.Scanner.Initialize_Scanner (Deffile);
|
|
|
661 Prep.Parse_Def_File;
|
|
|
662
|
|
|
663 -- Reset the behavior of the scanner to the default
|
|
|
664
|
|
|
665 Scn.Scanner.Set_End_Of_Line_As_Token (False);
|
|
|
666
|
|
|
667 -- Fail if errors were found while processing the definition file
|
|
|
668
|
|
|
669 if T /= Total_Errors_Detected then
|
|
|
670 Errout.Finalize (Last_Call => True);
|
|
|
671 Errout.Output_Messages;
|
|
|
672 Fail ("errors found in definition file """
|
|
|
673 & Get_Name_String (N)
|
|
|
674 & """");
|
|
|
675 end if;
|
|
|
676
|
|
|
677 for Index in 1 .. Dependencies.Last loop
|
|
|
678 if Dependencies.Table (Index) = Deffile then
|
|
|
679 Add_Deffile := False;
|
|
|
680 exit;
|
|
|
681 end if;
|
|
|
682 end loop;
|
|
|
683
|
|
|
684 if Add_Deffile then
|
|
|
685 Add_Dependency (Deffile);
|
|
|
686 end if;
|
|
|
687 end;
|
|
|
688
|
|
|
689 -- Get back the mapping, indicate that the definition file is
|
|
|
690 -- processed and store back the preprocessing data.
|
|
|
691
|
|
|
692 Current_Data.Mapping := Prep.Mapping;
|
|
|
693 Current_Data.Processed := True;
|
|
|
694
|
|
|
695 if Default then
|
|
|
696 Default_Data := Current_Data;
|
|
|
697
|
|
|
698 else
|
|
|
699 Preproc_Data_Table.Table (Index) := Current_Data;
|
|
|
700 end if;
|
|
|
701 end if;
|
|
|
702
|
|
|
703 Preprocessing_Needed := True;
|
|
|
704 end Prepare_To_Preprocess;
|
|
|
705
|
|
|
706 ---------------------------------------------
|
|
|
707 -- Process_Command_Line_Symbol_Definitions --
|
|
|
708 ---------------------------------------------
|
|
|
709
|
|
|
710 procedure Process_Command_Line_Symbol_Definitions is
|
|
|
711 Symbol_Data : Prep.Symbol_Data;
|
|
|
712 Found : Boolean := False;
|
|
|
713
|
|
|
714 begin
|
|
|
715 Symbol_Table.Init (Command_Line_Symbols);
|
|
|
716
|
|
|
717 -- The command line definitions have been stored temporarily in
|
|
|
718 -- array Symbol_Definitions.
|
|
|
719
|
|
|
720 for Index in 1 .. Preprocessing_Symbol_Last loop
|
|
|
721 -- Check each symbol definition, fail immediately if syntax is not
|
|
|
722 -- correct.
|
|
|
723
|
|
|
724 Check_Command_Line_Symbol_Definition
|
|
|
725 (Definition => Preprocessing_Symbol_Defs (Index).all,
|
|
|
726 Data => Symbol_Data);
|
|
|
727 Found := False;
|
|
|
728
|
|
|
729 -- If there is already a definition for this symbol, replace the old
|
|
|
730 -- definition by this one.
|
|
|
731
|
|
|
732 for J in 1 .. Symbol_Table.Last (Command_Line_Symbols) loop
|
|
|
733 if Command_Line_Symbols.Table (J).Symbol = Symbol_Data.Symbol then
|
|
|
734 Command_Line_Symbols.Table (J) := Symbol_Data;
|
|
|
735 Found := True;
|
|
|
736 exit;
|
|
|
737 end if;
|
|
|
738 end loop;
|
|
|
739
|
|
|
740 -- Otherwise, create a new entry in the table
|
|
|
741
|
|
|
742 if not Found then
|
|
|
743 Symbol_Table.Increment_Last (Command_Line_Symbols);
|
|
|
744 Command_Line_Symbols.Table
|
|
|
745 (Symbol_Table.Last (Command_Line_Symbols)) := Symbol_Data;
|
|
|
746 end if;
|
|
|
747 end loop;
|
|
|
748 end Process_Command_Line_Symbol_Definitions;
|
|
|
749
|
|
|
750 -------------------------
|
|
|
751 -- Skip_To_End_Of_Line --
|
|
|
752 -------------------------
|
|
|
753
|
|
|
754 procedure Skip_To_End_Of_Line is
|
|
|
755 begin
|
|
|
756 Set_Ignore_Errors (To => True);
|
|
|
757
|
|
|
758 while Token /= Tok_End_Of_Line and then Token /= Tok_EOF loop
|
|
|
759 Scan;
|
|
|
760 end loop;
|
|
|
761
|
|
|
762 Set_Ignore_Errors (To => False);
|
|
|
763 end Skip_To_End_Of_Line;
|
|
|
764
|
|
|
765 end Prepcomp;
|
