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