|
111
|
1 ------------------------------------------------------------------------------
|
|
|
2 -- --
|
|
|
3 -- GNAT COMPILER COMPONENTS --
|
|
|
4 -- --
|
|
|
5 -- O S I N T --
|
|
|
6 -- --
|
|
|
7 -- S p e c --
|
|
|
8 -- --
|
|
|
9 -- Copyright (C) 1992-2017, 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. See the GNU General Public License --
|
|
|
17 -- for more details. You should have received a copy of the GNU General --
|
|
|
18 -- Public License distributed with GNAT; see file COPYING3. If not, go to --
|
|
|
19 -- http://www.gnu.org/licenses for a complete copy of the license. --
|
|
|
20 -- --
|
|
|
21 -- GNAT was originally developed by the GNAT team at New York University. --
|
|
|
22 -- Extensive contributions were provided by Ada Core Technologies Inc. --
|
|
|
23 -- --
|
|
|
24 ------------------------------------------------------------------------------
|
|
|
25
|
|
|
26 -- This package contains the low level, operating system routines used in the
|
|
|
27 -- compiler and binder for command line processing and file input output.
|
|
|
28
|
|
|
29 with Namet; use Namet;
|
|
|
30 with Types; use Types;
|
|
|
31
|
|
|
32 with System; use System;
|
|
|
33
|
|
|
34 pragma Warnings (Off);
|
|
|
35 -- This package is used also by gnatcoll
|
|
|
36 with System.OS_Lib; use System.OS_Lib;
|
|
|
37 pragma Warnings (On);
|
|
|
38
|
|
|
39 with System.Storage_Elements;
|
|
|
40
|
|
|
41 pragma Elaborate_All (System.OS_Lib);
|
|
|
42 -- For the call to function Get_Target_Object_Suffix in the private part
|
|
|
43
|
|
|
44 package Osint is
|
|
|
45
|
|
|
46 Multi_Unit_Index_Character : constant Character := '~';
|
|
|
47 -- The character before the index of the unit in a multi-unit source in ALI
|
|
|
48 -- and object file names.
|
|
|
49
|
|
|
50 Ada_Include_Path : constant String := "ADA_INCLUDE_PATH";
|
|
|
51 Ada_Objects_Path : constant String := "ADA_OBJECTS_PATH";
|
|
|
52 Project_Include_Path_File : constant String := "ADA_PRJ_INCLUDE_FILE";
|
|
|
53 Project_Objects_Path_File : constant String := "ADA_PRJ_OBJECTS_FILE";
|
|
|
54
|
|
|
55 Output_FD : File_Descriptor;
|
|
|
56 -- File descriptor for current library info, list, tree, C, H, or binder
|
|
|
57 -- output. Only one of these is open at a time, so we need only one FD.
|
|
|
58
|
|
|
59 procedure Initialize;
|
|
|
60 -- Initialize internal tables
|
|
|
61
|
|
|
62 function Normalize_Directory_Name (Directory : String) return String_Ptr;
|
|
|
63 -- Verify and normalize a directory name. If directory name is invalid,
|
|
|
64 -- this will return an empty string. Otherwise it will insure a trailing
|
|
|
65 -- slash and make other normalizations.
|
|
|
66
|
|
|
67 type File_Type is (Source, Library, Config, Definition, Preprocessing_Data);
|
|
|
68
|
|
|
69 function Find_File
|
|
|
70 (N : File_Name_Type;
|
|
|
71 T : File_Type;
|
|
|
72 Full_Name : Boolean := False) return File_Name_Type;
|
|
|
73 -- Finds a source, library or config file depending on the value of T
|
|
|
74 -- following the directory search order rules unless N is the name of the
|
|
|
75 -- file just read with Next_Main_File and already contains directory
|
|
|
76 -- information, in which case just look in the Primary_Directory. Returns
|
|
|
77 -- File_Name_Type of the full file name if found, No_File if file not
|
|
|
78 -- found. Note that for the special case of gnat.adc, only the compilation
|
|
|
79 -- environment directory is searched, i.e. the directory where the ali and
|
|
|
80 -- object files are written. Another special case is Debug_Generated_Code
|
|
|
81 -- set and the file name ends in ".dg", in which case we look for the
|
|
|
82 -- generated file only in the current directory, since that is where it is
|
|
|
83 -- always built.
|
|
|
84 --
|
|
|
85 -- In the case of configuration files, full path names are needed for some
|
|
|
86 -- ASIS queries. The flag Full_Name indicates that the name of the file
|
|
|
87 -- should be normalized to include a full path.
|
|
|
88
|
|
|
89 function Get_File_Names_Case_Sensitive return Int;
|
|
|
90 pragma Import (C, Get_File_Names_Case_Sensitive,
|
|
|
91 "__gnat_get_file_names_case_sensitive");
|
|
|
92 File_Names_Case_Sensitive : constant Boolean :=
|
|
|
93 Get_File_Names_Case_Sensitive /= 0;
|
|
|
94 -- Set to indicate whether the operating system convention is for file
|
|
|
95 -- names to be case sensitive (e.g., in Unix, set True), or non case
|
|
|
96 -- sensitive (e.g., in Windows, set False).
|
|
|
97
|
|
|
98 procedure Canonical_Case_File_Name (S : in out String);
|
|
|
99 -- Given a file name, converts it to canonical case form. For systems
|
|
|
100 -- where file names are case sensitive, this procedure has no effect.
|
|
|
101 -- If file names are not case sensitive (i.e. for example if you have
|
|
|
102 -- the file "xyz.adb", you can refer to it as XYZ.adb or XyZ.AdB), then
|
|
|
103 -- this call converts the given string to canonical all lower case form,
|
|
|
104 -- so that two file names compare equal if they refer to the same file.
|
|
|
105
|
|
|
106 function Get_Env_Vars_Case_Sensitive return Int;
|
|
|
107 pragma Import (C, Get_Env_Vars_Case_Sensitive,
|
|
|
108 "__gnat_get_env_vars_case_sensitive");
|
|
|
109 Env_Vars_Case_Sensitive : constant Boolean :=
|
|
|
110 Get_Env_Vars_Case_Sensitive /= 0;
|
|
|
111 -- Set to indicate whether the operating system convention is for
|
|
|
112 -- environment variable names to be case sensitive (e.g., in Unix, set
|
|
|
113 -- True), or non case sensitive (e.g., in Windows, set False).
|
|
|
114
|
|
|
115 procedure Canonical_Case_Env_Var_Name (S : in out String);
|
|
|
116 -- Given an environment variable name, converts it to canonical case form.
|
|
|
117 -- For systems where environment variable names are case sensitive, this
|
|
|
118 -- procedure has no effect. If environment variable names are not case
|
|
|
119 -- sensitive, then this call converts the given string to canonical all
|
|
|
120 -- lower case form, so that two environment variable names compare equal if
|
|
|
121 -- they refer to the same environment variable.
|
|
|
122
|
|
|
123 function Number_Of_Files return Nat;
|
|
|
124 -- Gives the total number of filenames found on the command line
|
|
|
125
|
|
|
126 No_Index : constant := -1;
|
|
|
127 -- Value used in Add_File to indicate no index is specified for main
|
|
|
128
|
|
|
129 procedure Add_File (File_Name : String; Index : Int := No_Index);
|
|
|
130 -- Called by the subprogram processing the command line for each file name
|
|
|
131 -- found. The index, when not defaulted to No_Index is the index of the
|
|
|
132 -- subprogram in its source, zero indicating that the source is not
|
|
|
133 -- multi-unit.
|
|
|
134
|
|
|
135 procedure Find_Program_Name;
|
|
|
136 -- Put simple name of current program being run (excluding the directory
|
|
|
137 -- path) in Name_Buffer, with the length in Name_Len.
|
|
|
138
|
|
|
139 function Program_Name (Nam : String; Prog : String) return String_Access;
|
|
|
140 -- In the native compilation case, Create a string containing Nam. In the
|
|
|
141 -- cross compilation case, looks at the prefix of the current program being
|
|
|
142 -- run and prepend it to Nam. For instance if the program being run is
|
|
|
143 -- <target>-gnatmake and Nam is "gcc", the returned value will be a pointer
|
|
|
144 -- to "<target>-gcc". In the specific case where AAMP_On_Target is set, the
|
|
|
145 -- name "gcc" is mapped to "gnaamp", and names of the form "gnat*" are
|
|
|
146 -- mapped to "gnaamp*". This function clobbers Name_Buffer and Name_Len.
|
|
|
147 -- Also look at any suffix, e.g. gnatmake-4.1 -> "gcc-4.1". Prog is the
|
|
|
148 -- default name of the current program being executed, e.g. "gnatmake",
|
|
|
149 -- "gnatlink".
|
|
|
150
|
|
|
151 procedure Write_Program_Name;
|
|
|
152 -- Writes name of program as invoked to the current output (normally
|
|
|
153 -- standard output).
|
|
|
154
|
|
|
155 procedure Fail (S : String);
|
|
|
156 pragma No_Return (Fail);
|
|
|
157 -- Outputs error message S preceded by the name of the executing program
|
|
|
158 -- and exits with E_Fatal. The output goes to standard error, except if
|
|
|
159 -- special output is in effect (see Output).
|
|
|
160
|
|
|
161 function Is_Directory_Separator (C : Character) return Boolean;
|
|
|
162 -- Returns True if C is a directory separator
|
|
|
163
|
|
|
164 function Get_Directory (Name : File_Name_Type) return File_Name_Type;
|
|
|
165 -- Get the prefix directory name (if any) from Name. The last separator
|
|
|
166 -- is preserved. Return the normalized current directory if there is no
|
|
|
167 -- directory part in the name.
|
|
|
168
|
|
|
169 function Is_Readonly_Library (File : File_Name_Type) return Boolean;
|
|
|
170 -- Check if this library file is a read-only file
|
|
|
171
|
|
|
172 function Strip_Directory (Name : File_Name_Type) return File_Name_Type;
|
|
|
173 -- Strips the prefix directory name (if any) from Name. Returns the
|
|
|
174 -- stripped name. Name cannot end with a directory separator.
|
|
|
175
|
|
|
176 function Strip_Suffix (Name : File_Name_Type) return File_Name_Type;
|
|
|
177 -- Strips the suffix (the last '.' and whatever comes after it) from Name.
|
|
|
178 -- Returns the stripped name.
|
|
|
179
|
|
|
180 function Executable_Name
|
|
|
181 (Name : File_Name_Type;
|
|
|
182 Only_If_No_Suffix : Boolean := False) return File_Name_Type;
|
|
|
183 -- Given a file name it adds the appropriate suffix at the end so that
|
|
|
184 -- it becomes the name of the executable on the system at end. For
|
|
|
185 -- instance under DOS it adds the ".exe" suffix, whereas under UNIX no
|
|
|
186 -- suffix is added.
|
|
|
187
|
|
|
188 function Executable_Name
|
|
|
189 (Name : String;
|
|
|
190 Only_If_No_Suffix : Boolean := False) return String;
|
|
|
191 -- Same as above, with String parameters
|
|
|
192
|
|
|
193 function File_Stamp (Name : File_Name_Type) return Time_Stamp_Type;
|
|
|
194 -- Returns the time stamp of file Name. Name should include relative path
|
|
|
195 -- information in order to locate it. If the source file cannot be opened,
|
|
|
196 -- or Name = No_File, and all blank time stamp is returned (this is not an
|
|
|
197 -- error situation).
|
|
|
198
|
|
|
199 function File_Stamp (Name : Path_Name_Type) return Time_Stamp_Type;
|
|
|
200 -- Same as above for a path name
|
|
|
201
|
|
|
202 type String_Access_List is array (Positive range <>) of String_Access;
|
|
|
203 -- Dereferenced type used to return a list of file specs in
|
|
|
204 -- To_Canonical_File_List.
|
|
|
205
|
|
|
206 type String_Access_List_Access is access all String_Access_List;
|
|
|
207 -- Type used to return a String_Access_List without dragging in secondary
|
|
|
208 -- stack.
|
|
|
209
|
|
|
210 function To_Canonical_File_List
|
|
|
211 (Wildcard_Host_File : String;
|
|
|
212 Only_Dirs : Boolean) return String_Access_List_Access;
|
|
|
213 -- Expand a wildcard host syntax file or directory specification and return
|
|
|
214 -- a list of valid Unix syntax file or directory specs. If Only_Dirs is
|
|
|
215 -- True, then only return directories.
|
|
|
216
|
|
|
217 function To_Host_Dir_Spec
|
|
|
218 (Canonical_Dir : String;
|
|
|
219 Prefix_Style : Boolean) return String_Access;
|
|
|
220 -- Convert a canonical syntax directory specification to host syntax. The
|
|
|
221 -- Prefix_Style flag is currently ignored but should be set to False.
|
|
|
222 -- Note that the caller must free result.
|
|
|
223
|
|
|
224 function To_Host_File_Spec
|
|
|
225 (Canonical_File : String) return String_Access;
|
|
|
226 -- Convert a canonical syntax file specification to host syntax
|
|
|
227
|
|
|
228 function Relocate_Path
|
|
|
229 (Prefix : String;
|
|
|
230 Path : String) return String_Ptr;
|
|
|
231 -- Given an absolute path and a prefix, if Path starts with Prefix,
|
|
|
232 -- replace the Prefix substring with the root installation directory.
|
|
|
233 -- By default, try to compute the root installation directory by looking
|
|
|
234 -- at the executable name as it was typed on the command line and, if
|
|
|
235 -- needed, use the PATH environment variable. If the above computation
|
|
|
236 -- fails, return Path. This function assumes Prefix'First = Path'First.
|
|
|
237
|
|
|
238 function Shared_Lib (Name : String) return String;
|
|
|
239 -- Returns the runtime shared library in the form -l<name>-<version> where
|
|
|
240 -- version is the GNAT runtime library option for the platform. For example
|
|
|
241 -- this routine called with Name set to "gnat" will return "-lgnat-5.02"
|
|
|
242 -- on UNIX and Windows.
|
|
|
243
|
|
|
244 ---------------------
|
|
|
245 -- File attributes --
|
|
|
246 ---------------------
|
|
|
247
|
|
|
248 -- The following subprograms offer services similar to those found in
|
|
|
249 -- System.OS_Lib, but with the ability to extra multiple information from
|
|
|
250 -- a single system call, depending on the system. This can result in fewer
|
|
|
251 -- system calls when reused.
|
|
|
252
|
|
|
253 -- In all these subprograms, the requested value is either read from the
|
|
|
254 -- File_Attributes parameter (resulting in no system call), or computed
|
|
|
255 -- from the disk and then cached in the File_Attributes parameter (possibly
|
|
|
256 -- along with other values).
|
|
|
257
|
|
|
258 type File_Attributes is private;
|
|
|
259 Unknown_Attributes : constant File_Attributes;
|
|
|
260 -- A cache for various attributes for a file (length, accessibility,...)
|
|
|
261 -- This must be initialized to Unknown_Attributes prior to the first call.
|
|
|
262
|
|
|
263 function Is_Directory
|
|
|
264 (Name : C_File_Name;
|
|
|
265 Attr : access File_Attributes) return Boolean;
|
|
|
266 function Is_Regular_File
|
|
|
267 (Name : C_File_Name;
|
|
|
268 Attr : access File_Attributes) return Boolean;
|
|
|
269 function Is_Symbolic_Link
|
|
|
270 (Name : C_File_Name;
|
|
|
271 Attr : access File_Attributes) return Boolean;
|
|
|
272 -- Return the type of the file,
|
|
|
273
|
|
|
274 function File_Length
|
|
|
275 (Name : C_File_Name;
|
|
|
276 Attr : access File_Attributes) return Long_Integer;
|
|
|
277 -- Return the length (number of bytes) of the file
|
|
|
278
|
|
|
279 function File_Time_Stamp
|
|
|
280 (Name : C_File_Name;
|
|
|
281 Attr : access File_Attributes) return OS_Time;
|
|
|
282 function File_Time_Stamp
|
|
|
283 (Name : Path_Name_Type;
|
|
|
284 Attr : access File_Attributes) return Time_Stamp_Type;
|
|
|
285 -- Return the time stamp of the file
|
|
|
286
|
|
|
287 function Is_Readable_File
|
|
|
288 (Name : C_File_Name;
|
|
|
289 Attr : access File_Attributes) return Boolean;
|
|
|
290 function Is_Executable_File
|
|
|
291 (Name : C_File_Name;
|
|
|
292 Attr : access File_Attributes) return Boolean;
|
|
|
293 function Is_Writable_File
|
|
|
294 (Name : C_File_Name;
|
|
|
295 Attr : access File_Attributes) return Boolean;
|
|
|
296 -- Return the access rights for the file
|
|
|
297
|
|
|
298 -------------------------
|
|
|
299 -- Search Dir Routines --
|
|
|
300 -------------------------
|
|
|
301
|
|
|
302 function Include_Dir_Default_Prefix return String;
|
|
|
303 -- Return the directory of the run-time library sources, as modified
|
|
|
304 -- by update_path.
|
|
|
305
|
|
|
306 function Object_Dir_Default_Prefix return String;
|
|
|
307 -- Return the directory of the run-time library ALI and object files, as
|
|
|
308 -- modified by update_path.
|
|
|
309
|
|
|
310 procedure Add_Default_Search_Dirs;
|
|
|
311 -- This routine adds the default search dirs indicated by the environment
|
|
|
312 -- variables and sdefault package, as well as the library search dirs set
|
|
|
313 -- by option -gnateO for GNAT2WHY.
|
|
|
314
|
|
|
315 procedure Add_Lib_Search_Dir (Dir : String);
|
|
|
316 -- Add Dir at the end of the library file search path
|
|
|
317
|
|
|
318 procedure Add_Src_Search_Dir (Dir : String);
|
|
|
319 -- Add Dir at the end of the source file search path
|
|
|
320
|
|
|
321 procedure Get_Next_Dir_In_Path_Init
|
|
|
322 (Search_Path : String_Access);
|
|
|
323 function Get_Next_Dir_In_Path
|
|
|
324 (Search_Path : String_Access) return String_Access;
|
|
|
325 -- These subprograms are used to parse out the directory names in a search
|
|
|
326 -- path specified by a Search_Path argument. The procedure initializes an
|
|
|
327 -- internal pointer to point to the initial directory name, and calls to
|
|
|
328 -- the function return successive directory names, with a null pointer
|
|
|
329 -- marking the end of the list.
|
|
|
330
|
|
|
331 type Search_File_Type is (Include, Objects);
|
|
|
332
|
|
|
333 procedure Add_Search_Dirs
|
|
|
334 (Search_Path : String_Ptr;
|
|
|
335 Path_Type : Search_File_Type);
|
|
|
336 -- These procedure adds all the search directories that are in Search_Path
|
|
|
337 -- in the proper file search path (library or source)
|
|
|
338
|
|
|
339 function Get_Primary_Src_Search_Directory return String_Ptr;
|
|
|
340 -- Retrieved the primary directory (directory containing the main source
|
|
|
341 -- file for Gnatmake.
|
|
|
342
|
|
|
343 function Nb_Dir_In_Src_Search_Path return Natural;
|
|
|
344 function Dir_In_Src_Search_Path (Position : Natural) return String_Ptr;
|
|
|
345 -- Functions to access the directory names in the source search path
|
|
|
346
|
|
|
347 function Nb_Dir_In_Obj_Search_Path return Natural;
|
|
|
348 function Dir_In_Obj_Search_Path (Position : Natural) return String_Ptr;
|
|
|
349 -- Functions to access the directory names in the Object search path
|
|
|
350
|
|
|
351 Include_Search_File : constant String_Access :=
|
|
|
352 new String'("ada_source_path");
|
|
|
353 Objects_Search_File : constant String_Access :=
|
|
|
354 new String'("ada_object_path");
|
|
|
355 -- Names of the files containing the default include or objects search
|
|
|
356 -- directories. These files, located in Sdefault.Search_Dir_Prefix, do
|
|
|
357 -- not necessarily exist.
|
|
|
358
|
|
|
359 Exec_Name : String_Ptr;
|
|
|
360 -- Executable name as typed by the user (used to compute the
|
|
|
361 -- executable prefix).
|
|
|
362
|
|
|
363 function Read_Default_Search_Dirs
|
|
|
364 (Search_Dir_Prefix : String_Access;
|
|
|
365 Search_File : String_Access;
|
|
|
366 Search_Dir_Default_Name : String_Access) return String_Access;
|
|
|
367 -- Read and return the default search directories from the file located
|
|
|
368 -- in Search_Dir_Prefix (as modified by update_path) and named Search_File.
|
|
|
369 -- If no such file exists or an error occurs then instead return the
|
|
|
370 -- Search_Dir_Default_Name (as modified by update_path).
|
|
|
371
|
|
|
372 function Get_RTS_Search_Dir
|
|
|
373 (Search_Dir : String;
|
|
|
374 File_Type : Search_File_Type) return String_Ptr;
|
|
|
375 -- This function retrieves the paths to the search (resp. lib) dirs and
|
|
|
376 -- return them. The search dir can be absolute or relative. If the search
|
|
|
377 -- dir contains Include_Search_File (resp. Object_Search_File), then this
|
|
|
378 -- function reads and returns the default search directories from the file.
|
|
|
379 -- Otherwise, if the directory is absolute, it will try to find 'adalib'
|
|
|
380 -- (resp. 'adainclude'). If found, null is returned. If the directory is
|
|
|
381 -- relative, the following directories for the directories 'adalib' and
|
|
|
382 -- 'adainclude' will be scanned:
|
|
|
383 --
|
|
|
384 -- - current directory (from which the tool has been spawned)
|
|
|
385 -- - $GNAT_ROOT/gcc/gcc-lib/$targ/$vers/
|
|
|
386 -- - $GNAT_ROOT/gcc/gcc-lib/$targ/$vers/rts-
|
|
|
387 --
|
|
|
388 -- The scan will stop as soon as the directory being searched for (adalib
|
|
|
389 -- or adainclude) is found. If the scan fails, null is returned.
|
|
|
390
|
|
|
391 -----------------------
|
|
|
392 -- Source File Input --
|
|
|
393 -----------------------
|
|
|
394
|
|
|
395 -- Source file input routines are used by the compiler to read the main
|
|
|
396 -- source files and the subsidiary source files (e.g. with'ed units), and
|
|
|
397 -- also by the binder to check presence/time stamps of sources.
|
|
|
398
|
|
|
399 procedure Read_Source_File
|
|
|
400 (N : File_Name_Type;
|
|
|
401 Lo : Source_Ptr;
|
|
|
402 Hi : out Source_Ptr;
|
|
|
403 Src : out Source_Buffer_Ptr;
|
|
|
404 FD : out File_Descriptor;
|
|
|
405 T : File_Type := Source);
|
|
|
406 -- Allocates a Source_Buffer of appropriate length and then reads the
|
|
|
407 -- entire contents of the source file N into the buffer. The address of
|
|
|
408 -- the allocated buffer is returned in Src. FD is used for extended error
|
|
|
409 -- information in the case the read fails.
|
|
|
410 --
|
|
|
411 -- Each line of text is terminated by one of the sequences:
|
|
|
412 --
|
|
|
413 -- CR
|
|
|
414 -- CR/LF
|
|
|
415 -- LF
|
|
|
416
|
|
|
417 -- The source is terminated by an EOF (16#1A#) character, which is the last
|
|
|
418 -- character of the returned source buffer (note that any EOF characters in
|
|
|
419 -- positions other than the last source character are treated as blanks).
|
|
|
420 --
|
|
|
421 -- The logical lower bound of the source buffer is the input value of Lo,
|
|
|
422 -- and on exit Hi is set to the logical upper bound of the source buffer,
|
|
|
423 -- which is redundant with Src'Last.
|
|
|
424 --
|
|
|
425 -- If the given file cannot be opened, then the action depends on whether
|
|
|
426 -- this file is the current main unit (i.e. its name matches the name
|
|
|
427 -- returned by the most recent call to Next_Main_Source). If so, then the
|
|
|
428 -- failure to find the file is a fatal error, an error message is output,
|
|
|
429 -- and program execution is terminated. Otherwise (for the case of a
|
|
|
430 -- subsidiary source loaded directly or indirectly using with), a file
|
|
|
431 -- not found condition causes null to be set as the result value and a
|
|
|
432 -- value of No_Source_File (0) to be set as the FD value. In the related
|
|
|
433 -- case of a file with no read permissions the result is the same except FD
|
|
|
434 -- is set to No_Access_To_Source_File (-1). Upon success FD is set to a
|
|
|
435 -- positive Source_File_Index.
|
|
|
436 --
|
|
|
437 -- Note that the name passed to this function is the simple file name,
|
|
|
438 -- without any directory information. The implementation is responsible
|
|
|
439 -- for searching for the file in the appropriate directories.
|
|
|
440 --
|
|
|
441 -- Note the special case that if the file name is gnat.adc, then the search
|
|
|
442 -- for the file is done ONLY in the directory corresponding to the current
|
|
|
443 -- compilation environment, i.e. in the same directory where the ali and
|
|
|
444 -- object files will be written.
|
|
|
445
|
|
|
446 function Full_Source_Name return File_Name_Type;
|
|
|
447 function Current_Source_File_Stamp return Time_Stamp_Type;
|
|
|
448 -- Returns the full name/time stamp of the source file most recently read
|
|
|
449 -- using Read_Source_File. Calling this routine entails no source file
|
|
|
450 -- directory lookup penalty.
|
|
|
451
|
|
|
452 procedure Full_Source_Name
|
|
|
453 (N : File_Name_Type;
|
|
|
454 Full_File : out File_Name_Type;
|
|
|
455 Attr : access File_Attributes);
|
|
|
456 function Full_Source_Name (N : File_Name_Type) return File_Name_Type;
|
|
|
457 function Source_File_Stamp (N : File_Name_Type) return Time_Stamp_Type;
|
|
|
458 -- Returns the full name/time stamp of the source file whose simple name
|
|
|
459 -- is N which should not include path information. Note that if the file
|
|
|
460 -- cannot be located No_File is returned for the first routine and an all
|
|
|
461 -- blank time stamp is returned for the second (this is not an error
|
|
|
462 -- situation). The full name includes appropriate directory information.
|
|
|
463 -- The source file directory lookup penalty is incurred every single time
|
|
|
464 -- the routines are called unless you have previously called
|
|
|
465 -- Source_File_Data (Cache => True). See below.
|
|
|
466 --
|
|
|
467 -- The procedural version also returns some file attributes for the ALI
|
|
|
468 -- file (to save on system calls later on).
|
|
|
469
|
|
|
470 function Current_File_Index return Int;
|
|
|
471 -- Return the index in its source file of the current main unit
|
|
|
472
|
|
|
473 function Matching_Full_Source_Name
|
|
|
474 (N : File_Name_Type;
|
|
|
475 T : Time_Stamp_Type) return File_Name_Type;
|
|
|
476 -- Same semantics than Full_Source_Name but will search on the source path
|
|
|
477 -- until a source file with time stamp matching T is found. If none is
|
|
|
478 -- found returns No_File.
|
|
|
479
|
|
|
480 procedure Source_File_Data (Cache : Boolean);
|
|
|
481 -- By default source file data (full source file name and time stamp)
|
|
|
482 -- are looked up every time a call to Full_Source_Name (N) or
|
|
|
483 -- Source_File_Stamp (N) is made. This may be undesirable in certain
|
|
|
484 -- applications as this is uselessly slow if source file data does not
|
|
|
485 -- change during program execution. When this procedure is called with
|
|
|
486 -- Cache => True access to source file data does not incur a penalty if
|
|
|
487 -- this data was previously retrieved.
|
|
|
488
|
|
|
489 procedure Dump_Source_File_Names;
|
|
|
490 -- Prints out the names of all source files that have been read by
|
|
|
491 -- Read_Source_File, except those that come from the run-time library
|
|
|
492 -- (i.e. Include_Dir_Default_Prefix). The text is sent to whatever Output
|
|
|
493 -- is currently using (e.g. standard output or standard error).
|
|
|
494
|
|
|
495 -------------------------------------------
|
|
|
496 -- Representation of Library Information --
|
|
|
497 -------------------------------------------
|
|
|
498
|
|
|
499 -- Associated with each compiled source file is library information, a
|
|
|
500 -- string of bytes whose exact format is described in the body of Lib.Writ.
|
|
|
501 -- Compiling a source file generates this library information for the
|
|
|
502 -- compiled unit, and access the library information for units that were
|
|
|
503 -- compiled previously on which the unit being compiled depends.
|
|
|
504
|
|
|
505 -- How this information is stored is up to the implementation of this
|
|
|
506 -- package. At the interface level, this information is simply associated
|
|
|
507 -- with its corresponding source.
|
|
|
508
|
|
|
509 -- Several different implementations are possible:
|
|
|
510
|
|
|
511 -- 1. The information could be directly associated with the source file,
|
|
|
512 -- e.g. placed in a resource fork of this file on the Mac, or on
|
|
|
513 -- MS-DOS, written to the source file after the end of file mark.
|
|
|
514
|
|
|
515 -- 2. The information could be written into the generated object module
|
|
|
516 -- if the system supports the inclusion of arbitrary informational
|
|
|
517 -- byte streams into object files. In this case there must be a naming
|
|
|
518 -- convention that allows object files to be located given the name of
|
|
|
519 -- the corresponding source file.
|
|
|
520
|
|
|
521 -- 3. The information could be written to a separate file, whose name is
|
|
|
522 -- related to the name of the source file by a fixed convention.
|
|
|
523
|
|
|
524 -- Which of these three methods is chosen depends on the constraints of the
|
|
|
525 -- host operating system. The interface described here is independent of
|
|
|
526 -- which of these approaches is used. Currently all versions of GNAT use
|
|
|
527 -- the third approach with a file name of xxx.ali where xxx is the source
|
|
|
528 -- file name.
|
|
|
529
|
|
|
530 -------------------------------
|
|
|
531 -- Library Information Input --
|
|
|
532 -------------------------------
|
|
|
533
|
|
|
534 -- These subprograms are used by the binder to read library information
|
|
|
535 -- files, see section above for representation of these files.
|
|
|
536
|
|
|
537 function Read_Library_Info
|
|
|
538 (Lib_File : File_Name_Type;
|
|
|
539 Fatal_Err : Boolean := False) return Text_Buffer_Ptr;
|
|
|
540 -- Allocates a Text_Buffer of appropriate length and reads in the entire
|
|
|
541 -- source of the library information from the library information file
|
|
|
542 -- whose name is given by the parameter Name.
|
|
|
543 --
|
|
|
544 -- See description of Read_Source_File for details on the format of the
|
|
|
545 -- returned text buffer (the format is identical). The lower bound of
|
|
|
546 -- the Text_Buffer is always zero
|
|
|
547 --
|
|
|
548 -- If the specified file cannot be opened, then the action depends on
|
|
|
549 -- Fatal_Err. If Fatal_Err is True, an error message is given and the
|
|
|
550 -- compilation is abandoned. Otherwise if Fatal_Err is False, then null
|
|
|
551 -- is returned. Note that the Lib_File is a simple name which does not
|
|
|
552 -- include any directory information. The implementation is responsible
|
|
|
553 -- for searching for the file in appropriate directories.
|
|
|
554 --
|
|
|
555 -- If Opt.Check_Object_Consistency is set to True then this routine checks
|
|
|
556 -- whether the object file corresponding to the Lib_File is consistent with
|
|
|
557 -- it. The object file is inconsistent if the object does not exist or if
|
|
|
558 -- it has an older time stamp than Lib_File. This check is not performed
|
|
|
559 -- when the Lib_File is "locked" (i.e. read/only) because in this case the
|
|
|
560 -- object file may be buried in a library. In case of inconsistencies
|
|
|
561 -- Read_Library_Info behaves as if it did not find Lib_File (namely if
|
|
|
562 -- Fatal_Err is False, null is returned).
|
|
|
563
|
|
|
564 function Read_Library_Info_From_Full
|
|
|
565 (Full_Lib_File : File_Name_Type;
|
|
|
566 Lib_File_Attr : access File_Attributes;
|
|
|
567 Fatal_Err : Boolean := False) return Text_Buffer_Ptr;
|
|
|
568 -- Same as Read_Library_Info, except Full_Lib_File must contains the full
|
|
|
569 -- path to the library file (instead of having Read_Library_Info recompute
|
|
|
570 -- it).
|
|
|
571 -- Lib_File_Attr should be an initialized set of attributes for the
|
|
|
572 -- library file (it can be initialized to Unknown_Attributes, but in
|
|
|
573 -- general will have been initialized by a previous call to Find_File).
|
|
|
574
|
|
|
575 function Full_Library_Info_Name return File_Name_Type;
|
|
|
576 function Full_Object_File_Name return File_Name_Type;
|
|
|
577 -- Returns the full name of the library/object file most recently read
|
|
|
578 -- using Read_Library_Info, including appropriate directory information.
|
|
|
579 -- Calling this routine entails no library file directory lookup
|
|
|
580 -- penalty. Note that the object file corresponding to a library file
|
|
|
581 -- is not actually read. Its time stamp is affected when the flag
|
|
|
582 -- Opt.Check_Object_Consistency is set.
|
|
|
583
|
|
|
584 function Current_Library_File_Stamp return Time_Stamp_Type;
|
|
|
585 function Current_Object_File_Stamp return Time_Stamp_Type;
|
|
|
586 -- The time stamps of the files returned by the previous two routines.
|
|
|
587 -- It is an error to call Current_Object_File_Stamp if
|
|
|
588 -- Opt.Check_Object_Consistency is set to False.
|
|
|
589
|
|
|
590 procedure Full_Lib_File_Name
|
|
|
591 (N : File_Name_Type;
|
|
|
592 Lib_File : out File_Name_Type;
|
|
|
593 Attr : out File_Attributes);
|
|
|
594 function Full_Lib_File_Name (N : File_Name_Type) return File_Name_Type;
|
|
|
595 -- Returns the full name of library file N. N should not include
|
|
|
596 -- path information. Note that if the file cannot be located No_File is
|
|
|
597 -- returned for the first routine and an all blank time stamp is returned
|
|
|
598 -- for the second (this is not an error situation). The full name includes
|
|
|
599 -- the appropriate directory information. The library file directory lookup
|
|
|
600 -- penalty is incurred every single time this routine is called.
|
|
|
601 -- The procedural version also returns some file attributes for the ALI
|
|
|
602 -- file (to save on system calls later on).
|
|
|
603
|
|
|
604 function Lib_File_Name
|
|
|
605 (Source_File : File_Name_Type;
|
|
|
606 Munit_Index : Nat := 0) return File_Name_Type;
|
|
|
607 -- Given the name of a source file, returns the name of the corresponding
|
|
|
608 -- library information file. This may be the name of the object file or of
|
|
|
609 -- a separate file used to store the library information. In the current
|
|
|
610 -- implementation, a separate file (the ALI file) is always used. In either
|
|
|
611 -- case the returned result is suitable for calling Read_Library_Info. The
|
|
|
612 -- Munit_Index is the unit index in multiple unit per file mode, or zero in
|
|
|
613 -- normal single unit per file mode (used to add ~nnn suffix). Note: this
|
|
|
614 -- subprogram is in this section because it is used by the compiler to
|
|
|
615 -- determine the proper library information names to be placed in the
|
|
|
616 -- generated library information file.
|
|
|
617
|
|
|
618 -----------------
|
|
|
619 -- Termination --
|
|
|
620 -----------------
|
|
|
621
|
|
|
622 Current_Exit_Status : Integer := 0;
|
|
|
623 -- Exit status that is set with procedure OS_Exit_Through_Exception below
|
|
|
624 -- and can be used in exception handler for Types.Terminate_Program to call
|
|
|
625 -- Set_Exit_Status as the last action of the program.
|
|
|
626
|
|
|
627 procedure OS_Exit_Through_Exception (Status : Integer);
|
|
|
628 pragma No_Return (OS_Exit_Through_Exception);
|
|
|
629 -- Set the Current_Exit_Status, then raise Types.Terminate_Program
|
|
|
630
|
|
|
631 type Exit_Code_Type is (
|
|
|
632 E_Success, -- No warnings or errors
|
|
|
633 E_Warnings, -- Compiler warnings generated
|
|
|
634 E_No_Code, -- No code generated
|
|
|
635 E_No_Compile, -- Compilation not needed (smart recompilation)
|
|
|
636 E_Errors, -- Compiler error messages generated
|
|
|
637 E_Fatal, -- Fatal (serious) error, e.g. source file not found
|
|
|
638 E_Abort); -- Internally detected compiler error
|
|
|
639
|
|
|
640 procedure Exit_Program (Exit_Code : Exit_Code_Type);
|
|
|
641 pragma No_Return (Exit_Program);
|
|
|
642 -- A call to Exit_Program terminates execution with the given status. A
|
|
|
643 -- status of zero indicates normal completion, a non-zero status indicates
|
|
|
644 -- abnormal termination.
|
|
|
645
|
|
|
646 -------------------------
|
|
|
647 -- Command Line Access --
|
|
|
648 -------------------------
|
|
|
649
|
|
|
650 -- Direct interface to command line parameters. (We don't want to use
|
|
|
651 -- the predefined command line package because it defines functions
|
|
|
652 -- returning string)
|
|
|
653
|
|
|
654 function Arg_Count return Natural;
|
|
|
655 pragma Import (C, Arg_Count, "__gnat_arg_count");
|
|
|
656 -- Get number of arguments (note: optional globbing may be enabled)
|
|
|
657
|
|
|
658 procedure Fill_Arg (A : System.Address; Arg_Num : Integer);
|
|
|
659 pragma Import (C, Fill_Arg, "__gnat_fill_arg");
|
|
|
660 -- Store one argument
|
|
|
661
|
|
|
662 function Len_Arg (Arg_Num : Integer) return Integer;
|
|
|
663 pragma Import (C, Len_Arg, "__gnat_len_arg");
|
|
|
664 -- Get length of argument
|
|
|
665
|
|
|
666 ALI_Default_Suffix : constant String_Ptr := new String'("ali");
|
|
|
667 ALI_Suffix : String_Ptr := ALI_Default_Suffix;
|
|
|
668 -- The suffixes used for the ALI files
|
|
|
669
|
|
|
670 function Prep_Suffix return String;
|
|
|
671 -- The suffix used for preprocessed files
|
|
|
672
|
|
|
673 private
|
|
|
674
|
|
|
675 Current_Main : File_Name_Type := No_File;
|
|
|
676 -- Used to save a simple file name between calls to Next_Main_Source and
|
|
|
677 -- Read_Source_File. If the file name argument to Read_Source_File is
|
|
|
678 -- No_File, that indicates that the file whose name was returned by the
|
|
|
679 -- last call to Next_Main_Source (and stored here) is to be read.
|
|
|
680
|
|
|
681 Target_Object_Suffix : constant String := Get_Target_Object_Suffix.all;
|
|
|
682 -- The suffix used for the target object files
|
|
|
683
|
|
|
684 Output_File_Name : File_Name_Type;
|
|
|
685 -- File_Name_Type for name of open file whose FD is in Output_FD, the name
|
|
|
686 -- stored does not include the trailing NUL character.
|
|
|
687
|
|
|
688 Argument_Count : constant Integer := Arg_Count - 1;
|
|
|
689 -- Number of arguments (excluding program name)
|
|
|
690
|
|
|
691 type File_Name_Array is array (Int range <>) of String_Ptr;
|
|
|
692 type File_Name_Array_Ptr is access File_Name_Array;
|
|
|
693 File_Names : File_Name_Array_Ptr :=
|
|
|
694 new File_Name_Array (1 .. Int (Argument_Count) + 2);
|
|
|
695 -- As arguments are scanned, file names are stored in this array. The
|
|
|
696 -- strings do not have terminating NUL files. The array is extensible,
|
|
|
697 -- because when using project files, there may be more files than
|
|
|
698 -- arguments on the command line.
|
|
|
699
|
|
|
700 type File_Index_Array is array (Int range <>) of Int;
|
|
|
701 type File_Index_Array_Ptr is access File_Index_Array;
|
|
|
702 File_Indexes : File_Index_Array_Ptr :=
|
|
|
703 new File_Index_Array (1 .. Int (Argument_Count) + 2);
|
|
|
704
|
|
|
705 Current_File_Name_Index : Int := 0;
|
|
|
706 -- The index in File_Names of the last file opened by Next_Main_Source
|
|
|
707 -- or Next_Main_Lib_File. The value 0 indicates that no files have been
|
|
|
708 -- opened yet.
|
|
|
709
|
|
|
710 procedure Create_File_And_Check
|
|
|
711 (Fdesc : out File_Descriptor;
|
|
|
712 Fmode : Mode);
|
|
|
713 -- Create file whose name (NUL terminated) is in Name_Buffer (with the
|
|
|
714 -- length in Name_Len), and place the resulting descriptor in Fdesc. Issue
|
|
|
715 -- message and exit with fatal error if file cannot be created. The Fmode
|
|
|
716 -- parameter is set to either Text or Binary (for details see description
|
|
|
717 -- of System.OS_Lib.Create_File).
|
|
|
718
|
|
|
719 procedure Open_File_To_Append_And_Check
|
|
|
720 (Fdesc : out File_Descriptor;
|
|
|
721 Fmode : Mode);
|
|
|
722 -- Opens the file whose name (NUL terminated) is in Name_Buffer (with the
|
|
|
723 -- length in Name_Len), and place the resulting descriptor in Fdesc. Issue
|
|
|
724 -- message and exit with fatal error if file cannot be opened. The Fmode
|
|
|
725 -- parameter is set to either Text or Binary (for details see description
|
|
|
726 -- of System.OS_Lib.Open_Append).
|
|
|
727
|
|
|
728 type Program_Type is (Compiler, Binder, Make, Gnatls, Unspecified);
|
|
|
729 -- Program currently running
|
|
|
730 procedure Set_Program (P : Program_Type);
|
|
|
731 -- Indicates to the body of Osint the program currently running. This
|
|
|
732 -- procedure is called by the child packages of Osint. A check is made
|
|
|
733 -- that this procedure is not called more than once.
|
|
|
734
|
|
|
735 function More_Files return Boolean;
|
|
|
736 -- Implements More_Source_Files and More_Lib_Files
|
|
|
737
|
|
|
738 function Next_Main_File return File_Name_Type;
|
|
|
739 -- Implements Next_Main_Source and Next_Main_Lib_File
|
|
|
740
|
|
|
741 function Object_File_Name (N : File_Name_Type) return File_Name_Type;
|
|
|
742 -- Constructs the name of the object file corresponding to library file N.
|
|
|
743 -- If N is a full file name than the returned file name will also be a full
|
|
|
744 -- file name. Note that no lookup in the library file directories is done
|
|
|
745 -- for this file. This routine merely constructs the name.
|
|
|
746
|
|
|
747 procedure Write_Info (Info : String);
|
|
|
748 -- Implements Write_Binder_Info, Write_Debug_Info, and Write_Library_Info
|
|
|
749
|
|
|
750 procedure Write_With_Check (A : Address; N : Integer);
|
|
|
751 -- Writes N bytes from buffer starting at address A to file whose FD is
|
|
|
752 -- stored in Output_FD, and whose file name is stored as a File_Name_Type
|
|
|
753 -- in Output_File_Name. A check is made for disk full, and if this is
|
|
|
754 -- detected, the file being written is deleted, and a fatal error is
|
|
|
755 -- signalled.
|
|
|
756
|
|
|
757 File_Attributes_Size : constant Natural := 32;
|
|
|
758 -- This should be big enough to fit a "struct file_attributes" on any
|
|
|
759 -- system. It doesn't cause any malfunction if it is too big (which avoids
|
|
|
760 -- the need for either mapping the struct exactly or importing the sizeof
|
|
|
761 -- from C, which would result in dynamic code). However, it does waste
|
|
|
762 -- space (e.g. when a component of this type appears in a record, if it is
|
|
|
763 -- unnecessarily large). Note: for runtime units, use System.OS_Constants.
|
|
|
764 -- SIZEOF_struct_file_attributes instead, which has the exact value.
|
|
|
765
|
|
|
766 type File_Attributes is
|
|
|
767 array (1 .. File_Attributes_Size)
|
|
|
768 of System.Storage_Elements.Storage_Element;
|
|
|
769 for File_Attributes'Alignment use Standard'Maximum_Alignment;
|
|
|
770
|
|
|
771 Unknown_Attributes : constant File_Attributes := (others => 0);
|
|
|
772 -- Will be initialized properly at elaboration (for efficiency later on,
|
|
|
773 -- avoid function calls every time we want to reset the attributes).
|
|
|
774
|
|
|
775 end Osint;
|
