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