File : osint.ads
1 ------------------------------------------------------------------------------
2 -- --
3 -- GNAT COMPILER COMPONENTS --
4 -- --
5 -- O S I N T --
6 -- --
7 -- S p e c --
8 -- --
9 -- Copyright (C) 1992-2015, 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_Canonical_Dir_Spec
218 (Host_Dir : String;
219 Prefix_Style : Boolean) return String_Access;
220 -- Convert a host syntax directory specification to canonical (Unix)
221 -- syntax. If Prefix_Style then make it a valid file specification prefix.
222 -- A file specification prefix is a directory specification that can be
223 -- appended with a simple file specification to yield a valid absolute
224 -- or relative path to a file. On a conversion to Unix syntax this simply
225 -- means the spec has a trailing slash ("/").
226
227 function To_Canonical_File_Spec
228 (Host_File : String) return String_Access;
229 -- Convert a host syntax file specification to canonical (Unix) syntax
230
231 function To_Canonical_Path_Spec
232 (Host_Path : String) return String_Access;
233 -- Convert a host syntax Path specification to canonical (Unix) syntax
234
235 function To_Host_Dir_Spec
236 (Canonical_Dir : String;
237 Prefix_Style : Boolean) return String_Access;
238 -- Convert a canonical syntax directory specification to host syntax. The
239 -- Prefix_Style flag is currently ignored but should be set to False.
240 -- Note that the caller must free result.
241
242 function To_Host_File_Spec
243 (Canonical_File : String) return String_Access;
244 -- Convert a canonical syntax file specification to host syntax
245
246 function Relocate_Path
247 (Prefix : String;
248 Path : String) return String_Ptr;
249 -- Given an absolute path and a prefix, if Path starts with Prefix,
250 -- replace the Prefix substring with the root installation directory.
251 -- By default, try to compute the root installation directory by looking
252 -- at the executable name as it was typed on the command line and, if
253 -- needed, use the PATH environment variable. If the above computation
254 -- fails, return Path. This function assumes Prefix'First = Path'First.
255
256 function Shared_Lib (Name : String) return String;
257 -- Returns the runtime shared library in the form -l<name>-<version> where
258 -- version is the GNAT runtime library option for the platform. For example
259 -- this routine called with Name set to "gnat" will return "-lgnat-5.02"
260 -- on UNIX and Windows.
261
262 ---------------------
263 -- File attributes --
264 ---------------------
265
266 -- The following subprograms offer services similar to those found in
267 -- System.OS_Lib, but with the ability to extra multiple information from
268 -- a single system call, depending on the system. This can result in fewer
269 -- system calls when reused.
270
271 -- In all these subprograms, the requested value is either read from the
272 -- File_Attributes parameter (resulting in no system call), or computed
273 -- from the disk and then cached in the File_Attributes parameter (possibly
274 -- along with other values).
275
276 type File_Attributes is private;
277 Unknown_Attributes : constant File_Attributes;
278 -- A cache for various attributes for a file (length, accessibility,...)
279 -- This must be initialized to Unknown_Attributes prior to the first call.
280
281 function Is_Directory
282 (Name : C_File_Name;
283 Attr : access File_Attributes) return Boolean;
284 function Is_Regular_File
285 (Name : C_File_Name;
286 Attr : access File_Attributes) return Boolean;
287 function Is_Symbolic_Link
288 (Name : C_File_Name;
289 Attr : access File_Attributes) return Boolean;
290 -- Return the type of the file,
291
292 function File_Length
293 (Name : C_File_Name;
294 Attr : access File_Attributes) return Long_Integer;
295 -- Return the length (number of bytes) of the file
296
297 function File_Time_Stamp
298 (Name : C_File_Name;
299 Attr : access File_Attributes) return OS_Time;
300 function File_Time_Stamp
301 (Name : Path_Name_Type;
302 Attr : access File_Attributes) return Time_Stamp_Type;
303 -- Return the time stamp of the file
304
305 function Is_Readable_File
306 (Name : C_File_Name;
307 Attr : access File_Attributes) return Boolean;
308 function Is_Executable_File
309 (Name : C_File_Name;
310 Attr : access File_Attributes) return Boolean;
311 function Is_Writable_File
312 (Name : C_File_Name;
313 Attr : access File_Attributes) return Boolean;
314 -- Return the access rights for the file
315
316 -------------------------
317 -- Search Dir Routines --
318 -------------------------
319
320 function Include_Dir_Default_Prefix return String;
321 -- Return the directory of the run-time library sources, as modified
322 -- by update_path.
323
324 function Object_Dir_Default_Prefix return String;
325 -- Return the directory of the run-time library ALI and object files, as
326 -- modified by update_path.
327
328 procedure Add_Default_Search_Dirs;
329 -- This routine adds the default search dirs indicated by the environment
330 -- variables and sdefault package, as well as the library search dirs set
331 -- by option -gnateO for GNAT2WHY.
332
333 procedure Add_Lib_Search_Dir (Dir : String);
334 -- Add Dir at the end of the library file search path
335
336 procedure Add_Src_Search_Dir (Dir : String);
337 -- Add Dir at the end of the source file search path
338
339 procedure Get_Next_Dir_In_Path_Init
340 (Search_Path : String_Access);
341 function Get_Next_Dir_In_Path
342 (Search_Path : String_Access) return String_Access;
343 -- These subprograms are used to parse out the directory names in a search
344 -- path specified by a Search_Path argument. The procedure initializes an
345 -- internal pointer to point to the initial directory name, and calls to
346 -- the function return successive directory names, with a null pointer
347 -- marking the end of the list.
348
349 type Search_File_Type is (Include, Objects);
350
351 procedure Add_Search_Dirs
352 (Search_Path : String_Ptr;
353 Path_Type : Search_File_Type);
354 -- These procedure adds all the search directories that are in Search_Path
355 -- in the proper file search path (library or source)
356
357 function Get_Primary_Src_Search_Directory return String_Ptr;
358 -- Retrieved the primary directory (directory containing the main source
359 -- file for Gnatmake.
360
361 function Nb_Dir_In_Src_Search_Path return Natural;
362 function Dir_In_Src_Search_Path (Position : Natural) return String_Ptr;
363 -- Functions to access the directory names in the source search path
364
365 function Nb_Dir_In_Obj_Search_Path return Natural;
366 function Dir_In_Obj_Search_Path (Position : Natural) return String_Ptr;
367 -- Functions to access the directory names in the Object search path
368
369 Include_Search_File : constant String_Access :=
370 new String'("ada_source_path");
371 Objects_Search_File : constant String_Access :=
372 new String'("ada_object_path");
373 -- Names of the files containing the default include or objects search
374 -- directories. These files, located in Sdefault.Search_Dir_Prefix, do
375 -- not necessarily exist.
376
377 Exec_Name : String_Ptr;
378 -- Executable name as typed by the user (used to compute the
379 -- executable prefix).
380
381 function Read_Default_Search_Dirs
382 (Search_Dir_Prefix : String_Access;
383 Search_File : String_Access;
384 Search_Dir_Default_Name : String_Access) return String_Access;
385 -- Read and return the default search directories from the file located
386 -- in Search_Dir_Prefix (as modified by update_path) and named Search_File.
387 -- If no such file exists or an error occurs then instead return the
388 -- Search_Dir_Default_Name (as modified by update_path).
389
390 function Get_RTS_Search_Dir
391 (Search_Dir : String;
392 File_Type : Search_File_Type) return String_Ptr;
393 -- This function retrieves the paths to the search (resp. lib) dirs and
394 -- return them. The search dir can be absolute or relative. If the search
395 -- dir contains Include_Search_File (resp. Object_Search_File), then this
396 -- function reads and returns the default search directories from the file.
397 -- Otherwise, if the directory is absolute, it will try to find 'adalib'
398 -- (resp. 'adainclude'). If found, null is returned. If the directory is
399 -- relative, the following directories for the directories 'adalib' and
400 -- 'adainclude' will be scanned:
401 --
402 -- - current directory (from which the tool has been spawned)
403 -- - $GNAT_ROOT/gcc/gcc-lib/$targ/$vers/
404 -- - $GNAT_ROOT/gcc/gcc-lib/$targ/$vers/rts-
405 --
406 -- The scan will stop as soon as the directory being searched for (adalib
407 -- or adainclude) is found. If the scan fails, null is returned.
408
409 -----------------------
410 -- Source File Input --
411 -----------------------
412
413 -- Source file input routines are used by the compiler to read the main
414 -- source files and the subsidiary source files (e.g. with'ed units), and
415 -- also by the binder to check presence/time stamps of sources.
416
417 procedure Read_Source_File
418 (N : File_Name_Type;
419 Lo : Source_Ptr;
420 Hi : out Source_Ptr;
421 Src : out Source_Buffer_Ptr;
422 T : File_Type := Source);
423 -- Allocates a Source_Buffer of appropriate length and then reads the
424 -- entire contents of the source file N into the buffer. The address of
425 -- the allocated buffer is returned in Src.
426 --
427 -- Each line of text is terminated by one of the sequences:
428 --
429 -- CR
430 -- CR/LF
431 -- LF
432
433 -- The source is terminated by an EOF (16#1A#) character, which is the last
434 -- character of the returned source buffer (note that any EOF characters in
435 -- positions other than the last source character are treated as blanks).
436 --
437 -- The logical lower bound of the source buffer is the input value of Lo,
438 -- and on exit Hi is set to the logical upper bound of the source buffer.
439 -- Note that the returned value in Src points to an array with a physical
440 -- lower bound of zero. This virtual origin addressing approach means that
441 -- a constrained array pointer can be used with a low bound of zero which
442 -- results in more efficient code.
443 --
444 -- If the given file cannot be opened, then the action depends on whether
445 -- this file is the current main unit (i.e. its name matches the name
446 -- returned by the most recent call to Next_Main_Source). If so, then the
447 -- failure to find the file is a fatal error, an error message is output,
448 -- and program execution is terminated. Otherwise (for the case of a
449 -- subsidiary source loaded directly or indirectly using with), a file
450 -- not found condition causes null to be set as the result value.
451 --
452 -- Note that the name passed to this function is the simple file name,
453 -- without any directory information. The implementation is responsible
454 -- for searching for the file in the appropriate directories.
455 --
456 -- Note the special case that if the file name is gnat.adc, then the search
457 -- for the file is done ONLY in the directory corresponding to the current
458 -- compilation environment, i.e. in the same directory where the ali and
459 -- object files will be written.
460
461 function Full_Source_Name return File_Name_Type;
462 function Current_Source_File_Stamp return Time_Stamp_Type;
463 -- Returns the full name/time stamp of the source file most recently read
464 -- using Read_Source_File. Calling this routine entails no source file
465 -- directory lookup penalty.
466
467 procedure Full_Source_Name
468 (N : File_Name_Type;
469 Full_File : out File_Name_Type;
470 Attr : access File_Attributes);
471 function Full_Source_Name (N : File_Name_Type) return File_Name_Type;
472 function Source_File_Stamp (N : File_Name_Type) return Time_Stamp_Type;
473 -- Returns the full name/time stamp of the source file whose simple name
474 -- is N which should not include path information. Note that if the file
475 -- cannot be located No_File is returned for the first routine and an all
476 -- blank time stamp is returned for the second (this is not an error
477 -- situation). The full name includes appropriate directory information.
478 -- The source file directory lookup penalty is incurred every single time
479 -- the routines are called unless you have previously called
480 -- Source_File_Data (Cache => True). See below.
481 --
482 -- The procedural version also returns some file attributes for the ALI
483 -- file (to save on system calls later on).
484
485 function Current_File_Index return Int;
486 -- Return the index in its source file of the current main unit
487
488 function Matching_Full_Source_Name
489 (N : File_Name_Type;
490 T : Time_Stamp_Type) return File_Name_Type;
491 -- Same semantics than Full_Source_Name but will search on the source path
492 -- until a source file with time stamp matching T is found. If none is
493 -- found returns No_File.
494
495 procedure Source_File_Data (Cache : Boolean);
496 -- By default source file data (full source file name and time stamp)
497 -- are looked up every time a call to Full_Source_Name (N) or
498 -- Source_File_Stamp (N) is made. This may be undesirable in certain
499 -- applications as this is uselessly slow if source file data does not
500 -- change during program execution. When this procedure is called with
501 -- Cache => True access to source file data does not incur a penalty if
502 -- this data was previously retrieved.
503
504 procedure Dump_Source_File_Names;
505 -- Prints out the names of all source files that have been read by
506 -- Read_Source_File, except those that come from the run-time library
507 -- (i.e. Include_Dir_Default_Prefix). The text is sent to whatever Output
508 -- is currently using (e.g. standard output or standard error).
509
510 -------------------------------------------
511 -- Representation of Library Information --
512 -------------------------------------------
513
514 -- Associated with each compiled source file is library information, a
515 -- string of bytes whose exact format is described in the body of Lib.Writ.
516 -- Compiling a source file generates this library information for the
517 -- compiled unit, and access the library information for units that were
518 -- compiled previously on which the unit being compiled depends.
519
520 -- How this information is stored is up to the implementation of this
521 -- package. At the interface level, this information is simply associated
522 -- with its corresponding source.
523
524 -- Several different implementations are possible:
525
526 -- 1. The information could be directly associated with the source file,
527 -- e.g. placed in a resource fork of this file on the Mac, or on
528 -- MS-DOS, written to the source file after the end of file mark.
529
530 -- 2. The information could be written into the generated object module
531 -- if the system supports the inclusion of arbitrary informational
532 -- byte streams into object files. In this case there must be a naming
533 -- convention that allows object files to be located given the name of
534 -- the corresponding source file.
535
536 -- 3. The information could be written to a separate file, whose name is
537 -- related to the name of the source file by a fixed convention.
538
539 -- Which of these three methods is chosen depends on the constraints of the
540 -- host operating system. The interface described here is independent of
541 -- which of these approaches is used. Currently all versions of GNAT use
542 -- the third approach with a file name of xxx.ali where xxx is the source
543 -- file name.
544
545 -------------------------------
546 -- Library Information Input --
547 -------------------------------
548
549 -- These subprograms are used by the binder to read library information
550 -- files, see section above for representation of these files.
551
552 function Read_Library_Info
553 (Lib_File : File_Name_Type;
554 Fatal_Err : Boolean := False) return Text_Buffer_Ptr;
555 -- Allocates a Text_Buffer of appropriate length and reads in the entire
556 -- source of the library information from the library information file
557 -- whose name is given by the parameter Name.
558 --
559 -- See description of Read_Source_File for details on the format of the
560 -- returned text buffer (the format is identical). The lower bound of
561 -- the Text_Buffer is always zero
562 --
563 -- If the specified file cannot be opened, then the action depends on
564 -- Fatal_Err. If Fatal_Err is True, an error message is given and the
565 -- compilation is abandoned. Otherwise if Fatal_Err is False, then null
566 -- is returned. Note that the Lib_File is a simple name which does not
567 -- include any directory information. The implementation is responsible
568 -- for searching for the file in appropriate directories.
569 --
570 -- If Opt.Check_Object_Consistency is set to True then this routine checks
571 -- whether the object file corresponding to the Lib_File is consistent with
572 -- it. The object file is inconsistent if the object does not exist or if
573 -- it has an older time stamp than Lib_File. This check is not performed
574 -- when the Lib_File is "locked" (i.e. read/only) because in this case the
575 -- object file may be buried in a library. In case of inconsistencies
576 -- Read_Library_Info behaves as if it did not find Lib_File (namely if
577 -- Fatal_Err is False, null is returned).
578
579 function Read_Library_Info_From_Full
580 (Full_Lib_File : File_Name_Type;
581 Lib_File_Attr : access File_Attributes;
582 Fatal_Err : Boolean := False) return Text_Buffer_Ptr;
583 -- Same as Read_Library_Info, except Full_Lib_File must contains the full
584 -- path to the library file (instead of having Read_Library_Info recompute
585 -- it).
586 -- Lib_File_Attr should be an initialized set of attributes for the
587 -- library file (it can be initialized to Unknown_Attributes, but in
588 -- general will have been initialized by a previous call to Find_File).
589
590 function Full_Library_Info_Name return File_Name_Type;
591 function Full_Object_File_Name return File_Name_Type;
592 -- Returns the full name of the library/object file most recently read
593 -- using Read_Library_Info, including appropriate directory information.
594 -- Calling this routine entails no library file directory lookup
595 -- penalty. Note that the object file corresponding to a library file
596 -- is not actually read. Its time stamp is affected when the flag
597 -- Opt.Check_Object_Consistency is set.
598
599 function Current_Library_File_Stamp return Time_Stamp_Type;
600 function Current_Object_File_Stamp return Time_Stamp_Type;
601 -- The time stamps of the files returned by the previous two routines.
602 -- It is an error to call Current_Object_File_Stamp if
603 -- Opt.Check_Object_Consistency is set to False.
604
605 procedure Full_Lib_File_Name
606 (N : File_Name_Type;
607 Lib_File : out File_Name_Type;
608 Attr : out File_Attributes);
609 function Full_Lib_File_Name (N : File_Name_Type) return File_Name_Type;
610 -- Returns the full name of library file N. N should not include
611 -- path information. Note that if the file cannot be located No_File is
612 -- returned for the first routine and an all blank time stamp is returned
613 -- for the second (this is not an error situation). The full name includes
614 -- the appropriate directory information. The library file directory lookup
615 -- penalty is incurred every single time this routine is called.
616 -- The procedural version also returns some file attributes for the ALI
617 -- file (to save on system calls later on).
618
619 function Lib_File_Name
620 (Source_File : File_Name_Type;
621 Munit_Index : Nat := 0) return File_Name_Type;
622 -- Given the name of a source file, returns the name of the corresponding
623 -- library information file. This may be the name of the object file or of
624 -- a separate file used to store the library information. In the current
625 -- implementation, a separate file (the ALI file) is always used. In either
626 -- case the returned result is suitable for calling Read_Library_Info. The
627 -- Munit_Index is the unit index in multiple unit per file mode, or zero in
628 -- normal single unit per file mode (used to add ~nnn suffix). Note: this
629 -- subprogram is in this section because it is used by the compiler to
630 -- determine the proper library information names to be placed in the
631 -- generated library information file.
632
633 -----------------
634 -- Termination --
635 -----------------
636
637 Current_Exit_Status : Integer := 0;
638 -- Exit status that is set with procedure OS_Exit_Through_Exception below
639 -- and can be used in exception handler for Types.Terminate_Program to call
640 -- Set_Exit_Status as the last action of the program.
641
642 procedure OS_Exit_Through_Exception (Status : Integer);
643 pragma No_Return (OS_Exit_Through_Exception);
644 -- Set the Current_Exit_Status, then raise Types.Terminate_Program
645
646 type Exit_Code_Type is (
647 E_Success, -- No warnings or errors
648 E_Warnings, -- Compiler warnings generated
649 E_No_Code, -- No code generated
650 E_No_Compile, -- Compilation not needed (smart recompilation)
651 E_Errors, -- Compiler error messages generated
652 E_Fatal, -- Fatal (serious) error, e.g. source file not found
653 E_Abort); -- Internally detected compiler error
654
655 procedure Exit_Program (Exit_Code : Exit_Code_Type);
656 pragma No_Return (Exit_Program);
657 -- A call to Exit_Program terminates execution with the given status. A
658 -- status of zero indicates normal completion, a non-zero status indicates
659 -- abnormal termination.
660
661 -------------------------
662 -- Command Line Access --
663 -------------------------
664
665 -- Direct interface to command line parameters. (We don't want to use
666 -- the predefined command line package because it defines functions
667 -- returning string)
668
669 function Arg_Count return Natural;
670 pragma Import (C, Arg_Count, "__gnat_arg_count");
671 -- Get number of arguments (note: optional globbing may be enabled)
672
673 procedure Fill_Arg (A : System.Address; Arg_Num : Integer);
674 pragma Import (C, Fill_Arg, "__gnat_fill_arg");
675 -- Store one argument
676
677 function Len_Arg (Arg_Num : Integer) return Integer;
678 pragma Import (C, Len_Arg, "__gnat_len_arg");
679 -- Get length of argument
680
681 ALI_Default_Suffix : constant String_Ptr := new String'("ali");
682 ALI_Suffix : String_Ptr := ALI_Default_Suffix;
683 -- The suffixes used for the ALI files
684
685 function Prep_Suffix return String;
686 -- The suffix used for pre-processed files
687
688 private
689
690 Current_Main : File_Name_Type := No_File;
691 -- Used to save a simple file name between calls to Next_Main_Source and
692 -- Read_Source_File. If the file name argument to Read_Source_File is
693 -- No_File, that indicates that the file whose name was returned by the
694 -- last call to Next_Main_Source (and stored here) is to be read.
695
696 Target_Object_Suffix : constant String := Get_Target_Object_Suffix.all;
697 -- The suffix used for the target object files
698
699 Output_File_Name : File_Name_Type;
700 -- File_Name_Type for name of open file whose FD is in Output_FD, the name
701 -- stored does not include the trailing NUL character.
702
703 Argument_Count : constant Integer := Arg_Count - 1;
704 -- Number of arguments (excluding program name)
705
706 type File_Name_Array is array (Int range <>) of String_Ptr;
707 type File_Name_Array_Ptr is access File_Name_Array;
708 File_Names : File_Name_Array_Ptr :=
709 new File_Name_Array (1 .. Int (Argument_Count) + 2);
710 -- As arguments are scanned, file names are stored in this array. The
711 -- strings do not have terminating NUL files. The array is extensible,
712 -- because when using project files, there may be more files than
713 -- arguments on the command line.
714
715 type File_Index_Array is array (Int range <>) of Int;
716 type File_Index_Array_Ptr is access File_Index_Array;
717 File_Indexes : File_Index_Array_Ptr :=
718 new File_Index_Array (1 .. Int (Argument_Count) + 2);
719
720 Current_File_Name_Index : Int := 0;
721 -- The index in File_Names of the last file opened by Next_Main_Source
722 -- or Next_Main_Lib_File. The value 0 indicates that no files have been
723 -- opened yet.
724
725 procedure Create_File_And_Check
726 (Fdesc : out File_Descriptor;
727 Fmode : Mode);
728 -- Create file whose name (NUL terminated) is in Name_Buffer (with the
729 -- length in Name_Len), and place the resulting descriptor in Fdesc. Issue
730 -- message and exit with fatal error if file cannot be created. The Fmode
731 -- parameter is set to either Text or Binary (for details see description
732 -- of System.OS_Lib.Create_File).
733
734 procedure Open_File_To_Append_And_Check
735 (Fdesc : out File_Descriptor;
736 Fmode : Mode);
737 -- Opens the file whose name (NUL terminated) is in Name_Buffer (with the
738 -- length in Name_Len), and place the resulting descriptor in Fdesc. Issue
739 -- message and exit with fatal error if file cannot be opened. The Fmode
740 -- parameter is set to either Text or Binary (for details see description
741 -- of System.OS_Lib.Open_Append).
742
743 type Program_Type is (Compiler, Binder, Make, Gnatls, Unspecified);
744 -- Program currently running
745 procedure Set_Program (P : Program_Type);
746 -- Indicates to the body of Osint the program currently running. This
747 -- procedure is called by the child packages of Osint. A check is made
748 -- that this procedure is not called more than once.
749
750 function More_Files return Boolean;
751 -- Implements More_Source_Files and More_Lib_Files
752
753 function Next_Main_File return File_Name_Type;
754 -- Implements Next_Main_Source and Next_Main_Lib_File
755
756 function Object_File_Name (N : File_Name_Type) return File_Name_Type;
757 -- Constructs the name of the object file corresponding to library file N.
758 -- If N is a full file name than the returned file name will also be a full
759 -- file name. Note that no lookup in the library file directories is done
760 -- for this file. This routine merely constructs the name.
761
762 procedure Write_Info (Info : String);
763 -- Implements Write_Binder_Info, Write_Debug_Info, and Write_Library_Info
764
765 procedure Write_With_Check (A : Address; N : Integer);
766 -- Writes N bytes from buffer starting at address A to file whose FD is
767 -- stored in Output_FD, and whose file name is stored as a File_Name_Type
768 -- in Output_File_Name. A check is made for disk full, and if this is
769 -- detected, the file being written is deleted, and a fatal error is
770 -- signalled.
771
772 File_Attributes_Size : constant Natural := 32;
773 -- This should be big enough to fit a "struct file_attributes" on any
774 -- system. It doesn't cause any malfunction if it is too big (which avoids
775 -- the need for either mapping the struct exactly or importing the sizeof
776 -- from C, which would result in dynamic code). However, it does waste
777 -- space (e.g. when a component of this type appears in a record, if it is
778 -- unnecessarily large). Note: for runtime units, use System.OS_Constants.
779 -- SIZEOF_struct_file_attributes instead, which has the exact value.
780
781 type File_Attributes is
782 array (1 .. File_Attributes_Size)
783 of System.Storage_Elements.Storage_Element;
784 for File_Attributes'Alignment use Standard'Maximum_Alignment;
785
786 Unknown_Attributes : constant File_Attributes := (others => 0);
787 -- Will be initialized properly at elaboration (for efficiency later on,
788 -- avoid function calls every time we want to reset the attributes).
789
790 end Osint;