1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
11 -- Copyright (C) 1992-2001 Free Software Foundation, Inc. --
13 -- GNAT is free software; you can redistribute it and/or modify it under --
14 -- terms of the GNU General Public License as published by the Free Soft- --
15 -- ware Foundation; either version 2, or (at your option) any later ver- --
16 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
17 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
18 -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
19 -- for more details. You should have received a copy of the GNU General --
20 -- Public License distributed with GNAT; see file COPYING. If not, write --
21 -- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
22 -- MA 02111-1307, USA. --
24 -- GNAT was originally developed by the GNAT team at New York University. --
25 -- It is now maintained by Ada Core Technologies Inc (http://www.gnat.com). --
27 ------------------------------------------------------------------------------
29 -- This package contains the low level, operating system routines used in
30 -- the GNAT compiler and binder for command line processing and file input
33 with GNAT.OS_Lib; use GNAT.OS_Lib;
34 with System; use System;
35 with Types; use Types;
37 pragma Elaborate (GNAT.OS_Lib);
41 function Normalize_Directory_Name (Directory : String) return String_Ptr;
42 -- Verify and normalize a directory name. If directory name is invalid,
43 -- this will return an empty string. Otherwise it will insure a trailing
44 -- slash and make other normalizations.
46 type File_Type is (Source, Library, Config);
51 return File_Name_Type;
52 -- Finds a source, library or config file depending on the value
53 -- of T following the directory search order rules unless N is the
54 -- name of the file just read with Next_Main_File and already
55 -- contains directiory information, in which case just look in the
56 -- Primary_Directory. Returns File_Name_Type of the full file name
57 -- if found, No_File if file not found. Note that for the special
58 -- case of gnat.adc, only the compilation environment directory is
59 -- searched, i.e. the directory where the ali and object files are
60 -- written. Another special case is when Debug_Generated_Code is
61 -- set and the file name ends on ".dg", in which case we look for
62 -- the generated file only in the current directory, since that is
63 -- where it is always built.
65 function Get_File_Names_Case_Sensitive return Int;
66 pragma Import (C, Get_File_Names_Case_Sensitive,
67 "__gnat_get_file_names_case_sensitive");
68 File_Names_Case_Sensitive : constant Boolean :=
69 Get_File_Names_Case_Sensitive /= 0;
70 -- Set to indicate whether the operating system convention is for file
71 -- names to be case sensitive (e.g., in Unix, set True), or non case
72 -- sensitive (e.g., in OS/2, set False).
74 procedure Canonical_Case_File_Name (S : in out String);
75 -- Given a file name, converts it to canonical case form. For systems
76 -- where file names are case sensitive, this procedure has no effect.
77 -- If file names are not case sensitive (i.e. for example if you have
78 -- the file "xyz.adb", you can refer to it as XYZ.adb or XyZ.AdB), then
79 -- this call converts the given string to canonical all lower case form,
80 -- so that two file names compare equal if they refer to the same file.
82 function Number_Of_Files return Int;
83 -- gives the total number of filenames found on the command line.
85 procedure Add_File (File_Name : String);
86 -- Called by the subprogram processing the command line for each
89 procedure Find_Program_Name;
90 -- Put simple name of current program being run (excluding the directory
91 -- path) in Name_Buffer, with the length in Name_Len.
93 function Program_Name (Nam : String) return String_Access;
94 -- In the native compilation case, Create a string containing Nam. In
95 -- the cross compilation case, looks at the prefix of the current
96 -- program being run and prepend it to Nam. For instance if the program
97 -- being run is <target>-gnatmake and Nam is "gcc", the returned value
98 -- will be a pointer to "<target>-gcc". This function clobbers
99 -- Name_Buffer and Name_Len.
101 procedure Write_Program_Name;
102 -- Writes name of program as invoked to the current output
103 -- (normally standard output).
105 procedure Fail (S1 : String; S2 : String := ""; S3 : String := "");
106 pragma No_Return (Fail);
107 -- Outputs error messages S1 & S2 & S3 preceded by the name of the
108 -- executing program and exits with E_Fatal. The output goes to
109 -- standard error, except if special output is in effect (see Output).
111 function Is_Directory_Separator (C : Character) return Boolean;
112 -- Returns True if C is a directory separator
114 function Get_Directory (Name : File_Name_Type) return File_Name_Type;
115 -- Get the prefix directory name (if any) from Name. The last separator
116 -- is preserved. Return the normalized current directory if there is no
117 -- directory part in the name.
119 function Is_Readonly_Library (File : File_Name_Type) return Boolean;
120 -- Check if this library file is a read-only file.
122 function Strip_Directory (Name : File_Name_Type) return File_Name_Type;
123 -- Strips the prefix directory name (if any) from Name. Returns the
124 -- stripped name. Name cannot end with a directory separator.
126 function Strip_Suffix (Name : File_Name_Type) return File_Name_Type;
127 -- Strips the suffix (the last '.' and whatever comes after it) from Name.
128 -- Returns the stripped name.
130 function Executable_Name (Name : File_Name_Type) return File_Name_Type;
131 -- Given a file name it adds the appropriate suffix at the end so that
132 -- it becomes the name of the executable on the system at end. For
133 -- instance under DOS it adds the ".exe" suffix, whereas under UNIX no
136 function File_Stamp (Name : File_Name_Type) return Time_Stamp_Type;
137 -- Returns the time stamp of file Name. Name should include relative
138 -- path information in order to locate it. If the source file cannot be
139 -- opened, or Name = No_File, and all blank time stamp is returned (this is
140 -- not an error situation).
142 type String_Access_List is array (Positive range <>) of String_Access;
143 -- Deferenced type used to return a list of file specs in
144 -- To_Canonical_File_List.
146 type String_Access_List_Access is access all String_Access_List;
147 -- Type used to return a String_Access_List without dragging in secondary
150 function To_Canonical_File_List
151 (Wildcard_Host_File : String;
153 return String_Access_List_Access;
154 -- Expand a wildcard host syntax file or directory specification (e.g. on
155 -- a VMS host, any file or directory spec that contains:
156 -- "*", or "%", or "...")
157 -- and return a list of valid Unix syntax file or directory specs.
158 -- If Only_Dirs is True, then only return directories.
160 function To_Canonical_Dir_Spec
162 Prefix_Style : Boolean)
163 return String_Access;
164 -- Convert a host syntax directory specification (e.g. on a VMS host:
165 -- "SYS$DEVICE:[DIR]") to canonical (Unix) syntax (e.g. "/sys$device/dir").
166 -- If Prefix_Style then make it a valid file specification prefix.
167 -- A file specification prefix is a directory specification that
168 -- can be appended with a simple file specification to yield a valid
169 -- absolute or relative path to a file. On a conversion to Unix syntax
170 -- this simply means the spec has a trailing slash ("/").
172 function To_Canonical_File_Spec
174 return String_Access;
175 -- Convert a host syntax file specification (e.g. on a VMS host:
176 -- "SYS$DEVICE:[DIR]FILE.EXT;69 to canonical (Unix) syntax (e.g.
177 -- "/sys$device/dir/file.ext.69").
179 function To_Canonical_Path_Spec
181 return String_Access;
182 -- Convert a host syntax Path specification (e.g. on a VMS host:
183 -- "SYS$DEVICE:[BAR],DISK$USER:[FOO] to canonical (Unix) syntax (e.g.
184 -- "/sys$device/foo:disk$user/foo").
186 function To_Host_Dir_Spec
187 (Canonical_Dir : String;
188 Prefix_Style : Boolean)
189 return String_Access;
190 -- Convert a canonical syntax directory specification to host syntax.
191 -- The Prefix_Style flag is currently ignored but should be set to
194 function To_Host_File_Spec
195 (Canonical_File : String)
196 return String_Access;
197 -- Convert a canonical syntax file specification to host syntax.
199 -------------------------
200 -- Search Dir Routines --
201 -------------------------
203 procedure Add_Default_Search_Dirs;
204 -- This routine adds the default search dirs indicated by the
205 -- environment variables and sdefault package.
207 procedure Add_Lib_Search_Dir (Dir : String);
208 -- Add Dir at the end of the library file search path
210 procedure Add_Src_Search_Dir (Dir : String);
211 -- Add Dir at the end of the source file search path
213 procedure Get_Next_Dir_In_Path_Init
214 (Search_Path : String_Access);
215 function Get_Next_Dir_In_Path
216 (Search_Path : String_Access)
217 return String_Access;
218 -- These subprograms are used to parse out the directory names in a
219 -- search path specified by a Search_Path argument. The procedure
220 -- initializes an internal pointer to point to the initial directory
221 -- name, and calls to the function return successive directory names,
222 -- with a null pointer marking the end of the list.
224 type Search_File_Type is (Include, Objects);
226 procedure Add_Search_Dirs
227 (Search_Path : String_Ptr;
228 Path_Type : Search_File_Type);
229 -- These procedure adds all the search directories that are in Search_Path
230 -- in the proper file search path (library or source)
232 function Get_Primary_Src_Search_Directory return String_Ptr;
233 -- Retrieved the primary directory (directory containing the main source
234 -- file for Gnatmake.
236 function Nb_Dir_In_Src_Search_Path return Natural;
237 function Dir_In_Src_Search_Path (Position : Natural) return String_Ptr;
238 -- Functions to access the directory names in the source search path
240 function Nb_Dir_In_Obj_Search_Path return Natural;
241 function Dir_In_Obj_Search_Path (Position : Natural) return String_Ptr;
242 -- Functions to access the directory names in the Object search path
244 Include_Search_File : constant String_Access :=
245 new String'("ada_source_path");
246 Objects_Search_File : constant String_Access :=
247 new String'("ada_object_path");
248 -- Names of the files containg the default include or objects search
249 -- directories. These files, located in Sdefault.Search_Dir_Prefix, do
250 -- not necessarily exist.
252 function Read_Default_Search_Dirs
253 (Search_Dir_Prefix : String_Access;
254 Search_File : String_Access;
255 Search_Dir_Default_Name : String_Access)
256 return String_Access;
257 -- Read and return the default search directories from the file located
258 -- in Search_Dir_Prefix (as modified by update_path) and named Search_File.
259 -- If no such file exists or an error occurs then instead return the
260 -- Search_Dir_Default_Name (as modified by update_path).
262 function Get_RTS_Search_Dir
263 (Search_Dir : String;
264 File_Type : Search_File_Type)
266 -- This function retrieves the paths to the search (resp. lib) dirs and
267 -- return them. The search dir can be absolute or relative. If the search
268 -- dir contains Include_Search_File (resp. Object_Search_File), then this
269 -- function reads and returns the default search directories from the file.
270 -- Otherwise, if the directory is absolute, it will try to find 'adalib'
271 -- (resp. 'adainclude'). If found, null is returned. If the directory is
272 -- relative, the following directories for the directories 'adalib' and
273 -- 'adainclude' will be scanned:
275 -- - current directory (from which the tool has been spawned)
276 -- - $GNAT_ROOT/gcc/gcc-lib/$targ/$vers/
277 -- - $GNAT_ROOT/gcc/gcc-lib/$targ/$vers/rts-
279 -- The scan will stop as soon as the directory being searched for (adalib
280 -- or adainclude) is found. If the scan fails, null is returned.
282 -----------------------
283 -- Source File Input --
284 -----------------------
286 -- Source file input routines are used by the compiler to read the main
287 -- source files and the subsidiary source files (e.g. with'ed units), and
288 -- also by the binder to check presence/time stamps of sources.
290 procedure Read_Source_File
294 Src : out Source_Buffer_Ptr;
295 T : File_Type := Source);
296 -- Allocates a Source_Buffer of appropriate length and then reads the
297 -- entire contents of the source file N into the buffer. The address of
298 -- the allocated buffer is returned in Src.
300 -- Each line of text is terminated by one of the sequences:
307 -- The source is terminated by an EOF (16#1A#) character, which is
308 -- the last charcater of the returned source bufer (note that any
309 -- EOF characters in positions other than the last source character
310 -- are treated as representing blanks).
312 -- The logical lower bound of the source buffer is the input value of Lo,
313 -- and on exit Hi is set to the logical upper bound of the source buffer.
314 -- Note that the returned value in Src points to an array with a physical
315 -- lower bound of zero. This virtual origin addressing approach means that
316 -- a constrained array pointer can be used with a low bound of zero which
317 -- results in more efficient code.
319 -- If the given file cannot be opened, then the action depends on whether
320 -- this file is the current main unit (i.e. its name matches the name
321 -- returned by the most recent call to Next_Main_Source). If so, then the
322 -- failure to find the file is a fatal error, an error message is output,
323 -- and program execution is terminated. Otherwise (for the case of a
324 -- subsidiary source loaded directly or indirectly using with), a file
325 -- not found condition causes null to be set as the result value.
327 -- Note that the name passed to this function is the simple file name,
328 -- without any directory information. The implementation is responsible
329 -- for searching for the file in the appropriate directories.
331 -- Note the special case that if the file name is gnat.adc, then the
332 -- search for the file is done ONLY in the directory corresponding to
333 -- the current compilation environment, i.e. in the same directory
334 -- where the ali and object files will be written.
336 function Full_Source_Name return File_Name_Type;
337 function Current_Source_File_Stamp return Time_Stamp_Type;
338 -- Returns the full name/time stamp of the source file most recently read
339 -- using Read_Source_File. Calling this routine entails no source file
340 -- directory lookup penalty.
342 function Full_Source_Name (N : File_Name_Type) return File_Name_Type;
343 function Source_File_Stamp (N : File_Name_Type) return Time_Stamp_Type;
344 -- Returns the full name/time stamp of the source file whose simple name
345 -- is N which should not include path information. Note that if the file
346 -- cannot be located No_File is returned for the first routine and an
347 -- all blank time stamp is returned for the second (this is not an error
348 -- situation). The full name includes the appropriate directory
349 -- information. The source file directory lookup penalty is incurred
350 -- every single time the routines are called unless you have previously
351 -- called Source_File_Data (Cache => True). See below.
353 function Matching_Full_Source_Name
356 return File_Name_Type;
357 -- Same semantics than Full_Source_Name but will search on the source
358 -- path until a source file with time stamp matching T is found. If
359 -- none is found returns No_File.
361 procedure Source_File_Data (Cache : Boolean);
362 -- By default source file data (full source file name and time stamp)
363 -- are looked up every time a call to Full_Source_Name (N) or
364 -- Source_File_Stamp (N) is made. This may be undesirable in certain
365 -- applications as this is uselessly slow if source file data does not
366 -- change during program execution. When this procedure is called with
367 -- Cache => True access to source file data does not encurr a penalty if
368 -- this data was previously retrieved.
370 -------------------------------------------
371 -- Representation of Library Information --
372 -------------------------------------------
374 -- Associated with each compiled source file is library information,
375 -- a string of bytes whose exact format is described in the body of
376 -- Lib.Writ. Compiling a source file generates this library information
377 -- for the compiled unit, and access the library information for units
378 -- that were compiled previously on which the unit being compiled depends.
380 -- How this information is stored is up to the implementation of this
381 -- package. At the interface level, this information is simply associated
382 -- with its corresponding source.
384 -- Several different implementations are possible:
386 -- 1. The information could be directly associated with the source file,
387 -- e.g. placed in a resource fork of this file on the Mac, or on
388 -- MS-DOS, written to the source file after the end of file mark.
390 -- 2. The information could be written into the generated object module
391 -- if the system supports the inclusion of arbitrary informational
392 -- byte streams into object files. In this case there must be a naming
393 -- convention that allows object files to be located given the name of
394 -- the corresponding source file.
396 -- 3. The information could be written to a separate file, whose name is
397 -- related to the name of the source file by a fixed convention.
399 -- Which of these three methods is chosen depends on the constraints of the
400 -- host operating system. The interface described here is independent of
401 -- which of these approaches is used.
403 -------------------------------
404 -- Library Information Input --
405 -------------------------------
407 -- These subprograms are used by the binder to read library information
408 -- files, see section above for representation of these files.
410 function Read_Library_Info
411 (Lib_File : File_Name_Type;
412 Fatal_Err : Boolean := False)
413 return Text_Buffer_Ptr;
414 -- Allocates a Text_Buffer of appropriate length and reads in the entire
415 -- source of the library information from the library information file
416 -- whose name is given by the parameter Name.
418 -- See description of Read_Source_File for details on the format of the
419 -- returned text buffer (the format is identical). THe lower bound of
420 -- the Text_Buffer is always zero
422 -- If the specified file cannot be opened, then the action depends on
423 -- Fatal_Err. If Fatal_Err is True, an error message is given and the
424 -- compilation is abandoned. Otherwise if Fatal_Err is False, then null
425 -- is returned. Note that the Lib_File is a simple name which does not
426 -- include any directory information. The implementation is responsible
427 -- for searching for the file in appropriate directories.
429 -- If Opt.Check_Object_Consistency is set to True then this routine
430 -- checks whether the object file corresponding to the Lib_File is
431 -- consistent with it. The object file is inconsistent if the object
432 -- does not exist or if it has an older time stamp than Lib_File.
433 -- This check is not performed when the Lib_File is "locked" (i.e.
434 -- read/only) because in this case the object file may be buried
435 -- in a library. In case of inconsistencies Read_Library_Info
436 -- behaves as if it did not find Lib_File (namely if Fatal_Err is
437 -- False, null is returned).
439 function Full_Library_Info_Name return File_Name_Type;
440 function Full_Object_File_Name return File_Name_Type;
441 -- Returns the full name of the library/object file most recently read
442 -- using Read_Library_Info, including appropriate directory information.
443 -- Calling this routine entails no library file directory lookup
444 -- penalty. Note that the object file corresponding to a library file
445 -- is not actually read. Its time stamp is fected when the flag
446 -- Opt.Check_Object_Consistency is set.
448 function Current_Library_File_Stamp return Time_Stamp_Type;
449 function Current_Object_File_Stamp return Time_Stamp_Type;
450 -- The time stamps of the files returned by the previous two routines.
451 -- It is an error to call Current_Object_File_Stamp if
452 -- Opt.Check_Object_Consistency is set to False.
454 function Full_Lib_File_Name (N : File_Name_Type) return File_Name_Type;
455 function Library_File_Stamp (N : File_Name_Type) return Time_Stamp_Type;
456 -- Returns the full name/time stamp of library file N. N should not
457 -- include path information. Note that if the file cannot be located
458 -- No_File is returned for the first routine and an all blank time stamp
459 -- is returned for the second (this is not an error situation). The
460 -- full name includes the appropriate directory information. The library
461 -- file directory lookup penalty is incurred every single time this
462 -- routine is called.
464 function Lib_File_Name (Source_File : File_Name_Type) return File_Name_Type;
465 -- Given the name of a source file, returns the name of the corresponding
466 -- library information file. This may be the name of the object file, or
467 -- of a separate file used to store the library information. In either case
468 -- the returned result is suitable for use in a call to Read_Library_Info.
469 -- Note: this subprogram is in this section because it is used by the
470 -- compiler to determine the proper library information names to be placed
471 -- in the generated library information file.
477 type Exit_Code_Type is (
478 E_Success, -- No warnings or errors
479 E_Warnings, -- Compiler warnings generated
480 E_No_Code, -- No code generated
481 E_No_Compile, -- Compilation not needed (smart recompilation)
482 E_Errors, -- Compiler error messages generated
483 E_Fatal, -- Fatal (serious) error, e.g. source file not found
484 E_Abort); -- Internally detected compiler error
486 procedure Exit_Program (Exit_Code : Exit_Code_Type);
487 pragma No_Return (Exit_Program);
488 -- A call to Exit_Program terminates execution with the given status.
489 -- A status of zero indicates normal completion, a non-zero status
490 -- indicates abnormal termination.
492 -------------------------
493 -- Command Line Access --
494 -------------------------
496 -- Direct interface to command line parameters. (We don't want to use
497 -- the predefined command line package because it defines functions
500 function Arg_Count return Natural;
501 pragma Import (C, Arg_Count, "__gnat_arg_count");
502 -- Get number of arguments (note: optional globbing may be enabled)
504 procedure Fill_Arg (A : System.Address; Arg_Num : Integer);
505 pragma Import (C, Fill_Arg, "__gnat_fill_arg");
506 -- Store one argument
508 function Len_Arg (Arg_Num : Integer) return Integer;
509 pragma Import (C, Len_Arg, "__gnat_len_arg");
510 -- Get length of argument
514 ALI_Suffix : constant String_Ptr := new String'("ali");
515 -- The suffix used for the library files (also known as ALI files).
517 Current_Main : File_Name_Type := No_File;
518 -- Used to save a simple file name between calls to Next_Main_Source and
519 -- Read_Source_File. If the file name argument to Read_Source_File is
520 -- No_File, that indicates that the file whose name was returned by the
521 -- last call to Next_Main_Source (and stored here) is to be read.
523 Object_Suffix : constant String := Get_Object_Suffix.all;
524 -- The suffix used for the object files.
526 Output_FD : File_Descriptor;
527 -- The file descriptor for the current library info, tree or binder output
529 Output_File_Name : File_Name_Type;
530 -- File_Name_Type for name of open file whose FD is in Output_FD, the name
531 -- stored does not include the trailing NUL character.
533 Argument_Count : constant Integer := Arg_Count - 1;
534 -- Number of arguments (excluding program name)
536 type File_Name_Array is array (Int range <>) of String_Ptr;
537 type File_Name_Array_Ptr is access File_Name_Array;
538 File_Names : File_Name_Array_Ptr :=
539 new File_Name_Array (1 .. Int (Argument_Count) + 2);
540 -- As arguments are scanned in Initialize, file names are stored
541 -- in this array. The string does not contain a terminating NUL.
542 -- The array is "extensible" because when using project files,
543 -- there may be more file names than argument on the command line.
545 Current_File_Name_Index : Int := 0;
546 -- The index in File_Names of the last file opened by Next_Main_Source
547 -- or Next_Main_Lib_File. The value 0 indicates that no files have been
550 procedure Create_File_And_Check
551 (Fdesc : out File_Descriptor;
553 -- Create file whose name (NUL terminated) is in Name_Buffer (with the
554 -- length in Name_Len), and place the resulting descriptor in Fdesc.
555 -- Issue message and exit with fatal error if file cannot be created.
556 -- The Fmode parameter is set to either Text or Binary (see description
557 -- of GNAT.OS_Lib.Create_File).
559 type Program_Type is (Compiler, Binder, Make, Gnatls, Unspecified);
560 -- Program currently running
561 procedure Set_Program (P : Program_Type);
562 -- Indicates to the body of Osint the program currently running.
563 -- This procedure is called by the child packages of Osint.
564 -- A check is made that this procedure is not called several times.
566 function More_Files return Boolean;
567 -- Implements More_Source_Files and More_Lib_Files.
569 function Next_Main_File return File_Name_Type;
570 -- Implements Next_Main_Source and Next_Main_Lib_File.
572 function Object_File_Name (N : File_Name_Type) return File_Name_Type;
573 -- Constructs the name of the object file corresponding to library
574 -- file N. If N is a full file name than the returned file name will
575 -- also be a full file name. Note that no lookup in the library file
576 -- directories is done for this file. This routine merely constructs
579 procedure Write_Info (Info : String);
580 -- Implementation of Write_Binder_Info, Write_Debug_Info and
581 -- Write_Library_Info (identical)
projects / gcc.git / blob