gcc/ada/sinput.ads

   1 ------------------------------------------------------------------------------
   2 --                                                                          --
   3 --                         GNAT COMPILER COMPONENTS                         --
   4 --                                                                          --
   5 --                               S I N P U T                                --
   6 --                                                                          --
   7 --                                 S p e c                                  --
   8 --                                                                          --
   9 --                            $Revision: 1.2 $
  10 --                                                                          --
  11 --          Copyright (C) 1992-2001 Free Software Foundation, Inc.          --
  12 --                                                                          --
  13 -- GNAT is free software;  you can  redistribute it  and/or modify it under --
  14 -- terms of the  GNU General Public License as published  by the Free Soft- --
  15 -- ware  Foundation;  either version 2,  or (at your option) any later ver- --
  16 -- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
  17 -- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
  18 -- or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License --
  19 -- for  more details.  You should have  received  a copy of the GNU General --
  20 -- Public License  distributed with GNAT;  see file COPYING.  If not, write --
  21 -- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
  22 -- MA 02111-1307, USA.                                                      --
  23 --                                                                          --
  24 -- As a special exception,  if other files  instantiate  generics from this --
  25 -- unit, or you link  this unit with other files  to produce an executable, --
  26 -- this  unit  does not  by itself cause  the resulting  executable  to  be --
  27 -- covered  by the  GNU  General  Public  License.  This exception does not --
  28 -- however invalidate  any other reasons why  the executable file  might be --
  29 -- covered by the  GNU Public License.                                      --
  30 --                                                                          --
  31 -- GNAT was originally developed  by the GNAT team at  New York University. --
  32 -- It is now maintained by Ada Core Technologies Inc (http://www.gnat.com). --
  33 --                                                                          --
  34 ------------------------------------------------------------------------------
  35
  36 --  This package contains the input routines used for reading the
  37 --  input source file. The actual I/O routines are in OS_Interface,
  38 --  with this module containing only the system independent processing.
  39
  40 --  General Note: throughout the compiler, we use the term line or source
  41 --  line to refer to a physical line in the source, terminated by the end of
  42 --  physical line sequence. See Skip_Line_Terminators procedure for a full
  43 --  description of the difference between logical and physical lines.
  44
  45 with Alloc;
  46 with Casing; use Casing;
  47 with Table;
  48 with Types;  use Types;
  49
  50 package Sinput is
  51
  52    ----------------------------
  53    -- Source License Control --
  54    ----------------------------
  55
  56    --  The following type indicates the license state of a source if it
  57    --  is known.
  58
  59    type License_Type is
  60      (Unknown,
  61       --  Licensing status of this source unit is unknown
  62
  63       Restricted,
  64       --  This is a non-GPL'ed unit that is restricted from depending
  65       --  on GPL'ed units (e.g. proprietary code is in this category)
  66
  67       GPL,
  68       --  This file is licensed under the unmodified GPL. It is not allowed
  69       --  to depend on Non_GPL units, and Non_GPL units may not depend on
  70       --  this source unit.
  71
  72       Modified_GPL,
  73       --  This file is licensed under the GNAT modified GPL (see header of
  74       --  This file for wording of the modification). It may depend on other
  75       --  Modified_GPL units or on unrestricted units.
  76
  77       Unrestricted);
  78       --  The license on this file is permitted to depend on any other
  79       --  units, or have other units depend on it, without violating the
  80       --  license of this unit. Examples are public domain units, and
  81       --  units defined in the RM).
  82
  83    --  The above license status is checked when the appropriate check is
  84    --  activated and one source depends on another, and the licensing state
  85    --  of both files is known:
  86
  87    --  The prohibited combinations are:
  88
  89    --    Restricted file may not depend on GPL file
  90
  91    --    GPL file may not depend on Restricted file
  92
  93    --    Modified GPL file may not depend on Restricted file
  94    --    Modified_GPL file may not depend on GPL file
  95
  96    --  The reason for the last restriction here is that a client depending
  97    --  on a modified GPL file must be sure that the license condition is
  98    --  correct considered transitively.
  99
 100    --  The licensing status is determined either by the presence of a
 101    --  specific pragma License, or by scanning the header for a predefined
 102    --  file, or any file if compiling in -gnatg mode.
 103
 104    -----------------------
 105    -- Source File Table --
 106    -----------------------
 107
 108    --  The source file table has an entry for each source file read in for
 109    --  this run of the compiler. This table is (default) initialized when
 110    --  the compiler is loaded, and simply accumulates entries as compilation
 111    --  proceeds and the Sinput.L.Load_Source_File procedure is called to load
 112    --  required source files.
 113
 114    --  Virtual entries are also created for generic templates when they are
 115    --  instantiated, as described in a separate section later on.
 116
 117    --  In the case where there are multiple main units (e.g. in the case of
 118    --  the cross-reference tool), this table is not reset between these units,
 119    --  so that a given source file is only read once if it is used by two
 120    --  separate main units.
 121
 122    --  The entries in the table are accessed using a Source_File_Index that
 123    --  ranges from 1 to Last_Source_File. Each entry has the following fields
 124
 125    --  Note that entry 1 is always for system.ads (see Targparm for details
 126    --  of why we always read this source file first), and we have defined a
 127    --  constant Types.System_Source_File_Index as 1 to reflect this fact.
 128
 129    --  File_Name : File_Name_Type
 130    --    Name of the source file (simple name with no directory information).
 131    --    Set by Sinput.L.Load_Source_File and cannot be subequently changed.
 132
 133    --  Full_File_Name : File_Name_Type
 134    --    Full file name (full name with directory info), used for generation
 135    --    of error messages, etc. Set by Sinput.L.Load_Source_File and cannot
 136    --    be subsequently changed.
 137
 138    --  Reference_Name : File_Name_Type
 139    --    Name to be used for source file references in error messages where
 140    --    only the simple name of the file is required. Identical to File_Name
 141    --    unless pragma Source_Reference is used to change it. Only processing
 142    --    for the Source_Reference pragma circuit may set this field.
 143
 144    --  Full_Ref_Name : File_Name_Type
 145    --    Name to be used for source file references in error messages where
 146    --    the full name of the file is required. Identical to Full_File_Name
 147    --    unless pragma Source_Reference is used to change it. Only processing
 148    --    for the Source_Reference pragma may set this field.
 149
 150    --  Debug_Source_Name : File_Name_Type
 151    --    Name to be used for source file references in debugging information
 152    --    where only the simple name of the file is required. Identical to
 153    --    Full_Ref_Name unless the -gnatD (debug source file) switch is used.
 154    --    Only processing in Sprint that generates this file is permitted to
 155    --    set this field.
 156
 157    --  License : License_Type;
 158    --    License status of source file
 159
 160    --  Num_SRef_Pragmas : Nat;
 161    --    Number of source reference pragmas present in source file
 162
 163    --  First_Mapped_Line : Logical_Line_Number;
 164    --    This field stores logical line number of the first line in the
 165    --    file that is not a Source_Reference pragma. If no source reference
 166    --    pragmas are used, then the value is set to No_Line_Number.
 167
 168    --  Source_Text : Source_Buffer_Ptr
 169    --    Text of source file. Note that every source file has a distinct set
 170    --    of non-overlapping logical bounds, so it is possible to determine
 171    --    which file is referenced from a given subscript (Source_Ptr) value.
 172    --    Set by Sinput.L.Load_Source_File and cannot be subsequently changed.
 173
 174    --  Source_First : Source_Ptr;
 175    --    Subscript of first character in Source_Text. Note that this cannot
 176    --    be obtained as Source_Text'First, because we use virtual origin
 177    --    addressing. Set by Sinput.L procedures when the entry is first
 178    --    created and never subsequently changed.
 179
 180    --  Source_Last : Source_Ptr;
 181    --    Subscript of last character in Source_Text. Note that this cannot
 182    --    be obtained as Source_Text'Last, because we use virtual origin
 183    --    addressing, so this value is always Source_Ptr'Last. Set by
 184    --    Sinput.L procedures when the entry is first created and never
 185    --    subsequently changed.
 186
 187    --  Time_Stamp : Time_Stamp_Type;
 188    --    Time stamp of the source file. Set by Sinput.L.Load_Source_File,
 189    --    and cannot be subsequently changed.
 190
 191    --  Source_Checksum : Word;
 192    --    Computed checksum for contents of source file. See separate section
 193    --    later on in this spec for a description of the checksum algorithm.
 194
 195    --  Last_Source_Line : Physical_Line_Number;
 196    --    Physical line number of last source line. Whlie a file is being
 197    --    read, this refers to the last line scanned. Once a file has been
 198    --    completely scanned, it is the number of the last line in the file,
 199    --    and hence also gives the number of source lines in the file.
 200
 201    --  Keyword_Casing : Casing_Type;
 202    --    Casing style used in file for keyword casing. This is initialized
 203    --    to Unknown, and then set from the first occurrence of a keyword.
 204    --    This value is used only for formatting of error messages.
 205
 206    --  Identifier_Casing : Casing_Type;
 207    --    Casing style used in file for identifier casing. This is initialized
 208    --    to Unknown, and then set from an identifier in the program as soon as
 209    --    one is found whose casing is sufficiently clear to make a decision.
 210    --    This value is used for formatting of error messages, and also is used
 211    --    in the detection of keywords misused as identifiers.
 212
 213    --  Instantiation : Source_Ptr;
 214    --    Source file location of the instantiation if this source file entry
 215    --    represents a generic instantiation. Set to No_Location for the case
 216    --    of a normal non-instantiation entry. See section below for details.
 217    --    This field is read-only for clients.
 218
 219    --  Template : Source_File_Index;
 220    --    Source file index of the source file containing the template if this
 221    --    is a generic instantiation. Set to No_Source_File for the normal case
 222    --    of a non-instantiation entry. See Sinput-L for details. This field is
 223    --    read-only for clients.
 224
 225    --  The source file table is accessed by clients using the following
 226    --  subprogram interface:
 227
 228    subtype SFI is Source_File_Index;
 229
 230    function Debug_Source_Name (S : SFI) return File_Name_Type;
 231    function File_Name         (S : SFI) return File_Name_Type;
 232    function First_Mapped_Line (S : SFI) return Logical_Line_Number;
 233    function Full_File_Name    (S : SFI) return File_Name_Type;
 234    function Full_Ref_Name     (S : SFI) return File_Name_Type;
 235    function Identifier_Casing (S : SFI) return Casing_Type;
 236    function Instantiation     (S : SFI) return Source_Ptr;
 237    function Keyword_Casing    (S : SFI) return Casing_Type;
 238    function Last_Source_Line  (S : SFI) return Physical_Line_Number;
 239    function License           (S : SFI) return License_Type;
 240    function Num_SRef_Pragmas  (S : SFI) return Nat;
 241    function Reference_Name    (S : SFI) return File_Name_Type;
 242    function Source_Checksum   (S : SFI) return Word;
 243    function Source_First      (S : SFI) return Source_Ptr;
 244    function Source_Last       (S : SFI) return Source_Ptr;
 245    function Source_Text       (S : SFI) return Source_Buffer_Ptr;
 246    function Template          (S : SFI) return Source_File_Index;
 247    function Time_Stamp        (S : SFI) return Time_Stamp_Type;
 248
 249    procedure Set_Keyword_Casing    (S : SFI; C : Casing_Type);
 250    procedure Set_Identifier_Casing (S : SFI; C : Casing_Type);
 251    procedure Set_License           (S : SFI; L : License_Type);
 252
 253    function Last_Source_File return Source_File_Index;
 254    --  Index of last source file table entry
 255
 256    function Num_Source_Files return Nat;
 257    --  Number of source file table entries
 258
 259    procedure Initialize;
 260    --  Initialize internal tables
 261
 262    procedure Lock;
 263    --  Lock internal tables
 264
 265    Main_Source_File : Source_File_Index;
 266    --  This is set to the source file index of the main unit
 267
 268    -----------------------
 269    -- Checksum Handling --
 270    -----------------------
 271
 272    --  As a source file is scanned, a checksum is computed by taking all the
 273    --  non-blank characters in the file, excluding comment characters, the
 274    --  minus-minus sequence starting a comment, and all control characters
 275    --  except ESC.
 276
 277    --  The checksum algorithm used is the standard CRC-32 algorithm, as
 278    --  implemented by System.CRC32, except that we do not bother with the
 279    --  final XOR with all 1 bits.
 280
 281    --  This algorithm ensures that the checksum includes all semantically
 282    --  significant aspects of the program represented by the source file,
 283    --  but is insensitive to layout, presence or contents of comments, wide
 284    --  character representation method, or casing conventions outside strings.
 285
 286    --  Scans.Checksum is initialized appropriately at the start of scanning
 287    --  a file, and copied into the Source_Checksum field of the file table
 288    --  entry when the end of file is encountered.
 289
 290    -------------------------------------
 291    -- Handling Generic Instantiations --
 292    -------------------------------------
 293
 294    --  As described in Sem_Ch12, a generic instantiation involves making a
 295    --  copy of the tree of the generic template. The source locations in
 296    --  this tree directly reference the source of the template. However it
 297    --  is also possible to find the location of the instantiation.
 298
 299    --  This is achieved as follows. When an instantiation occurs, a new entry
 300    --  is made in the source file table. This entry points to the same source
 301    --  text, i.e. the file that contains the instantiation, but has a distinct
 302    --  set of Source_Ptr index values. The separate range of Sloc values avoids
 303    --  confusion, and means that the Sloc values can still be used to uniquely
 304    --  identify the source file table entry. It is possible for both entries
 305    --  to point to the same text, because of the virtual origin pointers used
 306    --  in the source table.
 307
 308    --  The Instantiation field of this source file index entry, usually set
 309    --  to No_Source_File, instead contains the Sloc of the instantiation. In
 310    --  the case of nested instantiations, this Sloc may itself refer to an
 311    --  instantiation, so the complete chain can be traced.
 312
 313    --  Two routines are used to build these special entries in the source
 314    --  file table. Create_Instantiation_Source is first called to build
 315    --  the virtual source table entry for the instantiation, and then the
 316    --  Sloc values in the copy are adjusted using Adjust_Instantiation_Sloc.
 317    --  See child unit Sinput.L for details on these two routines.
 318
 319    -----------------
 320    -- Global Data --
 321    -----------------
 322
 323    Current_Source_File : Source_File_Index;
 324    --  Source_File table index of source file currently being scanned
 325
 326    Current_Source_Unit : Unit_Number_Type;
 327    --  Unit number of source file currently being scanned. The special value
 328    --  of No_Unit indicates that the configuration pragma file is currently
 329    --  being scanned (this has no entry in the unit table).
 330
 331    Source_gnat_adc : Source_File_Index := No_Source_File;
 332    --  This is set if a gnat.adc file is present to reference this file
 333
 334    Source : Source_Buffer_Ptr;
 335    --  Current source (copy of Source_File.Table (Current_Source_Unit).Source)
 336
 337    Internal_Source : aliased Source_Buffer (1 .. 81);
 338    --  This buffer is used internally in the compiler when the lexical analyzer
 339    --  is used to scan a string from within the compiler. The procedure is to
 340    --  establish Internal_Source_Ptr as the value of Source, set the string to
 341    --  be scanned, appropriately terminated, in this buffer, and set Scan_Ptr
 342    --  to point to the start of the buffer. It is a fatal error if the scanner
 343    --  signals an error while scanning a token in this internal buffer.
 344
 345    Internal_Source_Ptr : constant Source_Buffer_Ptr :=
 346                            Internal_Source'Unrestricted_Access;
 347    --  Pointer to internal source buffer
 348
 349    -----------------
 350    -- Subprograms --
 351    -----------------
 352
 353    procedure Backup_Line (P : in out Source_Ptr);
 354    --  Back up the argument pointer to the start of the previous line. On
 355    --  entry, P points to the start of a physical line in the source buffer.
 356    --  On return, P is updated to point to the start of the previous line.
 357    --  The caller has checked that a Line_Terminator character precedes P so
 358    --  that there definitely is a previous line in the source buffer.
 359
 360    procedure Build_Location_String (Loc : Source_Ptr);
 361    --  This function builds a string literal of the form "name:line",
 362    --  where name is the file name corresponding to Loc, and line is
 363    --  the line number. In the event that instantiations are involved,
 364    --  additional suffixes of the same form are appended after the
 365    --  separating string " instantiated at ". The returned string is
 366    --  stored in Name_Buffer, terminated by ASCII.Nul, with Name_Length
 367    --  indicating the length not including the terminating Nul.
 368
 369    function Get_Column_Number (P : Source_Ptr) return Column_Number;
 370    --  The ones-origin column number of the specified Source_Ptr value is
 371    --  determined and returned. Tab characters if present are assumed to
 372    --  represent the standard 1,9,17.. spacing pattern.
 373
 374    function Get_Logical_Line_Number
 375      (P    : Source_Ptr)
 376       return Logical_Line_Number;
 377    --  The line number of the specified source position is obtained by
 378    --  doing a binary search on the source positions in the lines table
 379    --  for the unit containing the given source position. The returned
 380    --  value is the logical line number, already adjusted for the effect
 381    --  of source reference pragmas. If P refers to the line of a source
 382    --  reference pragma itself, then No_Line is returned. If no source
 383    --  reference pragmas have been encountered, the value returned is
 384    --  the same as the physical line number.
 385
 386    function Get_Physical_Line_Number
 387      (P    : Source_Ptr)
 388       return Physical_Line_Number;
 389    --  The line number of the specified source position is obtained by
 390    --  doing a binary search on the source positions in the lines table
 391    --  for the unit containing the given source position. The returned
 392    --  value is the physical line number in the source being compiled.
 393
 394    function Get_Source_File_Index (S : Source_Ptr) return Source_File_Index;
 395    --  Return file table index of file identified by given source pointer
 396    --  value. This call must always succeed, since any valid source pointer
 397    --  value belongs to some previously loaded source file.
 398
 399    function Instantiation_Depth (S : Source_Ptr) return Nat;
 400    --  Determine instantiation depth for given Sloc value. A value of
 401    --  zero means that the given Sloc is not in an instantiation.
 402
 403    function Line_Start (P : Source_Ptr) return Source_Ptr;
 404    --  Finds the source position of the start of the line containing the
 405    --  given source location.
 406
 407    function Line_Start
 408      (L    : Physical_Line_Number;
 409       S    : Source_File_Index)
 410       return Source_Ptr;
 411    --  Finds the source position of the start of the given line in the
 412    --  given source file, using a physical line number to identify the line.
 413
 414    function Num_Source_Lines (S : Source_File_Index) return Nat;
 415    --  Returns the number of source lines (this is equivalent to reading
 416    --  the value of Last_Source_Line, but returns Nat rathern than a
 417    --  physical line number.
 418
 419    procedure Register_Source_Ref_Pragma
 420      (File_Name          : Name_Id;
 421       Stripped_File_Name : Name_Id;
 422       Mapped_Line        : Nat;
 423       Line_After_Pragma  : Physical_Line_Number);
 424    --  Register a source reference pragma, the parameter File_Name is the
 425    --  file name from the pragma, and Stripped_File_Name is this name with
 426    --  the directory information stripped. Both these parameters are set
 427    --  to No_Name if no file name parameter was given in the pragma.
 428    --  (which can only happen for the second and subsequent pragmas).
 429    --  Mapped_Line is the line number parameter from the pragma, and
 430    --  Line_After_Pragma is the physical line number of the line that
 431    --  follows the line containing the Source_Reference pragma.
 432
 433    function Original_Location (S : Source_Ptr) return Source_Ptr;
 434    --  Given a source pointer S, returns the corresponding source pointer
 435    --  value ignoring instantiation copies. For locations that do not
 436    --  correspond to instantiation copies of templates, the argument is
 437    --  returned unchanged. For locations that do correspond to copies of
 438    --  templates from instantiations, the location within the original
 439    --  template is returned. This is useful in canonicalizing locations.
 440
 441    function Instantiation_Location (S : Source_Ptr) return Source_Ptr;
 442    pragma Inline (Instantiation_Location);
 443    --  Given a source pointer S, returns the corresponding source pointer
 444    --  value of the instantiation if this location is within an instance.
 445    --  If S is not within an instance, then this returns No_Location.
 446
 447    function Top_Level_Location (S : Source_Ptr) return Source_Ptr;
 448    --  Given a source pointer S, returns the argument unchanged if it is
 449    --  not in an instantiation. If S is in an instantiation, then it returns
 450    --  the location of the top level instantiation, i.e. the outer level
 451    --  instantiation in the nested case.
 452
 453    function Physical_To_Logical
 454      (Line : Physical_Line_Number;
 455       S    : Source_File_Index)
 456       return Logical_Line_Number;
 457    --  Given a physical line number in source file whose source index is S,
 458    --  return the corresponding logical line number. If the physical line
 459    --  number is one containing a Source_Reference pragma, the result will
 460    --  be No_Line_Number.
 461
 462    procedure Skip_Line_Terminators
 463      (P        : in out Source_Ptr;
 464       Physical : out Boolean);
 465    --  On entry, Source (P) points to the line terminator character that
 466    --  terminates a line. The result set in P is the location of the first
 467    --  character of the following line (after skipping the sequence of line
 468    --  terminator characters terminating the current line). In addition, if
 469    --  the terminator sequence ends a physical line (the definition of what
 470    --  constitutes a physical line is embodied in the implementation of this
 471    --  function), and it is the first time this sequence is encountered, then
 472    --  an entry is made in the lines table to record the location for further
 473    --  use by functions such as Get_Line_Number. Physical is set to True if
 474    --  the line terminator was the end of a physical line.
 475
 476    function Source_Offset (S : Source_Ptr) return Nat;
 477    --  Returns the zero-origin offset of the given source location from the
 478    --  start of its corresponding unit. This is used for creating canonical
 479    --  names in some situations.
 480
 481    procedure Write_Location (P : Source_Ptr);
 482    --  Writes out a string of the form fff:nn:cc, where fff, nn, cc are the
 483    --  file name, line number and column corresponding to the given source
 484    --  location. No_Location and Standard_Location appear as the strings
 485    --  <no location> and <standard location>. If the location is within an
 486    --  instantiation, then the instance location is appended, enclosed in
 487    --  square brackets (which can nest if necessary). Note that this routine
 488    --  is used only for internal compiler debugging output purposes (which
 489    --  is why the somewhat cryptic use of brackets is acceptable).
 490
 491    procedure wl (P : Source_Ptr);
 492    --  Equivalent to Write_Location (P); Write_Eol; for calls from GDB
 493
 494    procedure Write_Time_Stamp (S : Source_File_Index);
 495    --  Writes time stamp of specified file in YY-MM-DD HH:MM.SS format
 496
 497    procedure Tree_Write;
 498    --  Writes out internal tables to current tree file using Tree_Write
 499
 500    procedure Tree_Read;
 501    --  Initializes internal tables from current tree file using Tree_Read
 502
 503 private
 504    pragma Inline (File_Name);
 505    pragma Inline (First_Mapped_Line);
 506    pragma Inline (Full_File_Name);
 507    pragma Inline (Identifier_Casing);
 508    pragma Inline (Instantiation);
 509    pragma Inline (Keyword_Casing);
 510    pragma Inline (Last_Source_Line);
 511    pragma Inline (Last_Source_File);
 512    pragma Inline (License);
 513    pragma Inline (Num_SRef_Pragmas);
 514    pragma Inline (Num_Source_Files);
 515    pragma Inline (Num_Source_Lines);
 516    pragma Inline (Reference_Name);
 517    pragma Inline (Set_Keyword_Casing);
 518    pragma Inline (Set_Identifier_Casing);
 519    pragma Inline (Source_First);
 520    pragma Inline (Source_Last);
 521    pragma Inline (Source_Text);
 522    pragma Inline (Template);
 523    pragma Inline (Time_Stamp);
 524
 525    -------------------------
 526    -- Source_Lines Tables --
 527    -------------------------
 528
 529    type Lines_Table_Type is
 530      array (Physical_Line_Number) of Source_Ptr;
 531    --  Type used for lines table. The entries are indexed by physical line
 532    --  numbers. The values are the starting Source_Ptr values for the start
 533    --  of the corresponding physical line. Note that we make this a bogus
 534    --  big array, sized as required, so that we avoid the use of fat pointers.
 535
 536    type Lines_Table_Ptr is access all Lines_Table_Type;
 537    --  Type used for pointers to line tables
 538
 539    type Logical_Lines_Table_Type is
 540      array (Physical_Line_Number) of Logical_Line_Number;
 541    --  Type used for logical lines table. This table is used if a source
 542    --  reference pragma is present. It is indexed by physical line numbers,
 543    --  and contains the corresponding logical line numbers. An entry that
 544    --  corresponds to a source reference pragma is set to No_Line_Number.
 545    --  Note that we make this a bogus big array, sized as required, so that
 546    --  we avoid the use of fat pointers.
 547
 548    type Logical_Lines_Table_Ptr is access all Logical_Lines_Table_Type;
 549    --  Type used for pointers to logical line tables.
 550
 551    -----------------------
 552    -- Source_File Table --
 553    -----------------------
 554
 555    --  See earlier descriptions for meanings of public fields
 556
 557    type Source_File_Record is record
 558
 559       File_Name         : File_Name_Type;
 560       Reference_Name    : File_Name_Type;
 561       Debug_Source_Name : File_Name_Type;
 562       Full_File_Name    : File_Name_Type;
 563       Full_Ref_Name     : File_Name_Type;
 564       License           : License_Type;
 565       Num_SRef_Pragmas  : Nat;
 566       First_Mapped_Line : Logical_Line_Number;
 567       Source_Text       : Source_Buffer_Ptr;
 568       Source_First      : Source_Ptr;
 569       Source_Last       : Source_Ptr;
 570       Time_Stamp        : Time_Stamp_Type;
 571       Source_Checksum   : Word;
 572       Last_Source_Line  : Physical_Line_Number;
 573       Keyword_Casing    : Casing_Type;
 574       Identifier_Casing : Casing_Type;
 575       Instantiation     : Source_Ptr;
 576       Template          : Source_File_Index;
 577
 578       --  The following fields are for internal use only (i.e. only in the
 579       --  body of Sinput or its children, with no direct access by clients).
 580
 581       Sloc_Adjust : Source_Ptr;
 582       --  A value to be added to Sloc values for this file to reference the
 583       --  corresponding lines table. This is zero for the non-instantiation
 584       --  case, and set so that the adition references the ultimate template
 585       --  for the instantiation case. See Sinput-L for further details.
 586
 587       Lines_Table : Lines_Table_Ptr;
 588       --  Pointer to lines table for this source. Updated as additional
 589       --  lines are accessed using the Skip_Line_Terminators procedure.
 590       --  Note: the lines table for an instantiation entry refers to the
 591       --  original line numbers of the template see Sinput-L for details.
 592
 593       Logical_Lines_Table : Logical_Lines_Table_Ptr;
 594       --  Pointer to logical lines table for this source. Non-null only if
 595       --  a source reference pragma has been processed. Updated as lines
 596       --  are accessed using the Skip_Line_Terminators procedure.
 597
 598       Lines_Table_Max : Physical_Line_Number;
 599       --  Maximum subscript values for currently allocated Lines_Table
 600       --  and (if present) the allocated Logical_Lines_Table. The value
 601       --  Max_Source_Line gives the maximum used value, this gives the
 602       --  maximum allocated value.
 603
 604    end record;
 605
 606    package Source_File is new Table.Table (
 607      Table_Component_Type => Source_File_Record,
 608      Table_Index_Type     => Source_File_Index,
 609      Table_Low_Bound      => 1,
 610      Table_Initial        => Alloc.Source_File_Initial,
 611      Table_Increment      => Alloc.Source_File_Increment,
 612      Table_Name           => "Source_File");
 613
 614    -----------------
 615    -- Subprograms --
 616    -----------------
 617
 618    procedure Alloc_Line_Tables
 619      (S       : in out Source_File_Record;
 620       New_Max : Nat);
 621    --  Allocate or reallocate the lines table for the given source file so
 622    --  that it can accommodate at least New_Max lines. Also allocates or
 623    --  reallocates logical lines table if source ref pragmas are present.
 624
 625    procedure Add_Line_Tables_Entry
 626      (S : in out Source_File_Record;
 627       P : Source_Ptr);
 628    --  Increment line table size by one (reallocating the lines table if
 629    --  needed) and set the new entry to contain the value P. Also bumps
 630    --  the Source_Line_Count field. If source reference pragmas are
 631    --  present, also increments logical lines table size by one, and
 632    --  sets new entry.
 633
 634 end Sinput;