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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [gcc/] [ada/] [sinput.ads] - Blame information for rev 826

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 281 jeremybenn
------------------------------------------------------------------------------
2
--                                                                          --
3
--                         GNAT COMPILER COMPONENTS                         --
4
--                                                                          --
5
--                               S I N P U T                                --
6
--                                                                          --
7
--                                 S p e c                                  --
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
-- As a special exception under Section 7 of GPL version 3, you are granted --
19
-- additional permissions described in the GCC Runtime Library Exception,   --
20
-- version 3.1, as published by the Free Software Foundation.               --
21
--                                                                          --
22
-- You should have received a copy of the GNU General Public License and    --
23
-- a copy of the GCC Runtime Library Exception along with this program;     --
24
-- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    --
25
-- <http://www.gnu.org/licenses/>.                                          --
26
--                                                                          --
27
-- GNAT was originally developed  by the GNAT team at  New York University. --
28
-- Extensive contributions were provided by Ada Core Technologies Inc.      --
29
--                                                                          --
30
------------------------------------------------------------------------------
31
 
32
--  This package contains the input routines used for reading the
33
--  input source file. The actual I/O routines are in OS_Interface,
34
--  with this module containing only the system independent processing.
35
 
36
--  General Note: throughout the compiler, we use the term line or source
37
--  line to refer to a physical line in the source, terminated by the end of
38
--  physical line sequence.
39
 
40
--  There are two distinct concepts of line terminator in GNAT
41
 
42
--    A logical line terminator is what corresponds to the "end of a line" as
43
--    described in RM 2.2 (13). Any of the characters FF, LF, CR or VT or any
44
--    wide character that is a Line or Paragraph Separator acts as an end of
45
--    logical line in this sense, and it is essentially irrelevant whether one
46
--    or more appears in sequence (since if sequence of such characters is
47
--    regarded as separate ends of line, then the intervening logical lines
48
--    are null in any case).
49
 
50
--    A physical line terminator is a sequence of format effectors that is
51
--    treated as ending a physical line. Physical lines have no Ada semantic
52
--    significance, but they are significant for error reporting purposes,
53
--    since errors are identified by line and column location.
54
 
55
--  In GNAT, a physical line is ended by any of the sequences LF, CR/LF, or
56
--  CR. LF is used in typical Unix systems, CR/LF in DOS systems, and CR
57
--  alone in System 7. In addition, we recognize any of these sequences in
58
--  any of the operating systems, for better behavior in treating foreign
59
--  files (e.g. a Unix file with LF terminators transferred to a DOS system).
60
--  Finally, wide character codes in categories Separator, Line and Separator,
61
--  Paragraph are considered to be physical line terminators.
62
 
63
with Alloc;
64
with Casing; use Casing;
65
with Namet;  use Namet;
66
with Table;
67
with Types;  use Types;
68
 
69
package Sinput is
70
 
71
   type Type_Of_File is (
72
   --  Indicates type of file being read
73
 
74
      Src,
75
      --  Normal Ada source file
76
 
77
      Config,
78
      --  Configuration pragma file
79
 
80
      Def,
81
      --  Preprocessing definition file
82
 
83
      Preproc);
84
      --  Source file with preprocessing commands to be preprocessed
85
 
86
   ----------------------------
87
   -- Source License Control --
88
   ----------------------------
89
 
90
   --  The following type indicates the license state of a source if it
91
   --  is known.
92
 
93
   type License_Type is
94
     (Unknown,
95
      --  Licensing status of this source unit is unknown
96
 
97
      Restricted,
98
      --  This is a non-GPL'ed unit that is restricted from depending
99
      --  on GPL'ed units (e.g. proprietary code is in this category)
100
 
101
      GPL,
102
      --  This file is licensed under the unmodified GPL. It is not allowed
103
      --  to depend on Non_GPL units, and Non_GPL units may not depend on
104
      --  this source unit.
105
 
106
      Modified_GPL,
107
      --  This file is licensed under the GNAT modified GPL (see header of
108
      --  This file for wording of the modification). It may depend on other
109
      --  Modified_GPL units or on unrestricted units.
110
 
111
      Unrestricted);
112
      --  The license on this file is permitted to depend on any other
113
      --  units, or have other units depend on it, without violating the
114
      --  license of this unit. Examples are public domain units, and
115
      --  units defined in the RM).
116
 
117
   --  The above license status is checked when the appropriate check is
118
   --  activated and one source depends on another, and the licensing state
119
   --  of both files is known:
120
 
121
   --  The prohibited combinations are:
122
 
123
   --    Restricted file may not depend on GPL file
124
 
125
   --    GPL file may not depend on Restricted file
126
 
127
   --    Modified GPL file may not depend on Restricted file
128
   --    Modified_GPL file may not depend on GPL file
129
 
