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