1------------------------------------------------------------------------------ 2-- -- 3-- GNAT COMPILER COMPONENTS -- 4-- -- 5-- S I N P U T -- 6-- -- 7-- S p e c -- 8-- -- 9-- Copyright (C) 1992-2012, 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 a 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 63with Alloc; 64with Casing; use Casing; 65with Namet; use Namet; 66with Table; 67with Types; use Types; 68 69package 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 type Instance_Id is new Nat; 87 No_Instance_Id : constant Instance_Id; 88 89 ---------------------------- 90 -- Source License Control -- 91 ---------------------------- 92 93 -- The following type indicates the license state of a source if it 94 -- is known. 95 96 type License_Type is 97 (Unknown, 98 -- Licensing status of this source unit is unknown 99 100 Restricted, 101 -- This is a non-GPL'ed unit that is restricted from depending 102 -- on GPL'ed units (e.g. proprietary code is in this category) 103 104 GPL, 105 -- This file is licensed under the unmodified GPL. It is not allowed 106 -- to depend on Non_GPL units, and Non_GPL units may not depend on 107 -- this source unit. 108 109 Modified_GPL, 110 -- This file is licensed under the GNAT modified GPL (see header of 111 -- This file for wording of the modification). It may depend on other 112 -- Modified_GPL units or on unrestricted units. 113 114 Unrestricted); 115 -- The license on this file is permitted to depend on any other 116 -- units, or have other units depend on it, without violating the 117 -- license of this unit. Examples are public domain units, and 118 -- units defined in the RM). 119 120 -- The above license status is checked when the appropriate check is 121 -- activated and one source depends on another, and the licensing state 122 -- of both files is known: 123 124 -- The prohibited combinations are: 125 126 -- Restricted file may not depend on GPL file 127 128 -- GPL file may not depend on Restricted file 129 130 -- Modified GPL file may not depend on Restricted file 131 -- Modified_GPL file may not depend on GPL file 132 133 -- The reason for the last restriction here is that a client depending 134 -- on a modified GPL file must be sure that the license condition is 135 -- correct considered transitively. 136 137 -- The licensing status is determined either by the presence of a 138 -- specific pragma License, or by scanning the header for a predefined 139 -- file, or any file if compiling in -gnatg mode. 140 141 ----------------------- 142 -- Source File Table -- 143 ----------------------- 144 145 -- The source file table has an entry for each source file read in for 146 -- this run of the compiler. This table is (default) initialized when 147 -- the compiler is loaded, and simply accumulates entries as compilation 148 -- proceeds and various routines in Sinput and its child packages are 149 -- called to load required source files. 150 151 -- Virtual entries are also created for generic templates when they are 152 -- instantiated, as described in a separate section later on. 153 154 -- In the case where there are multiple main units (e.g. in the case of 155 -- the cross-reference tool), this table is not reset between these units, 156 -- so that a given source file is only read once if it is used by two 157 -- separate main units. 158 159 -- The entries in the table are accessed using a Source_File_Index that 160 -- ranges from 1 to Last_Source_File. Each entry has the following fields 161 162 -- Note: fields marked read-only are set by Sinput or one of its child 163 -- packages when a source file table entry is created, and cannot be 164 -- subsequently modified, or alternatively are set only by very special 165 -- circumstances, documented in the comments. 166 167 -- File_Name : File_Name_Type (read-only) 168 -- Name of the source file (simple name with no directory information) 169 170 -- Full_File_Name : File_Name_Type (read-only) 171 -- Full file name (full name with directory info), used for generation 172 -- of error messages, etc. 173 174 -- File_Type : Type_Of_File (read-only) 175 -- Indicates type of file (source file, configuration pragmas file, 176 -- preprocessor definition file, preprocessor input file). 177 178 -- Reference_Name : File_Name_Type (read-only) 179 -- Name to be used for source file references in error messages where 180 -- only the simple name of the file is required. Identical to File_Name 181 -- unless pragma Source_Reference is used to change it. Only processing 182 -- for the Source_Reference pragma circuit may set this field. 183 184 -- Full_Ref_Name : File_Name_Type (read-only) 185 -- Name to be used for source file references in error messages where 186 -- the full name of the file is required. Identical to Full_File_Name 187 -- unless pragma Source_Reference is used to change it. Only processing 188 -- for the Source_Reference pragma may set this field. 189 190 -- Debug_Source_Name : File_Name_Type (read-only) 191 -- Name to be used for source file references in debugging information 192 -- where only the simple name of the file is required. Identical to 193 -- Reference_Name unless the -gnatD (debug source file) switch is used. 194 -- Only processing in Sprint that generates this file is permitted to 195 -- set this field. 196 197 -- Full_Debug_Name : File_Name_Type (read-only) 198 -- Name to be used for source file references in debugging information 199 -- where the full name of the file is required. This is identical to 200 -- Full_Ref_Name unless the -gnatD (debug source file) switch is used. 201 -- Only processing in Sprint that generates this file is permitted to 202 -- set this field. 203 204 -- Instance : Instance_Id (read-only) 205 -- For entries corresponding to a generic instantiation, unique 206 -- identifier denoting the full chain of nested instantiations. Set to 207 -- No_Instance_Id for the case of a normal, non-instantiation entry. 208 -- See below for details on the handling of generic instantiations. 209 210 -- License : License_Type; 211 -- License status of source file 212 213 -- Num_SRef_Pragmas : Nat; 214 -- Number of source reference pragmas present in source file 215 216 -- First_Mapped_Line : Logical_Line_Number; 217 -- This field stores logical line number of the first line in the 218 -- file that is not a Source_Reference pragma. If no source reference 219 -- pragmas are used, then the value is set to No_Line_Number. 220 221 -- Source_Text : Source_Buffer_Ptr (read-only) 222 -- Text of source file. Note that every source file has a distinct set 223 -- of non-overlapping logical bounds, so it is possible to determine 224 -- which file is referenced from a given subscript (Source_Ptr) value. 225 226 -- Source_First : Source_Ptr; (read-only) 227 -- Subscript of first character in Source_Text. Note that this cannot 228 -- be obtained as Source_Text'First, because we use virtual origin 229 -- addressing. 230 231 -- Source_Last : Source_Ptr; (read-only) 232 -- Subscript of last character in Source_Text. Note that this cannot 233 -- be obtained as Source_Text'Last, because we use virtual origin 234 -- addressing, so this value is always Source_Ptr'Last. 235 236 -- Time_Stamp : Time_Stamp_Type; (read-only) 237 -- Time stamp of the source file 238 239 -- Source_Checksum : Word; 240 -- Computed checksum for contents of source file. See separate section 241 -- later on in this spec for a description of the checksum algorithm. 242 243 -- Last_Source_Line : Physical_Line_Number; 244 -- Physical line number of last source line. While a file is being 245 -- read, this refers to the last line scanned. Once a file has been 246 -- completely scanned, it is the number of the last line in the file, 247 -- and hence also gives the number of source lines in the file. 248 249 -- Keyword_Casing : Casing_Type; 250 -- Casing style used in file for keyword casing. This is initialized 251 -- to Unknown, and then set from the first occurrence of a keyword. 252 -- This value is used only for formatting of error messages. 253 254 -- Identifier_Casing : Casing_Type; 255 -- Casing style used in file for identifier casing. This is initialized 256 -- to Unknown, and then set from an identifier in the program as soon as 257 -- one is found whose casing is sufficiently clear to make a decision. 258 -- This value is used for formatting of error messages, and also is used 259 -- in the detection of keywords misused as identifiers. 260 261 -- Inlined_Call : Source_Ptr; 262 -- Source file location of the subprogram call if this source file entry 263 -- represents an inlined body. Set to No_Location otherwise. 264 -- This field is read-only for clients. 265 266 -- Inlined_Body : Boolean; 267 -- This can only be set True if Instantiation has a value other than 268 -- No_Location. If true it indicates that the instantiation is actually 269 -- an instance of an inlined body. 270 -- ??? Redundant, always equal to (Inlined_Call /= No_Location) 271 272 -- Template : Source_File_Index; (read-only) 273 -- Source file index of the source file containing the template if this 274 -- is a generic instantiation. Set to No_Source_File for the normal case 275 -- of a non-instantiation entry. See Sinput-L for details. 276 277 -- Unit : Unit_Number_Type; 278 -- Identifies the unit contained in this source file. Set by 279 -- Initialize_Scanner, must not be subsequently altered. 280 281 -- The source file table is accessed by clients using the following 282 -- subprogram interface: 283 284 subtype SFI is Source_File_Index; 285 286 System_Source_File_Index : SFI; 287 -- The file system.ads is always read by the compiler to determine the 288 -- settings of the target parameters in the private part of System. This 289 -- variable records the source file index of system.ads. Typically this 290 -- will be 1 since system.ads is read first. 291 292 function Debug_Source_Name (S : SFI) return File_Name_Type; 293 function File_Name (S : SFI) return File_Name_Type; 294 function File_Type (S : SFI) return Type_Of_File; 295 function First_Mapped_Line (S : SFI) return Logical_Line_Number; 296 function Full_Debug_Name (S : SFI) return File_Name_Type; 297 function Full_File_Name (S : SFI) return File_Name_Type; 298 function Full_Ref_Name (S : SFI) return File_Name_Type; 299 function Identifier_Casing (S : SFI) return Casing_Type; 300 function Inlined_Body (S : SFI) return Boolean; 301 function Inlined_Call (S : SFI) return Source_Ptr; 302 function Instance (S : SFI) return Instance_Id; 303 function Keyword_Casing (S : SFI) return Casing_Type; 304 function Last_Source_Line (S : SFI) return Physical_Line_Number; 305 function License (S : SFI) return License_Type; 306 function Num_SRef_Pragmas (S : SFI) return Nat; 307 function Reference_Name (S : SFI) return File_Name_Type; 308 function Source_Checksum (S : SFI) return Word; 309 function Source_First (S : SFI) return Source_Ptr; 310 function Source_Last (S : SFI) return Source_Ptr; 311 function Source_Text (S : SFI) return Source_Buffer_Ptr; 312 function Template (S : SFI) return Source_File_Index; 313 function Unit (S : SFI) return Unit_Number_Type; 314 function Time_Stamp (S : SFI) return Time_Stamp_Type; 315 316 procedure Set_Keyword_Casing (S : SFI; C : Casing_Type); 317 procedure Set_Identifier_Casing (S : SFI; C : Casing_Type); 318 procedure Set_License (S : SFI; L : License_Type); 319 procedure Set_Unit (S : SFI; U : Unit_Number_Type); 320 321 function Last_Source_File return Source_File_Index; 322 -- Index of last source file table entry 323 324 function Num_Source_Files return Nat; 325 -- Number of source file table entries 326 327 procedure Initialize; 328 -- Initialize internal tables 329 330 procedure Lock; 331 -- Lock internal tables 332 333 procedure Unlock; 334 -- Unlock internal tables 335 336 Main_Source_File : Source_File_Index := No_Source_File; 337 -- This is set to the source file index of the main unit 338 339 ----------------------------- 340 -- Source_File_Index_Table -- 341 ----------------------------- 342 343 -- The Get_Source_File_Index function is called very frequently. Earlier 344 -- versions cached a single entry, but then reverted to a serial search, 345 -- and this proved to be a significant source of inefficiency. To get 346 -- around this, we use the following directly indexed array. The space 347 -- of possible input values is a value of type Source_Ptr which is simply 348 -- an Int value. The values in this space are allocated sequentially as 349 -- new units are loaded. 350 351 -- The following table has an entry for each 4K range of possible 352 -- Source_Ptr values. The value in the table is the lowest value 353 -- Source_File_Index whose Source_Ptr range contains value in the 354 -- range. 355 356 -- For example, the entry with index 4 in this table represents Source_Ptr 357 -- values in the range 4*4096 .. 5*4096-1. The Source_File_Index value 358 -- stored would be the lowest numbered source file with at least one byte 359 -- in this range. 360 361 -- The algorithm used in Get_Source_File_Index is simply to access this 362 -- table and then do a serial search starting at the given position. This 363 -- will almost always terminate with one or two checks. 364 365 -- Note that this array is pretty large, but in most operating systems 366 -- it will not be allocated in physical memory unless it is actually used. 367 368 Chunk_Power : constant := 12; 369 Chunk_Size : constant := 2 ** Chunk_Power; 370 -- Change comments above if value changed. Note that Chunk_Size must 371 -- be a power of 2 (to allow for efficient access to the table). 372 373 Source_File_Index_Table : 374 array (Int range 0 .. Int'Last / Chunk_Size) of Source_File_Index; 375 376 procedure Set_Source_File_Index_Table (Xnew : Source_File_Index); 377 -- Sets entries in the Source_File_Index_Table for the newly created 378 -- Source_File table entry whose index is Xnew. The Source_First and 379 -- Source_Last fields of this entry must be set before the call. 380 381 ----------------------- 382 -- Checksum Handling -- 383 ----------------------- 384 385 -- As a source file is scanned, a checksum is computed by taking all the 386 -- non-blank characters in the file, excluding comment characters, the 387 -- minus-minus sequence starting a comment, and all control characters 388 -- except ESC. 389 390 -- The checksum algorithm used is the standard CRC-32 algorithm, as 391 -- implemented by System.CRC32, except that we do not bother with the 392 -- final XOR with all 1 bits. 393 394 -- This algorithm ensures that the checksum includes all semantically 395 -- significant aspects of the program represented by the source file, 396 -- but is insensitive to layout, presence or contents of comments, wide 397 -- character representation method, or casing conventions outside strings. 398 399 -- Scans.Checksum is initialized appropriately at the start of scanning 400 -- a file, and copied into the Source_Checksum field of the file table 401 -- entry when the end of file is encountered. 402 403 ------------------------------------- 404 -- Handling Generic Instantiations -- 405 ------------------------------------- 406 407 -- As described in Sem_Ch12, a generic instantiation involves making a 408 -- copy of the tree of the generic template. The source locations in 409 -- this tree directly reference the source of the template. However it 410 -- is also possible to find the location of the instantiation. 411 412 -- This is achieved as follows. When an instantiation occurs, a new entry 413 -- is made in the source file table. This entry points to the same source 414 -- text, i.e. the file that contains the instantiation, but has a distinct 415 -- set of Source_Ptr index values. The separate range of Sloc values avoids 416 -- confusion, and means that the Sloc values can still be used to uniquely 417 -- identify the source file table entry. It is possible for both entries 418 -- to point to the same text, because of the virtual origin pointers used 419 -- in the source table. 420 421 -- The Instantiation_Id field of this source file index entry, set 422 -- to No_Instance_Id for normal entries, instead contains a value that 423 -- uniquely identifies a particular instantiation, and the associated 424 -- entry in the Instances table. The source location of the instantiation 425 -- can be retrieved using function Instantiation below. In the case of 426 -- nested instantiations, the Instances table can be used to trace the 427 -- complete chain of nested instantiations. 428 429 -- Two routines are used to build the special instance entries in the 430 -- source file table. Create_Instantiation_Source is first called to build 431 -- the virtual source table entry for the instantiation, and then the 432 -- Sloc values in the copy are adjusted using Adjust_Instantiation_Sloc. 433 -- See child unit Sinput.L for details on these two routines. 434 435 generic 436 with procedure Process (Id : Instance_Id; Inst_Sloc : Source_Ptr); 437 procedure Iterate_On_Instances; 438 -- Execute Process for each entry in the instance table 439 440 function Instantiation (S : SFI) return Source_Ptr; 441 -- For a source file entry that represents an inlined body, source location 442 -- of the inlined call. Otherwise, for a source file entry that represents 443 -- a generic instantiation, source location of the instantiation. Returns 444 -- No_Location in all other cases. 445 446 ----------------- 447 -- Global Data -- 448 ----------------- 449 450 Current_Source_File : Source_File_Index := No_Source_File; 451 -- Source_File table index of source file currently being scanned. 452 -- Initialized so that some tools (such as gprbuild) can be built with 453 -- -gnatVa and pragma Initialized_Scalars without problems. 454 455 Current_Source_Unit : Unit_Number_Type; 456 -- Unit number of source file currently being scanned. The special value 457 -- of No_Unit indicates that the configuration pragma file is currently 458 -- being scanned (this has no entry in the unit table). 459 460 Source_gnat_adc : Source_File_Index := No_Source_File; 461 -- This is set if a gnat.adc file is present to reference this file 462 463 Source : Source_Buffer_Ptr; 464 -- Current source (copy of Source_File.Table (Current_Source_Unit).Source) 465 466 Internal_Source : aliased Source_Buffer (1 .. 81); 467 -- This buffer is used internally in the compiler when the lexical analyzer 468 -- is used to scan a string from within the compiler. The procedure is to 469 -- establish Internal_Source_Ptr as the value of Source, set the string to 470 -- be scanned, appropriately terminated, in this buffer, and set Scan_Ptr 471 -- to point to the start of the buffer. It is a fatal error if the scanner 472 -- signals an error while scanning a token in this internal buffer. 473 474 Internal_Source_Ptr : constant Source_Buffer_Ptr := 475 Internal_Source'Unrestricted_Access; 476 -- Pointer to internal source buffer 477 478 ----------------------------------------- 479 -- Handling of Source Line Terminators -- 480 ----------------------------------------- 481 482 -- In this section we discuss in detail the issue of terminators used to 483 -- terminate source lines. The RM says that one or more format effectors 484 -- (other than horizontal tab) end a source line, and defines the set of 485 -- such format effectors, but does not talk about exactly how they are 486 -- represented in the source program (since in general the RM is not in 487 -- the business of specifying source program formats). 488 489 -- The type Types.Line_Terminator is defined as a subtype of Character 490 -- that includes CR/LF/VT/FF. The most common line enders in practice 491 -- are CR (some MAC systems), LF (Unix systems), and CR/LF (DOS/Windows 492 -- systems). Any of these sequences is recognized as ending a physical 493 -- source line, and if multiple such terminators appear (e.g. LF/LF), 494 -- then we consider we have an extra blank line. 495 496 -- VT and FF are recognized as terminating source lines, but they are 497 -- considered to end a logical line instead of a physical line, so that 498 -- the line numbering ignores such terminators. The use of VT and FF is 499 -- mandated by the standard, and correctly handled in a conforming manner 500 -- by GNAT, but their use is not recommended. 501 502 -- In addition to the set of characters defined by the type in Types, in 503 -- wide character encoding, then the codes returning True for a call to 504 -- System.UTF_32.Is_UTF_32_Line_Terminator are also recognized as ending a 505 -- source line. This includes the standard codes defined above in addition 506 -- to NEL (NEXT LINE), LINE SEPARATOR and PARAGRAPH SEPARATOR. Again, as in 507 -- the case of VT and FF, the standard requires we recognize these as line 508 -- terminators, but we consider them to be logical line terminators. The 509 -- only physical line terminators recognized are the standard ones (CR, 510 -- LF, or CR/LF). 511 512 -- However, we do not recognize the NEL (16#85#) character as having the 513 -- significance of an end of line character when operating in normal 8-bit 514 -- Latin-n input mode for the compiler. Instead the rule in this mode is 515 -- that all upper half control codes (16#80# .. 16#9F#) are illegal if they 516 -- occur in program text, and are ignored if they appear in comments. 517 518 -- First, note that this behavior is fully conforming with the standard. 519 -- The standard has nothing whatever to say about source representation 520 -- and implementations are completely free to make there own rules. In 521 -- this case, in 8-bit mode, GNAT decides that the 16#0085# character is 522 -- not a representation of the NEL character, even though it looks like it. 523 -- If you have NEL's in your program, which you expect to be treated as 524 -- end of line characters, you must use a wide character encoding such as 525 -- UTF-8 for this code to be recognized. 526 527 -- Second, an explanation of why we take this slightly surprising choice. 528 -- We have never encountered anyone actually using the NEL character to 529 -- end lines. One user raised the issue as a result of some experiments, 530 -- but no one has ever submitted a program encoded this way, in any of 531 -- the possible encodings. It seems that even when using wide character 532 -- codes extensively, the normal approach is to use standard line enders 533 -- (LF or CR/LF). So the failure to recognize NEL in this mode seems to 534 -- have no practical downside. 535 536 -- Moreover, what we have seen in a significant number of programs from 537 -- multiple sources is the practice of writing all program text in lower 538 -- half (ASCII) form, but using UTF-8 encoded wide characters freely in 539 -- comments, where the comments are terminated by normal line endings 540 -- (LF or CR/LF). The comments do not contain NEL codes, but they can and 541 -- do contain other UTF-8 encoding sequences where one of the bytes is the 542 -- NEL code. Now such programs can of course be compiled in UTF-8 mode, 543 -- but in practice they also compile fine in standard 8-bit mode without 544 -- specifying a character encoding. Since this is common practice, it would 545 -- be a signficant upwards incompatibility to recognize NEL in 8-bit mode. 546 547 ----------------- 548 -- Subprograms -- 549 ----------------- 550 551 procedure Backup_Line (P : in out Source_Ptr); 552 -- Back up the argument pointer to the start of the previous line. On 553 -- entry, P points to the start of a physical line in the source buffer. 554 -- On return, P is updated to point to the start of the previous line. 555 -- The caller has checked that a Line_Terminator character precedes P so 556 -- that there definitely is a previous line in the source buffer. 557 558 procedure Build_Location_String (Loc : Source_Ptr); 559 -- This function builds a string literal of the form "name:line", where 560 -- name is the file name corresponding to Loc, and line is the line number. 561 -- In the event that instantiations are involved, additional suffixes of 562 -- the same form are appended after the separating string " instantiated at 563 -- ". The returned string is appended to the Name_Buffer, terminated by 564 -- ASCII.NUL, with Name_Length indicating the length not including the 565 -- terminating Nul. 566 567 function Build_Location_String (Loc : Source_Ptr) return String; 568 -- Functional form returning a string, which does not include a terminating 569 -- null character. The contents of Name_Buffer is destroyed. 570 571 procedure Check_For_BOM; 572 -- Check if the current source starts with a BOM. Scan_Ptr needs to be at 573 -- the start of the current source. If the current source starts with a 574 -- recognized BOM, then some flags such as Wide_Character_Encoding_Method 575 -- are set accordingly, and the Scan_Ptr on return points past this BOM. 576 -- An error message is output and Unrecoverable_Error raised if a non- 577 -- recognized BOM is detected. The call has no effect if no BOM is found. 578 579 function Get_Column_Number (P : Source_Ptr) return Column_Number; 580 -- The ones-origin column number of the specified Source_Ptr value is 581 -- determined and returned. Tab characters if present are assumed to 582 -- represent the standard 1,9,17.. spacing pattern. 583 584 function Get_Logical_Line_Number 585 (P : Source_Ptr) return Logical_Line_Number; 586 -- The line number of the specified source position is obtained by 587 -- doing a binary search on the source positions in the lines table 588 -- for the unit containing the given source position. The returned 589 -- value is the logical line number, already adjusted for the effect 590 -- of source reference pragmas. If P refers to the line of a source 591 -- reference pragma itself, then No_Line is returned. If no source 592 -- reference pragmas have been encountered, the value returned is 593 -- the same as the physical line number. 594 595 function Get_Logical_Line_Number_Img 596 (P : Source_Ptr) return String; 597 -- Same as above function, but returns the line number as a string of 598 -- decimal digits, with no leading space. Destroys Name_Buffer. 599 600 function Get_Physical_Line_Number 601 (P : Source_Ptr) return Physical_Line_Number; 602 -- The line number of the specified source position is obtained by 603 -- doing a binary search on the source positions in the lines table 604 -- for the unit containing the given source position. The returned 605 -- value is the physical line number in the source being compiled. 606 607 function Get_Source_File_Index (S : Source_Ptr) return Source_File_Index; 608 -- Return file table index of file identified by given source pointer 609 -- value. This call must always succeed, since any valid source pointer 610 -- value belongs to some previously loaded source file. 611 612 function Instantiation_Depth (S : Source_Ptr) return Nat; 613 -- Determine instantiation depth for given Sloc value. A value of 614 -- zero means that the given Sloc is not in an instantiation. 615 616 function Line_Start (P : Source_Ptr) return Source_Ptr; 617 -- Finds the source position of the start of the line containing the 618 -- given source location. 619 620 function Line_Start 621 (L : Physical_Line_Number; 622 S : Source_File_Index) return Source_Ptr; 623 -- Finds the source position of the start of the given line in the 624 -- given source file, using a physical line number to identify the line. 625 626 function Num_Source_Lines (S : Source_File_Index) return Nat; 627 -- Returns the number of source lines (this is equivalent to reading 628 -- the value of Last_Source_Line, but returns Nat rather than a 629 -- physical line number. 630 631 procedure Register_Source_Ref_Pragma 632 (File_Name : File_Name_Type; 633 Stripped_File_Name : File_Name_Type; 634 Mapped_Line : Nat; 635 Line_After_Pragma : Physical_Line_Number); 636 -- Register a source reference pragma, the parameter File_Name is the 637 -- file name from the pragma, and Stripped_File_Name is this name with 638 -- the directory information stripped. Both these parameters are set 639 -- to No_Name if no file name parameter was given in the pragma. 640 -- (which can only happen for the second and subsequent pragmas). 641 -- Mapped_Line is the line number parameter from the pragma, and 642 -- Line_After_Pragma is the physical line number of the line that 643 -- follows the line containing the Source_Reference pragma. 644 645 function Original_Location (S : Source_Ptr) return Source_Ptr; 646 -- Given a source pointer S, returns the corresponding source pointer 647 -- value ignoring instantiation copies. For locations that do not 648 -- correspond to instantiation copies of templates, the argument is 649 -- returned unchanged. For locations that do correspond to copies of 650 -- templates from instantiations, the location within the original 651 -- template is returned. This is useful in canonicalizing locations. 652 653 function Instantiation_Location (S : Source_Ptr) return Source_Ptr; 654 pragma Inline (Instantiation_Location); 655 -- Given a source pointer S, returns the corresponding source pointer 656 -- value of the instantiation if this location is within an instance. 657 -- If S is not within an instance, then this returns No_Location. 658 659 function Top_Level_Location (S : Source_Ptr) return Source_Ptr; 660 -- Given a source pointer S, returns the argument unchanged if it is 661 -- not in an instantiation. If S is in an instantiation, then it returns 662 -- the location of the top level instantiation, i.e. the outer level 663 -- instantiation in the nested case. 664 665 function Physical_To_Logical 666 (Line : Physical_Line_Number; 667 S : Source_File_Index) return Logical_Line_Number; 668 -- Given a physical line number in source file whose source index is S, 669 -- return the corresponding logical line number. If the physical line 670 -- number is one containing a Source_Reference pragma, the result will 671 -- be No_Line_Number. 672 673 procedure Skip_Line_Terminators 674 (P : in out Source_Ptr; 675 Physical : out Boolean); 676 -- On entry, P points to a line terminator that has been encountered, 677 -- which is one of FF,LF,VT,CR or a wide character sequence whose value is 678 -- in category Separator,Line or Separator,Paragraph. P points just past 679 -- the character that was scanned. The purpose of this routine is to 680 -- distinguish physical and logical line endings. A physical line ending 681 -- is one of: 682 -- 683 -- CR on its own (MAC System 7) 684 -- LF on its own (Unix and unix-like systems) 685 -- CR/LF (DOS, Windows) 686 -- Wide character in Separator,Line or Separator,Paragraph category 687 -- 688 -- Note: we no longer recognize LF/CR (which we did in some earlier 689 -- versions of GNAT. The reason for this is that this sequence is not 690 -- used and recognizing it generated confusion. For example given the 691 -- sequence LF/CR/LF we were interpreting that as (LF/CR) ending the 692 -- first line and a blank line ending with CR following, but it is 693 -- clearly better to interpret this as LF, with a blank line terminated 694 -- by CR/LF, given that LF and CR/LF are both in common use, but no 695 -- system we know of uses LF/CR. 696 -- 697 -- A logical line ending (that is not a physical line ending) is one of: 698 -- 699 -- VT on its own 700 -- FF on its own 701 -- 702 -- On return, P is bumped past the line ending sequence (one of the above 703 -- seven possibilities). Physical is set to True to indicate that a 704 -- physical end of line was encountered, in which case this routine also 705 -- makes sure that the lines table for the current source file has an 706 -- appropriate entry for the start of the new physical line. 707 708 procedure Sloc_Range (N : Node_Id; Min, Max : out Source_Ptr); 709 -- Given a node, returns the minimum and maximum source locations of any 710 -- node in the syntactic subtree for the node. This is not quite the same 711 -- as the locations of the first and last token in the node construct 712 -- because parentheses at the outer level do not have a recorded Sloc. 713 -- 714 -- Note: if the tree for the expression contains no "real" Sloc values, 715 -- i.e. values > No_Location, then both Min and Max are set to Sloc (Expr). 716 717 function Source_Offset (S : Source_Ptr) return Nat; 718 -- Returns the zero-origin offset of the given source location from the 719 -- start of its corresponding unit. This is used for creating canonical 720 -- names in some situations. 721 722 procedure Write_Location (P : Source_Ptr); 723 -- Writes out a string of the form fff:nn:cc, where fff, nn, cc are the 724 -- file name, line number and column corresponding to the given source 725 -- location. No_Location and Standard_Location appear as the strings 726 -- <no location> and <standard location>. If the location is within an 727 -- instantiation, then the instance location is appended, enclosed in 728 -- square brackets (which can nest if necessary). Note that this routine 729 -- is used only for internal compiler debugging output purposes (which 730 -- is why the somewhat cryptic use of brackets is acceptable). 731 732 procedure wl (P : Source_Ptr); 733 pragma Export (Ada, wl); 734 -- Equivalent to Write_Location (P); Write_Eol; for calls from GDB 735 736 procedure Write_Time_Stamp (S : Source_File_Index); 737 -- Writes time stamp of specified file in YY-MM-DD HH:MM.SS format 738 739 procedure Tree_Read; 740 -- Initializes internal tables from current tree file using the relevant 741 -- Table.Tree_Read routines. 742 743 procedure Tree_Write; 744 -- Writes out internal tables to current tree file using the relevant 745 -- Table.Tree_Write routines. 746 747private 748 pragma Inline (File_Name); 749 pragma Inline (Full_File_Name); 750 pragma Inline (File_Type); 751 pragma Inline (Reference_Name); 752 pragma Inline (Full_Ref_Name); 753 pragma Inline (Debug_Source_Name); 754 pragma Inline (Full_Debug_Name); 755 pragma Inline (Instance); 756 pragma Inline (License); 757 pragma Inline (Num_SRef_Pragmas); 758 pragma Inline (First_Mapped_Line); 759 pragma Inline (Source_Text); 760 pragma Inline (Source_First); 761 pragma Inline (Source_Last); 762 pragma Inline (Time_Stamp); 763 pragma Inline (Source_Checksum); 764 pragma Inline (Last_Source_Line); 765 pragma Inline (Keyword_Casing); 766 pragma Inline (Identifier_Casing); 767 pragma Inline (Inlined_Call); 768 pragma Inline (Inlined_Body); 769 pragma Inline (Template); 770 pragma Inline (Unit); 771 772 pragma Inline (Set_Keyword_Casing); 773 pragma Inline (Set_Identifier_Casing); 774 775 pragma Inline (Last_Source_File); 776 pragma Inline (Num_Source_Files); 777 pragma Inline (Num_Source_Lines); 778 779 No_Instance_Id : constant Instance_Id := 0; 780 781 ------------------------- 782 -- Source_Lines Tables -- 783 ------------------------- 784 785 type Lines_Table_Type is 786 array (Physical_Line_Number) of Source_Ptr; 787 -- Type used for lines table. The entries are indexed by physical line 788 -- numbers. The values are the starting Source_Ptr values for the start 789 -- of the corresponding physical line. Note that we make this a bogus 790 -- big array, sized as required, so that we avoid the use of fat pointers. 791 792 type Lines_Table_Ptr is access all Lines_Table_Type; 793 -- Type used for pointers to line tables 794 795 type Logical_Lines_Table_Type is 796 array (Physical_Line_Number) of Logical_Line_Number; 797 -- Type used for logical lines table. This table is used if a source 798 -- reference pragma is present. It is indexed by physical line numbers, 799 -- and contains the corresponding logical line numbers. An entry that 800 -- corresponds to a source reference pragma is set to No_Line_Number. 801 -- Note that we make this a bogus big array, sized as required, so that 802 -- we avoid the use of fat pointers. 803 804 type Logical_Lines_Table_Ptr is access all Logical_Lines_Table_Type; 805 -- Type used for pointers to logical line tables 806 807 ----------------------- 808 -- Source_File Table -- 809 ----------------------- 810 811 -- See earlier descriptions for meanings of public fields 812 813 type Source_File_Record is record 814 File_Name : File_Name_Type; 815 Reference_Name : File_Name_Type; 816 Debug_Source_Name : File_Name_Type; 817 Full_Debug_Name : File_Name_Type; 818 Full_File_Name : File_Name_Type; 819 Full_Ref_Name : File_Name_Type; 820 Instance : Instance_Id; 821 Num_SRef_Pragmas : Nat; 822 First_Mapped_Line : Logical_Line_Number; 823 Source_Text : Source_Buffer_Ptr; 824 Source_First : Source_Ptr; 825 Source_Last : Source_Ptr; 826 Source_Checksum : Word; 827 Last_Source_Line : Physical_Line_Number; 828 Template : Source_File_Index; 829 Unit : Unit_Number_Type; 830 Time_Stamp : Time_Stamp_Type; 831 File_Type : Type_Of_File; 832 Inlined_Call : Source_Ptr; 833 Inlined_Body : Boolean; 834 License : License_Type; 835 Keyword_Casing : Casing_Type; 836 Identifier_Casing : Casing_Type; 837 838 -- The following fields are for internal use only (i.e. only in the 839 -- body of Sinput or its children, with no direct access by clients). 840 841 Sloc_Adjust : Source_Ptr; 842 -- A value to be added to Sloc values for this file to reference the 843 -- corresponding lines table. This is zero for the non-instantiation 844 -- case, and set so that the addition references the ultimate template 845 -- for the instantiation case. See Sinput-L for further details. 846 847 Lines_Table : Lines_Table_Ptr; 848 -- Pointer to lines table for this source. Updated as additional 849 -- lines are accessed using the Skip_Line_Terminators procedure. 850 -- Note: the lines table for an instantiation entry refers to the 851 -- original line numbers of the template see Sinput-L for details. 852 853 Logical_Lines_Table : Logical_Lines_Table_Ptr; 854 -- Pointer to logical lines table for this source. Non-null only if 855 -- a source reference pragma has been processed. Updated as lines 856 -- are accessed using the Skip_Line_Terminators procedure. 857 858 Lines_Table_Max : Physical_Line_Number; 859 -- Maximum subscript values for currently allocated Lines_Table 860 -- and (if present) the allocated Logical_Lines_Table. The value 861 -- Max_Source_Line gives the maximum used value, this gives the 862 -- maximum allocated value. 863 864 end record; 865 866 -- The following representation clause ensures that the above record 867 -- has no holes. We do this so that when instances of this record are 868 -- written by Tree_Gen, we do not write uninitialized values to the file. 869 870 AS : constant Pos := Standard'Address_Size; 871 872 for Source_File_Record use record 873 File_Name at 0 range 0 .. 31; 874 Reference_Name at 4 range 0 .. 31; 875 Debug_Source_Name at 8 range 0 .. 31; 876 Full_Debug_Name at 12 range 0 .. 31; 877 Full_File_Name at 16 range 0 .. 31; 878 Full_Ref_Name at 20 range 0 .. 31; 879 Instance at 48 range 0 .. 31; 880 Num_SRef_Pragmas at 24 range 0 .. 31; 881 First_Mapped_Line at 28 range 0 .. 31; 882 Source_First at 32 range 0 .. 31; 883 Source_Last at 36 range 0 .. 31; 884 Source_Checksum at 40 range 0 .. 31; 885 Last_Source_Line at 44 range 0 .. 31; 886 Template at 52 range 0 .. 31; 887 Unit at 56 range 0 .. 31; 888 Time_Stamp at 60 range 0 .. 8 * Time_Stamp_Length - 1; 889 File_Type at 74 range 0 .. 7; 890 Inlined_Call at 88 range 0 .. 31; 891 Inlined_Body at 75 range 0 .. 7; 892 License at 76 range 0 .. 7; 893 Keyword_Casing at 77 range 0 .. 7; 894 Identifier_Casing at 78 range 0 .. 15; 895 Sloc_Adjust at 80 range 0 .. 31; 896 Lines_Table_Max at 84 range 0 .. 31; 897 898 -- The following fields are pointers, so we have to specialize their 899 -- lengths using pointer size, obtained above as Standard'Address_Size. 900 901 Source_Text at 92 range 0 .. AS - 1; 902 Lines_Table at 92 range AS .. AS * 2 - 1; 903 Logical_Lines_Table at 92 range AS * 2 .. AS * 3 - 1; 904 end record; 905 906 for Source_File_Record'Size use 92 * 8 + AS * 3; 907 -- This ensures that we did not leave out any fields 908 909 package Source_File is new Table.Table ( 910 Table_Component_Type => Source_File_Record, 911 Table_Index_Type => Source_File_Index, 912 Table_Low_Bound => 1, 913 Table_Initial => Alloc.Source_File_Initial, 914 Table_Increment => Alloc.Source_File_Increment, 915 Table_Name => "Source_File"); 916 917 -- Auxiliary table containing source location of instantiations. Index 0 918 -- is used for code that does not come from an instance. 919 920 package Instances is new Table.Table ( 921 Table_Component_Type => Source_Ptr, 922 Table_Index_Type => Instance_Id, 923 Table_Low_Bound => 0, 924 Table_Initial => Alloc.Source_File_Initial, 925 Table_Increment => Alloc.Source_File_Increment, 926 Table_Name => "Instances"); 927 928 ----------------- 929 -- Subprograms -- 930 ----------------- 931 932 procedure Alloc_Line_Tables 933 (S : in out Source_File_Record; 934 New_Max : Nat); 935 -- Allocate or reallocate the lines table for the given source file so 936 -- that it can accommodate at least New_Max lines. Also allocates or 937 -- reallocates logical lines table if source ref pragmas are present. 938 939 procedure Add_Line_Tables_Entry 940 (S : in out Source_File_Record; 941 P : Source_Ptr); 942 -- Increment line table size by one (reallocating the lines table if 943 -- needed) and set the new entry to contain the value P. Also bumps 944 -- the Source_Line_Count field. If source reference pragmas are 945 -- present, also increments logical lines table size by one, and 946 -- sets new entry. 947 948 procedure Trim_Lines_Table (S : Source_File_Index); 949 -- Set lines table size for entry S in the source file table to 950 -- correspond to the current value of Num_Source_Lines, releasing 951 -- any unused storage. This is used by Sinput.L and Sinput.D. 952 953end Sinput; 954