130
   --  The reason for the last restriction here is that a client depending
131
   --  on a modified GPL file must be sure that the license condition is
132
   --  correct considered transitively.
133
 
134
   --  The licensing status is determined either by the presence of a
135
   --  specific pragma License, or by scanning the header for a predefined
136
   --  file, or any file if compiling in -gnatg mode.
137
 
138
   -----------------------
139
   -- Source File Table --
140
   -----------------------
141
 
142
   --  The source file table has an entry for each source file read in for
143
   --  this run of the compiler. This table is (default) initialized when
144
   --  the compiler is loaded, and simply accumulates entries as compilation
145
   --  proceeds and various routines in Sinput and its child packages are
146
   --  called to load required source files.
147
 
148
   --  Virtual entries are also created for generic templates when they are
149
   --  instantiated, as described in a separate section later on.
150
 
151
   --  In the case where there are multiple main units (e.g. in the case of
152
   --  the cross-reference tool), this table is not reset between these units,
153
   --  so that a given source file is only read once if it is used by two
154
   --  separate main units.
155
 
156
   --  The entries in the table are accessed using a Source_File_Index that
157
   --  ranges from 1 to Last_Source_File. Each entry has the following fields
158
 
159
   --  Note: fields marked read-only are set by Sinput or one of its child
160
   --  packages when a source file table entry is created, and cannot be
161
   --  subsequently modified, or alternatively are set only by very special
162
   --  circumstances, documented in the comments.
163
 
164
   --  File_Name : File_Name_Type (read-only)
165
   --    Name of the source file (simple name with no directory information)
166
 
167
   --  Full_File_Name : File_Name_Type (read-only)
168
   --    Full file name (full name with directory info), used for generation
169
   --    of error messages, etc.
170
 
171
   --  File_Type : Type_Of_File (read-only)
172
   --    Indicates type of file (source file, configuration pragmas file,
173
   --    preprocessor definition file, preprocessor input file).
174
 
175
   --  Reference_Name : File_Name_Type (read-only)
176
   --    Name to be used for source file references in error messages where
177
   --    only the simple name of the file is required. Identical to File_Name
178
   --    unless pragma Source_Reference is used to change it. Only processing
179
   --    for the Source_Reference pragma circuit may set this field.
180
 
181
   --  Full_Ref_Name : File_Name_Type (read-only)
182
   --    Name to be used for source file references in error messages where
183
   --    the full name of the file is required. Identical to Full_File_Name
184
   --    unless pragma Source_Reference is used to change it. Only processing
185
   --    for the Source_Reference pragma may set this field.
186
 
187
   --  Debug_Source_Name : File_Name_Type (read-only)
188
   --    Name to be used for source file references in debugging information
189
   --    where only the simple name of the file is required. Identical to
190
   --    Reference_Name unless the -gnatD (debug source file) switch is used.
191
   --    Only processing in Sprint that generates this file is permitted to
192
   --    set this field.
193
 
194
   --  Full_Debug_Name : File_Name_Type (read-only)
195
   --    Name to be used for source file references in debugging information
196
   --    where the full name of the file is required. This is identical to
197
   --    Full_Ref_Name unless the -gnatD (debug source file) switch is used.
198
   --    Only processing in Sprint that generates this file is permitted to
199
   --    set this field.
200
 
201
   --  License : License_Type;
202
   --    License status of source file
203
 
204
   --  Num_SRef_Pragmas : Nat;
205
   --    Number of source reference pragmas present in source file
206
 
207
   --  First_Mapped_Line : Logical_Line_Number;
208
   --    This field stores logical line number of the first line in the
209
   --    file that is not a Source_Reference pragma. If no source reference
210
   --    pragmas are used, then the value is set to No_Line_Number.
211
 
212
   --  Source_Text : Source_Buffer_Ptr (read-only)
213
   --    Text of source file. Note that every source file has a distinct set
214
   --    of non-overlapping logical bounds, so it is possible to determine
215
   --    which file is referenced from a given subscript (Source_Ptr) value.
216
 
217
   --  Source_First : Source_Ptr; (read-only)
218
   --    Subscript of first character in Source_Text. Note that this cannot
219
   --    be obtained as Source_Text'First, because we use virtual origin
220
   --    addressing.
221
 
222
   --  Source_Last : Source_Ptr; (read-only)
223
   --    Subscript of last character in Source_Text. Note that this cannot
224
   --    be obtained as Source_Text'Last, because we use virtual origin
225
   --    addressing, so this value is always Source_Ptr'Last.
226
 
227
   --  Time_Stamp : Time_Stamp_Type; (read-only)
228
   --    Time stamp of the source file
229
 
230
   --  Source_Checksum : Word;
231
   --    Computed checksum for contents of source file. See separate section
232
   --    later on in this spec for a description of the checksum algorithm.
233
 
234
   --  Last_Source_Line : Physical_Line_Number;
235
   --    Physical line number of last source line. While a file is being
236
   --    read, this refers to the last line scanned. Once a file has been
237
   --    completely scanned, it is the number of the last line in the file,
238
   --    and hence also gives the number of source lines in the file.
239
 
240
   --  Keyword_Casing : Casing_Type;
241
   --    Casing style used in file for keyword casing. This is initialized
242
   --    to Unknown, and then set from the first occurrence of a keyword.
243
   --    This value is used only for formatting of error messages.
244
 
245
   --  Identifier_Casing : Casing_Type;
246
   --    Casing style used in file for identifier casing. This is initialized
247
   --    to Unknown, and then set from an identifier in the program as soon as
248
   --    one is found whose casing is sufficiently clear to make a decision.
249
   --    This value is used for formatting of error messages, and also is used
250
   --    in the detection of keywords misused as identifiers.
251
 
252
   --  Instantiation : Source_Ptr;
253
   --    Source file location of the instantiation if this source file entry
254
   --    represents a generic instantiation. Set to No_Location for the case
255
   --    of a normal non-instantiation entry. See section below for details.
256
   --    This field is read-only for clients.
257
 
258
   --  Inlined_Body : Boolean;
259
   --    This can only be set True if Instantiation has a value other than
260
   --    No_Location. If true it indicates that the instantiation is actually
261
   --    an instance of an inlined body.
262
 
263
   --  Template : Source_File_Index; (read-only)
264
   --    Source file index of the source file containing the template if this
265
   --    is a generic instantiation. Set to No_Source_File for the normal case
266
   --    of a non-instantiation entry. See Sinput-L for details.
267
 
268
   --  Unit : Unit_Number_Type;
269
   --    Identifies the unit contained in this source file. Set by
270
   --    Initialize_Scanner, must not be subsequently altered.
271
 
272
   --  The source file table is accessed by clients using the following
273
   --  subprogram interface:
274
 
275
   subtype SFI is Source_File_Index;
276
 
277
   System_Source_File_Index : SFI;
278
   --  The file system.ads is always read by the compiler to determine the
279
   --  settings of the target parameters in the private part of System. This
280
   --  variable records the source file index of system.ads. Typically this
281
   --  will be 1 since system.ads is read first.
282
 
283
   function Debug_Source_Name (S : SFI) return File_Name_Type;
284
   function File_Name         (S : SFI) return File_Name_Type;
285
   function File_Type         (S : SFI) return Type_Of_File;
286
   function First_Mapped_Line (S : SFI) return Logical_Line_Number;
287
   function Full_Debug_Name   (S : SFI) return File_Name_Type;
288
   function Full_File_Name    (S : SFI) return File_Name_Type;
289
   function Full_Ref_Name     (S : SFI) return File_Name_Type;
290
   function Identifier_Casing (S : SFI) return Casing_Type;
291
   function Inlined_Body      (S : SFI) return Boolean;
292
   function Instantiation     (S : SFI) return Source_Ptr;
293
   function Keyword_Casing    (S : SFI) return Casing_Type;
294
   function Last_Source_Line  (S : SFI) return Physical_Line_Number;
295
   function License           (S : SFI) return License_Type;
296
   function Num_SRef_Pragmas  (S : SFI) return Nat;
297
   function Reference_Name    (S : SFI) return File_Name_Type;
298
   function Source_Checksum   (S : SFI) return Word;
299
   function Source_First      (S : SFI) return Source_Ptr;
300
   function Source_Last       (S : SFI) return Source_Ptr;
301
   function Source_Text       (S : SFI) return Source_Buffer_Ptr;
302
   function Template          (S : SFI) return Source_File_Index;
303
   function Unit              (S : SFI) return Unit_Number_Type;
304
   function Time_Stamp        (S : SFI) return Time_Stamp_Type;
305
 
306
   procedure Set_Keyword_Casing    (S : SFI; C : Casing_Type);
307
   procedure Set_Identifier_Casing (S : SFI; C : Casing_Type);
308
   procedure Set_License           (S : SFI; L : License_Type);
309
   procedure Set_Unit              (S : SFI; U : Unit_Number_Type);
310
 
311
   function Last_Source_File return Source_File_Index;
312
   --  Index of last source file table entry
313
 
314
   function Num_Source_Files return Nat;
315
   --  Number of source file table entries
316
 
317
   procedure Initialize;
318
   --  Initialize internal tables
319
 
320
   procedure Lock;
321
   --  Lock internal tables
322
 
323
   procedure Unlock;
324
   --  Unlock internal tables
325
 
326
   Main_Source_File : Source_File_Index := No_Source_File;
327
   --  This is set to the source file index of the main unit
328
 
329
   -----------------------------
330
   -- Source_File_Index_Table --
331
   -----------------------------
332
 
333
   --  The Get_Source_File_Index function is called very frequently. Earlier
334
   --  versions cached a single entry, but then reverted to a serial search,
335
   --  and this proved to be a significant source of inefficiency. To get
336
   --  around this, we use the following directly indexed array. The space
337
   --  of possible input values is a value of type Source_Ptr which is simply
338
   --  an Int value. The values in this space are allocated sequentially as
339
   --  new units are loaded.
340
 
341
   --  The following table has an entry for each 4K range of possible
342
   --  Source_Ptr values. The value in the table is the lowest value
343
   --  Source_File_Index whose Source_Ptr range contains value in the
344
   --  range.
345
 
346
   --  For example, the entry with index 4 in this table represents Source_Ptr
347
   --  values in the range 4*4096 .. 5*4096-1. The Source_File_Index value
348
   --  stored would be the lowest numbered source file with at least one byte
349
   --  in this range.
350
 
351
   --  The algorithm used in Get_Source_File_Index is simply to access this
352
   --  table and then do a serial search starting at the given position. This
353
   --  will almost always terminate with one or two checks.
354
 
355
   --  Note that this array is pretty large, but in most operating systems
356
   --  it will not be allocated in physical memory unless it is actually used.
357
 
358
   Chunk_Power : constant := 12;
359
   Chunk_Size  : constant := 2 ** Chunk_Power;
360
   --  Change comments above if value changed. Note that Chunk_Size must
361
   --  be a power of 2 (to allow for efficient access to the table).
362
 
363
   Source_File_Index_Table :
364
     array (Int range 0 .. Int'Last / Chunk_Size) of Source_File_Index;
365
 
366
   procedure Set_Source_File_Index_Table (Xnew : Source_File_Index);
367
   --  Sets entries in the Source_File_Index_Table for the newly created
368
   --  Source_File table entry whose index is Xnew. The Source_First and
369
   --  Source_Last fields of this entry must be set before the call.
370
 
371
   -----------------------
372
   -- Checksum Handling --
373
   -----------------------
374
 
375
   --  As a source file is scanned, a checksum is computed by taking all the
376
   --  non-blank characters in the file, excluding comment characters, the
377
   --  minus-minus sequence starting a comment, and all control characters
378
   --  except ESC.
379
 
380
   --  The checksum algorithm used is the standard CRC-32 algorithm, as
381
   --  implemented by System.CRC32, except that we do not bother with the
382
   --  final XOR with all 1 bits.
383
 
384
   --  This algorithm ensures that the checksum includes all semantically
385
   --  significant aspects of the program represented by the source file,
386
   --  but is insensitive to layout, presence or contents of comments, wide
387
   --  character representation method, or casing conventions outside strings.
388
 
389
   --  Scans.Checksum is initialized appropriately at the start of scanning
390
   --  a file, and copied into the Source_Checksum field of the file table
391
   --  entry when the end of file is encountered.
392
 
393
   -------------------------------------
394
   -- Handling Generic Instantiations --
395
   -------------------------------------
396
 
397
   --  As described in Sem_Ch12, a generic instantiation involves making a
398
   --  copy of the tree of the generic template. The source locations in
399
   --  this tree directly reference the source of the template. However it
400
   --  is also possible to find the location of the instantiation.
401
 
402
   --  This is achieved as follows. When an instantiation occurs, a new entry
403
   --  is made in the source file table. This entry points to the same source
404
   --  text, i.e. the file that contains the instantiation, but has a distinct
405
   --  set of Source_Ptr index values. The separate range of Sloc values avoids
406
   --  confusion, and means that the Sloc values can still be used to uniquely
407
   --  identify the source file table entry. It is possible for both entries
408
   --  to point to the same text, because of the virtual origin pointers used
409
   --  in the source table.
410
 
411
   --  The Instantiation field of this source file index entry, usually set
412
   --  to No_Source_File, instead contains the Sloc of the instantiation. In
413
   --  the case of nested instantiations, this Sloc may itself refer to an
414
   --  instantiation, so the complete chain can be traced.
415
 
416
   --  Two routines are used to build these special entries in the source
417
   --  file table. Create_Instantiation_Source is first called to build
418
   --  the virtual source table entry for the instantiation, and then the
419
   --  Sloc values in the copy are adjusted using Adjust_Instantiation_Sloc.
420
   --  See child unit Sinput.L for details on these two routines.
421
 
422
   -----------------
423
   -- Global Data --
424
   -----------------
425
 
426
   Current_Source_File : Source_File_Index := No_Source_File;
427
   --  Source_File table index of source file currently being scanned.
428
   --  Initialized so that some tools (such as gprbuild) can be built with
429
   --  -gnatVa and pragma Initialized_Scalars without problems.
430
 
431
   Current_Source_Unit : Unit_Number_Type;
432
   --  Unit number of source file currently being scanned. The special value
433
   --  of No_Unit indicates that the configuration pragma file is currently
434
   --  being scanned (this has no entry in the unit table).
435
 
436
   Source_gnat_adc : Source_File_Index := No_Source_File;
437
   --  This is set if a gnat.adc file is present to reference this file
438
 
439
   Source : Source_Buffer_Ptr;
440
   --  Current source (copy of Source_File.Table (Current_Source_Unit).Source)
441
 
442
   Internal_Source : aliased Source_Buffer (1 .. 81);
443
   --  This buffer is used internally in the compiler when the lexical analyzer
444
   --  is used to scan a string from within the compiler. The procedure is to
445
   --  establish Internal_Source_Ptr as the value of Source, set the string to
446
   --  be scanned, appropriately terminated, in this buffer, and set Scan_Ptr
447
   --  to point to the start of the buffer. It is a fatal error if the scanner
448
   --  signals an error while scanning a token in this internal buffer.
449
 
450
   Internal_Source_Ptr : constant Source_Buffer_Ptr :=
451
                           Internal_Source'Unrestricted_Access;
452
   --  Pointer to internal source buffer
453
 
454
   -----------------
455
   -- Subprograms --
456
   -----------------
457
 
458
   procedure Backup_Line (P : in out Source_Ptr);
459
   --  Back up the argument pointer to the start of the previous line. On
460
   --  entry, P points to the start of a physical line in the source buffer.
461
   --  On return, P is updated to point to the start of the previous line.
462
   --  The caller has checked that a Line_Terminator character precedes P so
463
   --  that there definitely is a previous line in the source buffer.
464
 
465
   procedure Build_Location_String (Loc : Source_Ptr);
466
   --  This function builds a string literal of the form "name:line", where
467
   --  name is the file name corresponding to Loc, and line is the line number.
468
   --  In the event that instantiations are involved, additional suffixes of
469
   --  the same form are appended after the separating string " instantiated at
470
   --  ". The returned string is appended to the Name_Buffer, terminated by
471
   --  ASCII.NUL, with Name_Length indicating the length not including the
472
   --  terminating Nul.
473
 
474
   function Get_Column_Number (P : Source_Ptr) return Column_Number;
475
   --  The ones-origin column number of the specified Source_Ptr value is
476
   --  determined and returned. Tab characters if present are assumed to
477
   --  represent the standard 1,9,17.. spacing pattern.
478
 
479
   function Get_Logical_Line_Number
480
     (P : Source_Ptr) return Logical_Line_Number;
481
   --  The line number of the specified source position is obtained by
482
   --  doing a binary search on the source positions in the lines table
483
   --  for the unit containing the given source position. The returned
484
   --  value is the logical line number, already adjusted for the effect
485
   --  of source reference pragmas. If P refers to the line of a source
486
   --  reference pragma itself, then No_Line is returned. If no source
487
   --  reference pragmas have been encountered, the value returned is
488
   --  the same as the physical line number.
489
 
490
   function Get_Physical_Line_Number
491
     (P : Source_Ptr) return Physical_Line_Number;
492
   --  The line number of the specified source position is obtained by
493
   --  doing a binary search on the source positions in the lines table
494
   --  for the unit containing the given source position. The returned
495
   --  value is the physical line number in the source being compiled.
496
 
497
   function Get_Source_File_Index (S : Source_Ptr) return Source_File_Index;
498
   --  Return file table index of file identified by given source pointer
499
   --  value. This call must always succeed, since any valid source pointer
500
   --  value belongs to some previously loaded source file.
501
 
502
   function Instantiation_Depth (S : Source_Ptr) return Nat;
503
   --  Determine instantiation depth for given Sloc value. A value of
504
   --  zero means that the given Sloc is not in an instantiation.
505
 
506
   function Line_Start (P : Source_Ptr) return Source_Ptr;
507
   --  Finds the source position of the start of the line containing the
508
   --  given source location.
509
 
510
   function Line_Start
511
     (L : Physical_Line_Number;
512
      S : Source_File_Index) return Source_Ptr;
513
   --  Finds the source position of the start of the given line in the
514
   --  given source file, using a physical line number to identify the line.
515
 
516
   function Num_Source_Lines (S : Source_File_Index) return Nat;
517
   --  Returns the number of source lines (this is equivalent to reading
518
   --  the value of Last_Source_Line, but returns Nat rather than a
519
   --  physical line number.
520
 
521
   procedure Register_Source_Ref_Pragma
522
     (File_Name          : File_Name_Type;
523
      Stripped_File_Name : File_Name_Type;
524
      Mapped_Line        : Nat;
525
      Line_After_Pragma  : Physical_Line_Number);
526
   --  Register a source reference pragma, the parameter File_Name is the
527
   --  file name from the pragma, and Stripped_File_Name is this name with
528
   --  the directory information stripped. Both these parameters are set
529
   --  to No_Name if no file name parameter was given in the pragma.
530
   --  (which can only happen for the second and subsequent pragmas).
531
   --  Mapped_Line is the line number parameter from the pragma, and
532
   --  Line_After_Pragma is the physical line number of the line that
533
   --  follows the line containing the Source_Reference pragma.
534
 
535
   function Original_Location (S : Source_Ptr) return Source_Ptr;
536
   --  Given a source pointer S, returns the corresponding source pointer
537
   --  value ignoring instantiation copies. For locations that do not
538
   --  correspond to instantiation copies of templates, the argument is
539
   --  returned unchanged. For locations that do correspond to copies of
540
   --  templates from instantiations, the location within the original
541
   --  template is returned. This is useful in canonicalizing locations.
542
 
543
   function Instantiation_Location (S : Source_Ptr) return Source_Ptr;
544
   pragma Inline (Instantiation_Location);
545
   --  Given a source pointer S, returns the corresponding source pointer
546
   --  value of the instantiation if this location is within an instance.
547
   --  If S is not within an instance, then this returns No_Location.
548
 
549
   function Top_Level_Location (S : Source_Ptr) return Source_Ptr;
550
   --  Given a source pointer S, returns the argument unchanged if it is
551
   --  not in an instantiation. If S is in an instantiation, then it returns
552
   --  the location of the top level instantiation, i.e. the outer level
553
   --  instantiation in the nested case.
554
 
555
   function Physical_To_Logical
556
     (Line : Physical_Line_Number;
557
      S    : Source_File_Index) return Logical_Line_Number;
558
   --  Given a physical line number in source file whose source index is S,
559
   --  return the corresponding logical line number. If the physical line
560
   --  number is one containing a Source_Reference pragma, the result will
561
   --  be No_Line_Number.
562
 
563
   procedure Skip_Line_Terminators
564
     (P        : in out Source_Ptr;
565
      Physical : out Boolean);
566
   --  On entry, P points to a line terminator that has been encountered,
567
   --  which is one of FF,LF,VT,CR or a wide character sequence whose value is
568
   --  in category Separator,Line or Separator,Paragraph. P points just past
569
   --  the character that was scanned. The purpose of this routine is to
570
   --  distinguish physical and logical line endings. A physical line ending
571
   --  is one of:
572
   --
573
   --     CR on its own (MAC System 7)
574
   --     LF on its own (Unix and unix-like systems)
575
   --     CR/LF (DOS, Windows)
576
   --     Wide character in Separator,Line or Separator,Paragraph category
577
   --
578
   --     Note: we no longer recognize LF/CR (which we did in some earlier
579
   --     versions of GNAT. The reason for this is that this sequence is not
580
   --     used and recognizing it generated confusion. For example given the
581
   --     sequence LF/CR/LF we were interpreting that as (LF/CR) ending the
582
   --     first line and a blank line ending with CR following, but it is
583
   --     clearly better to interpret this as LF, with a blank line terminated
584
   --     by CR/LF, given that LF and CR/LF are both in common use, but no
585
   --     system we know of uses LF/CR.
586
   --
587
   --  A logical line ending (that is not a physical line ending) is one of:
588
   --
589
   --     VT on its own
590
   --     FF on its own
591
   --
592
   --  On return, P is bumped past the line ending sequence (one of the above
593
   --  seven possibilities). Physical is set to True to indicate that a
594
   --  physical end of line was encountered, in which case this routine also
595
   --  makes sure that the lines table for the current source file has an
596
   --  appropriate entry for the start of the new physical line.
597
 
598
   procedure Sloc_Range (N : Node_Id; Min, Max : out Source_Ptr);
599
   --  Given a node, returns the minimum and maximum source locations of any
600
   --  node in the syntactic subtree for the node. This is not quite the same
601
   --  as the locations of the first and last token in the node construct
602
   --  because parentheses at the outer level do not have a recorded Sloc.
603
   --
604
   --  Note: if the tree for the expression contains no "real" Sloc values,
605
   --  i.e. values > No_Location, then both Min and Max are set to Sloc (Expr).
606
 
607
   function Source_Offset (S : Source_Ptr) return Nat;
608
   --  Returns the zero-origin offset of the given source location from the
609
   --  start of its corresponding unit. This is used for creating canonical
610
   --  names in some situations.
611
 
612
   procedure Write_Location (P : Source_Ptr);
613
   --  Writes out a string of the form fff:nn:cc, where fff, nn, cc are the
614
   --  file name, line number and column corresponding to the given source
615
   --  location. No_Location and Standard_Location appear as the strings
616
   --  <no location> and <standard location>. If the location is within an
617
   --  instantiation, then the instance location is appended, enclosed in
618
   --  square brackets (which can nest if necessary). Note that this routine
619
   --  is used only for internal compiler debugging output purposes (which
620
   --  is why the somewhat cryptic use of brackets is acceptable).
621
 
622
   procedure wl (P : Source_Ptr);
623
   pragma Export (Ada, wl);
624
   --  Equivalent to Write_Location (P); Write_Eol; for calls from GDB
625
 
626
   procedure Write_Time_Stamp (S : Source_File_Index);
627
   --  Writes time stamp of specified file in YY-MM-DD HH:MM.SS format
628
 
629
   procedure Tree_Read;
630
   --  Initializes internal tables from current tree file using the relevant
631
   --  Table.Tree_Read routines.
632
 
633
   procedure Tree_Write;
634
   --  Writes out internal tables to current tree file using the relevant
635
   --  Table.Tree_Write routines.
636
 
637
private
638
   pragma Inline (File_Name);
639
   pragma Inline (First_Mapped_Line);
640
   pragma Inline (Full_File_Name);
641
   pragma Inline (Identifier_Casing);
642
   pragma Inline (Instantiation);
643
   pragma Inline (Keyword_Casing);
644
   pragma Inline (Last_Source_Line);
645
   pragma Inline (Last_Source_File);
646
   pragma Inline (License);
647
   pragma Inline (Num_SRef_Pragmas);
648
   pragma Inline (Num_Source_Files);
649
   pragma Inline (Num_Source_Lines);
650
   pragma Inline (Reference_Name);
651
   pragma Inline (Set_Keyword_Casing);
652
   pragma Inline (Set_Identifier_Casing);
653
   pragma Inline (Source_First);
654
   pragma Inline (Source_Last);
655
   pragma Inline (Source_Text);
656
   pragma Inline (Template);
657
   pragma Inline (Time_Stamp);
658
 
659
   -------------------------
660
   -- Source_Lines Tables --
661
   -------------------------
662
 
663
   type Lines_Table_Type is
664
     array (Physical_Line_Number) of Source_Ptr;
665
   --  Type used for lines table. The entries are indexed by physical line
666
   --  numbers. The values are the starting Source_Ptr values for the start
667
   --  of the corresponding physical line. Note that we make this a bogus
668
   --  big array, sized as required, so that we avoid the use of fat pointers.
669
 
670
   type Lines_Table_Ptr is access all Lines_Table_Type;
671
   --  Type used for pointers to line tables
672
 
673
   type Logical_Lines_Table_Type is
674
     array (Physical_Line_Number) of Logical_Line_Number;
675
   --  Type used for logical lines table. This table is used if a source
676
   --  reference pragma is present. It is indexed by physical line numbers,
677
   --  and contains the corresponding logical line numbers. An entry that
678
   --  corresponds to a source reference pragma is set to No_Line_Number.
679
   --  Note that we make this a bogus big array, sized as required, so that
680
   --  we avoid the use of fat pointers.
681
 
682
   type Logical_Lines_Table_Ptr is access all Logical_Lines_Table_Type;
683
   --  Type used for pointers to logical line tables
684
 
685
   -----------------------
686
   -- Source_File Table --
687
   -----------------------
688
 
689
   --  See earlier descriptions for meanings of public fields
690
 
691
   type Source_File_Record is record
692
      File_Name         : File_Name_Type;
693
      Reference_Name    : File_Name_Type;
694
      Debug_Source_Name : File_Name_Type;
695
      Full_Debug_Name   : File_Name_Type;
696
      Full_File_Name    : File_Name_Type;
697
      Full_Ref_Name     : File_Name_Type;
698
      Num_SRef_Pragmas  : Nat;
699
      First_Mapped_Line : Logical_Line_Number;
700
      Source_Text       : Source_Buffer_Ptr;
701
      Source_First      : Source_Ptr;
702
      Source_Last       : Source_Ptr;
703
      Source_Checksum   : Word;
704
      Last_Source_Line  : Physical_Line_Number;
705
      Instantiation     : Source_Ptr;
706
      Template          : Source_File_Index;
707
      Unit              : Unit_Number_Type;
708
      Time_Stamp        : Time_Stamp_Type;
709
      File_Type         : Type_Of_File;
710
      Inlined_Body      : Boolean;
711
      License           : License_Type;
712
      Keyword_Casing    : Casing_Type;
713
      Identifier_Casing : Casing_Type;
714
 
715
      --  The following fields are for internal use only (i.e. only in the
716
      --  body of Sinput or its children, with no direct access by clients).
717
 
718
      Sloc_Adjust : Source_Ptr;
719
      --  A value to be added to Sloc values for this file to reference the
720
      --  corresponding lines table. This is zero for the non-instantiation
721
      --  case, and set so that the addition references the ultimate template
722
      --  for the instantiation case. See Sinput-L for further details.
723
 
724
      Lines_Table : Lines_Table_Ptr;
725
      --  Pointer to lines table for this source. Updated as additional
726
      --  lines are accessed using the Skip_Line_Terminators procedure.
727
      --  Note: the lines table for an instantiation entry refers to the
728
      --  original line numbers of the template see Sinput-L for details.
729
 
730
      Logical_Lines_Table : Logical_Lines_Table_Ptr;
731
      --  Pointer to logical lines table for this source. Non-null only if
732
      --  a source reference pragma has been processed. Updated as lines
733
      --  are accessed using the Skip_Line_Terminators procedure.
734
 
735
      Lines_Table_Max : Physical_Line_Number;
736
      --  Maximum subscript values for currently allocated Lines_Table
737
      --  and (if present) the allocated Logical_Lines_Table. The value
738
      --  Max_Source_Line gives the maximum used value, this gives the
739
      --  maximum allocated value.
740
 
741
   end record;
742
 
743
   --  The following representation clause ensures that the above record
744
   --  has no holes. We do this so that when instances of this record are
745
   --  written by Tree_Gen, we do not write uninitialized values to the file.
746
 
747
   AS : constant Pos := Standard'Address_Size;
748
 
749
   for Source_File_Record use record
750
      File_Name           at  0 range 0 .. 31;
751
      Reference_Name      at  4 range 0 .. 31;
752
      Debug_Source_Name   at  8 range 0 .. 31;
753
      Full_Debug_Name     at 12 range 0 .. 31;
754
      Full_File_Name      at 16 range 0 .. 31;
755
      Full_Ref_Name       at 20 range 0 .. 31;
756
      Num_SRef_Pragmas    at 24 range 0 .. 31;
757
      First_Mapped_Line   at 28 range 0 .. 31;
758
      Source_First        at 32 range 0 .. 31;
759
      Source_Last         at 36 range 0 .. 31;
760
      Source_Checksum     at 40 range 0 .. 31;
761
      Last_Source_Line    at 44 range 0 .. 31;
762
      Instantiation       at 48 range 0 .. 31;
763
      Template            at 52 range 0 .. 31;
764
      Unit                at 56 range 0 .. 31;
765
      Time_Stamp          at 60 range 0 .. 8 * Time_Stamp_Length - 1;
766
      File_Type           at 74 range 0 .. 7;
767
      Inlined_Body        at 75 range 0 .. 7;
768
      License             at 76 range 0 .. 7;
769
      Keyword_Casing      at 77 range 0 .. 7;
770
      Identifier_Casing   at 78 range 0 .. 15;
771
      Sloc_Adjust         at 80 range 0 .. 31;
772
      Lines_Table_Max     at 84 range 0 .. 31;
773
 
774
      --  The following fields are pointers, so we have to specialize their
775
      --  lengths using pointer size, obtained above as Standard'Address_Size.
776
 
777
      Source_Text         at 88 range 0      .. AS - 1;
778
      Lines_Table         at 88 range AS     .. AS * 2 - 1;
779
      Logical_Lines_Table at 88 range AS * 2 .. AS * 3 - 1;
780
   end record;
781
 
782
   for Source_File_Record'Size use 88 * 8 + AS * 3;
783
   --  This ensures that we did not leave out any fields
784
 
785
   package Source_File is new Table.Table (
786
     Table_Component_Type => Source_File_Record,
787
     Table_Index_Type     => Source_File_Index,
788
     Table_Low_Bound      => 1,
789
     Table_Initial        => Alloc.Source_File_Initial,
790
     Table_Increment      => Alloc.Source_File_Increment,
791
     Table_Name           => "Source_File");
792
 
793
   -----------------
794
   -- Subprograms --
795
   -----------------
796
 
797
   procedure Alloc_Line_Tables
798
     (S       : in out Source_File_Record;
799
      New_Max : Nat);
800
   --  Allocate or reallocate the lines table for the given source file so
801
   --  that it can accommodate at least New_Max lines. Also allocates or
802
   --  reallocates logical lines table if source ref pragmas are present.
803
 
804
   procedure Add_Line_Tables_Entry
805
     (S : in out Source_File_Record;
806
      P : Source_Ptr);
807
   --  Increment line table size by one (reallocating the lines table if
808
   --  needed) and set the new entry to contain the value P. Also bumps
809
   --  the Source_Line_Count field. If source reference pragmas are
810
   --  present, also increments logical lines table size by one, and
811
   --  sets new entry.
812
 
813
   procedure Trim_Lines_Table (S : Source_File_Index);
814
   --  Set lines table size for entry S in the source file table to
815
   --  correspond to the current value of Num_Source_Lines, releasing
816
   --  any unused storage. This is used by Sinput.L and Sinput.D.
817
 
818
end Sinput;

powered by: WebSVN 2.1.0

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