Skip several gcc.dg/builtin-dynamic-object-size tests on hppa*-*-hpux*
[official-gcc.git] / gcc / ada / make.adb
blobf2ce7193a2dcb61f7ddda38f72410286a122d490
1 ------------------------------------------------------------------------------
2 -- --
3 -- GNAT COMPILER COMPONENTS --
4 -- --
5 -- M A K E --
6 -- --
7 -- B o d y --
8 -- --
9 -- Copyright (C) 1992-2023, 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 ------------------------------------------------------------------------------
26 with ALI; use ALI;
27 with ALI.Util; use ALI.Util;
28 with Csets;
29 with Debug;
30 with Fmap;
31 with Fname; use Fname;
32 with Fname.SF;
33 with Fname.UF; use Fname.UF;
34 with Gnatvsn; use Gnatvsn;
35 with Hostparm; use Hostparm;
36 with Makeusg;
37 with Make_Util; use Make_Util;
38 with Namet; use Namet;
39 with Opt; use Opt;
40 with Osint.M; use Osint.M;
41 with Osint; use Osint;
42 with Output; use Output;
43 with SFN_Scan;
44 with Sinput;
45 with Snames;
46 with Stringt;
47 with Uintp;
49 pragma Warnings (Off);
50 with System.HTable;
51 pragma Warnings (On);
53 with Switch; use Switch;
54 with Switch.M; use Switch.M;
55 with Table;
56 with Targparm;
57 with Tempdir;
58 with Types; use Types;
60 with Ada.Command_Line; use Ada.Command_Line;
61 with Ada.Directories;
62 with Ada.Exceptions; use Ada.Exceptions;
64 with GNAT.Command_Line; use GNAT.Command_Line;
65 with GNAT.Ctrl_C;
66 with GNAT.Directory_Operations; use GNAT.Directory_Operations;
67 with GNAT.OS_Lib; use GNAT.OS_Lib;
69 package body Make is
71 use ASCII;
72 -- Make control characters visible
74 Standard_Library_Package_Body_Name : constant String := "s-stalib.adb";
75 System_Package_Spec_Name : constant String := "system.ads";
76 -- Every program depends on one of these packages: usually the first one,
77 -- or if Supress_Standard_Library is true on the second one. The dependency
78 -- is not always explicit and considering it is important when -f and -a
79 -- are used.
81 procedure Sigint_Intercepted;
82 pragma No_Return (Sigint_Intercepted);
83 -- Called when the program is interrupted by Ctrl-C to delete the
84 -- temporary mapping files and configuration pragmas files.
86 No_Mapping_File : constant Natural := 0;
88 type Compilation_Data is record
89 Pid : Process_Id;
90 Full_Source_File : File_Name_Type;
91 Lib_File : File_Name_Type;
92 Source_Unit : Unit_Name_Type;
93 Full_Lib_File : File_Name_Type;
94 Lib_File_Attr : aliased File_Attributes;
95 Mapping_File : Natural := No_Mapping_File;
96 end record;
97 -- Data recorded for each compilation process spawned
99 No_Compilation_Data : constant Compilation_Data :=
100 (Invalid_Pid, No_File, No_File, No_Unit_Name, No_File, Unknown_Attributes,
101 No_Mapping_File);
103 type Comp_Data_Arr is array (Positive range <>) of Compilation_Data;
104 type Comp_Data_Ptr is access Comp_Data_Arr;
105 Running_Compile : Comp_Data_Ptr;
106 -- Used to save information about outstanding compilations
108 Outstanding_Compiles : Natural := 0;
109 -- Current number of outstanding compiles
111 procedure Initialize;
113 Project_File_Name_Present : Boolean := False;
115 Project_File_Name : String_Access := null;
117 -------------------------
118 -- Note on terminology --
119 -------------------------
121 -- In this program, we use the phrase "termination" of a file name to refer
122 -- to the suffix that appears after the unit name portion. Very often this
123 -- is simply the extension, but in some cases, the sequence may be more
124 -- complex, for example in main.1.ada, the termination in this name is
125 -- ".1.ada" and in main_.ada the termination is "_.ada".
127 Unique_Compile : Boolean := False;
128 -- Set to True if -u or -U is used
130 Must_Compile : Boolean := False;
131 -- True if gnatmake is invoked with -f -u and one or several mains on the
132 -- command line.
134 Main_On_Command_Line : Boolean := False;
135 -- True if gnatmake is invoked with one or several mains on the command
136 -- line.
138 RTS_Specified : String_Access := null;
139 -- Used to detect multiple --RTS= switches
141 N_M_Switch : Natural := 0;
142 -- Used to count -mxxx switches that can affect multilib
144 -- The 3 following packages are used to store gcc, gnatbind and gnatlink
145 -- switches found in the project files.
147 package Gcc_Switches is new Table.Table (
148 Table_Component_Type => String_Access,
149 Table_Index_Type => Integer,
150 Table_Low_Bound => 1,
151 Table_Initial => 20,
152 Table_Increment => 100,
153 Table_Name => "Make.Gcc_Switches");
155 package Binder_Switches is new Table.Table (
156 Table_Component_Type => String_Access,
157 Table_Index_Type => Integer,
158 Table_Low_Bound => 1,
159 Table_Initial => 20,
160 Table_Increment => 100,
161 Table_Name => "Make.Binder_Switches");
163 package Linker_Switches is new Table.Table (
164 Table_Component_Type => String_Access,
165 Table_Index_Type => Integer,
166 Table_Low_Bound => 1,
167 Table_Initial => 20,
168 Table_Increment => 100,
169 Table_Name => "Make.Linker_Switches");
171 package Switches_To_Check is new Table.Table (
172 Table_Component_Type => String_Access,
173 Table_Index_Type => Integer,
174 Table_Low_Bound => 1,
175 Table_Initial => 20,
176 Table_Increment => 100,
177 Table_Name => "Make.Switches_To_Check");
179 package Failed_Links is new Table.Table (
180 Table_Component_Type => File_Name_Type,
181 Table_Index_Type => Integer,
182 Table_Low_Bound => 1,
183 Table_Initial => 10,
184 Table_Increment => 100,
185 Table_Name => "Make.Failed_Links");
187 package Successful_Links is new Table.Table (
188 Table_Component_Type => File_Name_Type,
189 Table_Index_Type => Integer,
190 Table_Low_Bound => 1,
191 Table_Initial => 10,
192 Table_Increment => 100,
193 Table_Name => "Make.Successful_Links");
195 Normalized_Switches : Argument_List_Access := new Argument_List (1 .. 10);
196 Last_Norm_Switch : Natural := 0;
198 Map_File : String_Access := null;
199 -- Value of switch --create-map-file
201 procedure Add_Library_Search_Dir (Path : String);
202 -- Call Add_Lib_Search_Dir with an absolute directory path. If Path is
203 -- relative path, it is relative to the current working directory.
205 procedure Add_Source_Search_Dir (Path : String);
206 -- Call Add_Src_Search_Dir with an absolute directory path. If Path is a
207 -- relative path, it is relative to the current working directory.
209 type Bad_Compilation_Info is record
210 File : File_Name_Type;
211 Unit : Unit_Name_Type;
212 Found : Boolean;
213 end record;
214 -- File is the name of the file for which a compilation failed. Unit is for
215 -- gnatdist use in order to easily get the unit name of a file when its
216 -- name is krunched or declared in gnat.adc. Found is False if the
217 -- compilation failed because the file could not be found.
219 package Bad_Compilation is new Table.Table (
220 Table_Component_Type => Bad_Compilation_Info,
221 Table_Index_Type => Natural,
222 Table_Low_Bound => 1,
223 Table_Initial => 20,
224 Table_Increment => 100,
225 Table_Name => "Make.Bad_Compilation");
226 -- Full name of all the source files for which compilation fails
228 Do_Compile_Step : Boolean := True;
229 Do_Bind_Step : Boolean := True;
230 Do_Link_Step : Boolean := True;
231 -- Flags to indicate what step should be executed. Can be set to False
232 -- with the switches -c, -b and -l. These flags are reset to True for
233 -- each invocation of procedure Gnatmake.
235 CodePeer_Mode_String : aliased String := "-P";
237 No_Shared_Switch : aliased Argument_List := (1 .. 0 => null);
238 Bind_Shared : Argument_List_Access := No_Shared_Switch'Access;
239 -- Switch to added in front of gnatbind switches. By default no switch is
240 -- added. Switch "-shared" is added if there is a non-static Library
241 -- Project File.
243 Shared_Libgcc : aliased String := "-shared-libgcc";
245 No_Shared_Libgcc_Switch : aliased Argument_List := (1 .. 0 => null);
246 Shared_Libgcc_Switch : aliased Argument_List :=
247 (1 => Shared_Libgcc'Access);
248 Link_With_Shared_Libgcc : Argument_List_Access :=
249 No_Shared_Libgcc_Switch'Access;
251 procedure Make_Failed (S : String);
252 pragma No_Return (Make_Failed);
253 -- Delete all temp files created by Gnatmake and call Osint.Fail, with the
254 -- parameter S (see osint.ads).
256 --------------------------
257 -- Obsolete Executables --
258 --------------------------
260 Executable_Obsolete : Boolean := False;
261 -- Executable_Obsolete is initially set to False for each executable,
262 -- and is set to True whenever one of the source of the executable is
263 -- compiled, or has already been compiled for another executable.
265 Max_Header : constant := 200;
266 -- This needs a proper comment, it used to say "arbitrary" that's not an
267 -- adequate comment ???
269 type Header_Num is range 1 .. Max_Header;
270 -- Header_Num for the hash table Obsoleted below
272 function Hash (F : File_Name_Type) return Header_Num;
273 -- Hash function for the hash table Obsoleted below
275 package Obsoleted is new System.HTable.Simple_HTable
276 (Header_Num => Header_Num,
277 Element => Boolean,
278 No_Element => False,
279 Key => File_Name_Type,
280 Hash => Hash,
281 Equal => "=");
282 -- A hash table to keep all files that have been compiled, to detect
283 -- if an executable is up to date or not.
285 procedure Enter_Into_Obsoleted (F : File_Name_Type);
286 -- Enter a file name, without directory information, into the hash table
287 -- Obsoleted.
289 function Is_In_Obsoleted (F : File_Name_Type) return Boolean;
290 -- Check if a file name, without directory information, has already been
291 -- entered into the hash table Obsoleted.
293 type Dependency is record
294 This : File_Name_Type;
295 Depends_On : File_Name_Type;
296 end record;
297 -- Components of table Dependencies below
299 package Dependencies is new Table.Table (
300 Table_Component_Type => Dependency,
301 Table_Index_Type => Integer,
302 Table_Low_Bound => 1,
303 Table_Initial => 20,
304 Table_Increment => 100,
305 Table_Name => "Make.Dependencies");
306 -- A table to keep dependencies, to be able to decide if an executable
307 -- is obsolete. More explanation needed ???
309 ----------------------------
310 -- Arguments and Switches --
311 ----------------------------
313 Arguments : Argument_List_Access;
314 -- Used to gather the arguments for invocation of the compiler
316 Last_Argument : Natural := 0;
317 -- Last index of arguments in Arguments above
319 Dummy_Switch : constant String_Access := new String'("- ");
320 -- Used to initialized Prev_Switch in procedure Check
322 procedure Add_Arguments (Args : Argument_List);
323 -- Add arguments to global variable Arguments, increasing its size
324 -- if necessary and adjusting Last_Argument.
326 -------------------
327 -- Misc Routines --
328 -------------------
330 procedure List_Depend;
331 -- Prints to standard output the list of object dependencies. This list
332 -- can be used directly in a Makefile. A call to Compile_Sources must
333 -- precede the call to List_Depend. Also because this routine uses the
334 -- ALI files that were originally loaded and scanned by Compile_Sources,
335 -- no additional ALI files should be scanned between the two calls (i.e.
336 -- between the call to Compile_Sources and List_Depend.)
338 procedure List_Bad_Compilations;
339 -- Prints out the list of all files for which the compilation failed
341 Usage_Needed : Boolean := True;
342 -- Flag used to make sure Makeusg is call at most once
344 procedure Usage;
345 -- Call Makeusg, if Usage_Needed is True.
346 -- Set Usage_Needed to False.
348 procedure Debug_Msg (S : String; N : Name_Id);
349 procedure Debug_Msg (S : String; N : File_Name_Type);
350 procedure Debug_Msg (S : String; N : Unit_Name_Type);
351 -- If Debug.Debug_Flag_W is set outputs string S followed by name N
353 -----------------------
354 -- Gnatmake Routines --
355 -----------------------
357 subtype Lib_Mark_Type is Byte;
358 -- Used in Mark_Directory
360 Ada_Lib_Dir : constant Lib_Mark_Type := 1;
361 -- Used to mark a directory as a GNAT lib dir
363 -- Note that the notion of GNAT lib dir is no longer used. The code related
364 -- to it has not been removed to give an idea on how to use the directory
365 -- prefix marking mechanism.
367 -- An Ada library directory is a directory containing ali and object files
368 -- but no source files for the bodies (the specs can be in the same or some
369 -- other directory). These directories are specified in the Gnatmake
370 -- command line with the switch "-Adir" (to specify the spec location -Idir
371 -- cab be used). Gnatmake skips the missing sources whose ali are in Ada
372 -- library directories. For an explanation of why Gnatmake behaves that
373 -- way, see the spec of Make.Compile_Sources. The directory lookup penalty
374 -- is incurred every single time this routine is called.
376 function In_Ada_Lib_Dir (File : File_Name_Type) return Boolean;
377 -- Get directory prefix of this file and get lib mark stored in name
378 -- table for this directory. Then check if an Ada lib mark has been set.
380 procedure Mark_Directory (Dir : String; Mark : Lib_Mark_Type);
381 -- Store the absolute path from Dir in name table and set lib mark as name
382 -- info to identify Ada libraries.
384 -- If Dir is a relative path, it is relative to the current working
385 -- directory.
387 Output_Is_Object : Boolean := True;
388 -- Set to False when using a switch -S for the compiler
390 procedure Check_For_S_Switch;
391 -- Set Output_Is_Object to False when the -S switch is used for the
392 -- compiler.
394 procedure Process_Multilib;
395 -- Add appropriate --RTS argument to handle multilib
397 procedure Compute_Executable
398 (Main_Source_File : File_Name_Type;
399 Executable : out File_Name_Type;
400 Non_Std_Executable : out Boolean);
401 -- Parse the linker switches and project file to compute the name of the
402 -- executable to generate.
404 -- When the platform expects a specific extension for the generated binary,
405 -- there is a chance that the linker might not use the right name for the
406 -- it. Non_Std_Executable is set to True in this case.
408 procedure Compilation_Phase
409 (Main_Source_File : File_Name_Type;
410 Current_Main_Index : Int := 0;
411 Total_Compilation_Failures : in out Natural;
412 Executable : File_Name_Type := No_File;
413 Stop_Compile : out Boolean);
414 -- Build all source files for a given main file
416 -- Current_Main_Index, if not zero, is the index of the current main unit
417 -- in its source file.
419 -- Stand_Alone_Libraries is set to True when there are Stand-Alone
420 -- Libraries, so that gnatbind is invoked with the -F switch to force
421 -- checking of elaboration flags.
423 -- Stop_Compile is set to true if we should not try to compile any more
424 -- of the main units
426 procedure Binding_Phase
427 (Main_ALI_File : File_Name_Type);
428 -- Stand_Alone_Libraries should be set to True when there are Stand-Alone
429 -- Libraries, so that gnatbind is invoked with the -F switch to force
430 -- checking of elaboration flags.
432 procedure Linking_Phase
433 (Non_Std_Executable : Boolean := False;
434 Executable : File_Name_Type := No_File;
435 Main_ALI_File : File_Name_Type);
436 -- Perform the link of a single executable. The ali file corresponds
437 -- to Main_ALI_File. Executable is the file name of an executable.
438 -- Non_Std_Executable is set to True when there is a possibility that
439 -- the linker will not choose the correct executable file name.
441 ----------------------------------------------------
442 -- Compiler, Binder & Linker Data and Subprograms --
443 ----------------------------------------------------
445 Gcc : String_Access := Program_Name ("gcc", "gnatmake");
446 Gnatbind : String_Access := Program_Name ("gnatbind", "gnatmake");
447 Gnatlink : String_Access := Program_Name ("gnatlink", "gnatmake");
448 -- Default compiler, binder, linker programs
450 Gcc_Path : String_Access :=
451 GNAT.OS_Lib.Locate_Exec_On_Path (Gcc.all);
452 Gnatbind_Path : String_Access :=
453 GNAT.OS_Lib.Locate_Exec_On_Path (Gnatbind.all);
454 Gnatlink_Path : String_Access :=
455 GNAT.OS_Lib.Locate_Exec_On_Path (Gnatlink.all);
456 -- Path for compiler, binder, linker programs, defaulted now for gnatdist.
457 -- Changed later if overridden on command line.
459 Comp_Flag : constant String_Access := new String'("-c");
460 Output_Flag : constant String_Access := new String'("-o");
461 Ada_Flag_1 : constant String_Access := new String'("-x");
462 Ada_Flag_2 : constant String_Access := new String'("ada");
463 AdaSCIL_Flag : constant String_Access := new String'("adascil");
464 GNAT_Flag : constant String_Access := new String'("-gnatg");
465 Do_Not_Check_Flag : constant String_Access := new String'("-x");
467 Object_Suffix : constant String := Get_Target_Object_Suffix.all;
469 Syntax_Only : Boolean := False;
470 -- Set to True when compiling with -gnats
472 Output_File_Name_Seen : Boolean := False;
473 -- Set to True after having scanned the file_name for
474 -- switch "-o file_name"
476 Object_Directory_Seen : Boolean := False;
477 -- Set to True after having scanned the object directory for
478 -- switch "-D obj_dir".
480 Object_Directory_Path : String_Access := null;
481 -- The path name of the object directory, set with switch -D
483 type Make_Program_Type is (None, Compiler, Binder, Linker);
485 Program_Args : Make_Program_Type := None;
486 -- Used to indicate if we are scanning gnatmake, gcc, gnatbind, or gnatbind
487 -- options within the gnatmake command line. Used in Scan_Make_Arg only,
488 -- but must be global since value preserved from one call to another.
490 procedure Add_Switch
491 (S : String_Access;
492 Program : Make_Program_Type;
493 Append_Switch : Boolean := True);
494 procedure Add_Switch
495 (S : String;
496 Program : Make_Program_Type;
497 Append_Switch : Boolean := True);
498 -- Make invokes one of three programs (the compiler, the binder or the
499 -- linker). For the sake of convenience, some program specific switches
500 -- can be passed directly on the gnatmake command line. This procedure
501 -- records these switches so that gnatmake can pass them to the right
502 -- program. S is the switch to be added at the end of the command line
503 -- for Program if Append_Switch is True. If Append_Switch is False S is
504 -- added at the beginning of the command line.
506 procedure Check
507 (Source_File : File_Name_Type;
508 The_Args : Argument_List;
509 Lib_File : File_Name_Type;
510 Full_Lib_File : File_Name_Type;
511 Lib_File_Attr : access File_Attributes;
512 Read_Only : Boolean;
513 ALI : out ALI_Id;
514 O_File : out File_Name_Type;
515 O_Stamp : out Time_Stamp_Type);
516 -- Determines whether the library file Lib_File is up-to-date or not. The
517 -- full name (with path information) of the object file corresponding to
518 -- Lib_File is returned in O_File. Its time stamp is saved in O_Stamp.
519 -- ALI is the ALI_Id corresponding to Lib_File. If Lib_File in not
520 -- up-to-date, then the corresponding source file needs to be recompiled.
521 -- In this case ALI = No_ALI_Id.
522 -- Full_Lib_File must be the result of calling Osint.Full_Lib_File_Name on
523 -- Lib_File. Precomputing it saves system calls. Lib_File_Attr is the
524 -- initialized attributes of that file, which is also used to save on
525 -- system calls (it can safely be initialized to Unknown_Attributes).
527 procedure Check_Linker_Options
528 (E_Stamp : Time_Stamp_Type;
529 O_File : out File_Name_Type;
530 O_Stamp : out Time_Stamp_Type);
531 -- Checks all linker options for linker files that are newer
532 -- than E_Stamp. If such objects are found, the youngest object
533 -- is returned in O_File and its stamp in O_Stamp.
535 -- If no obsolete linker files were found, the first missing
536 -- linker file is returned in O_File and O_Stamp is empty.
537 -- Otherwise O_File is No_File.
539 procedure Collect_Arguments (Args : Argument_List);
540 -- Collect all arguments for a source to be compiled.
542 procedure Display (Program : String; Args : Argument_List);
543 -- Displays Program followed by the arguments in Args if variable
544 -- Display_Executed_Programs is set. The lower bound of Args must be 1.
546 procedure Report_Compilation_Failed;
547 pragma No_Return (Report_Compilation_Failed);
548 -- Delete all temporary files and fail graciously
550 -----------------
551 -- Mapping files
552 -----------------
554 type Temp_Path_Names is array (Positive range <>) of Path_Name_Type;
555 type Temp_Path_Ptr is access Temp_Path_Names;
557 type Free_File_Indexes is array (Positive range <>) of Positive;
558 type Free_Indexes_Ptr is access Free_File_Indexes;
560 type Mapping_File_Data is record
561 Mapping_File_Names : Temp_Path_Ptr;
562 -- The name ids of the temporary mapping files used. This is indexed
563 -- on the maximum number of compilation processes we will be spawning
564 -- (-j parameter)
566 Last_Mapping_File_Names : Natural;
567 -- Index of the last mapping file created for this project
569 Free_Mapping_File_Indexes : Free_Indexes_Ptr;
570 -- Indexes in Mapping_File_Names of the mapping file names that can be
571 -- reused for subsequent compilations.
573 Last_Free_Indexes : Natural;
574 -- Number of mapping files that can be reused
575 end record;
576 -- Information necessary when compiling a project
578 The_Mapping_Files : Mapping_File_Data;
580 Gnatmake_Mapping_File : String_Access := null;
581 -- The path name of a mapping file specified by switch -C=
583 procedure Init_Mapping_File (File_Index : out Natural);
584 -- Create a new mapping file or reuse one already created.
586 package Temp_File_Paths is new Table.Table
587 (Table_Component_Type => Path_Name_Type,
588 Table_Index_Type => Natural,
589 Table_Low_Bound => 1,
590 Table_Initial => 4,
591 Table_Increment => 100,
592 Table_Name => "Make.Temp_File_Paths",
593 Release_Threshold => 0);
595 procedure Record_Temp_File (Path : Path_Name_Type);
596 -- Record the path of a temporary file, so that it can be deleted at the
597 -- end of execution of gnatmake.
599 procedure Record_Temp_File (Path : Path_Name_Type) is
600 begin
601 for J in 1 .. Temp_File_Paths.Last loop
602 if Temp_File_Paths.Table (J) = Path then
603 return;
604 end if;
605 end loop;
607 Temp_File_Paths.Append (Path);
608 end Record_Temp_File;
610 -------------------------------------------------
611 -- Subprogram declarations moved from the spec --
612 -------------------------------------------------
614 procedure Bind (ALI_File : File_Name_Type; Args : Argument_List);
615 -- Binds ALI_File. Args are the arguments to pass to the binder.
616 -- Args must have a lower bound of 1.
618 -- If a compilation, bind or link failed one of the following 3 exceptions
619 -- is raised. These need to be handled by the calling routines.
621 procedure Compile_Sources
622 (Main_Source : File_Name_Type;
623 Args : Argument_List;
624 First_Compiled_File : out File_Name_Type;
625 Most_Recent_Obj_File : out File_Name_Type;
626 Most_Recent_Obj_Stamp : out Time_Stamp_Type;
627 Main_Unit : out Boolean;
628 Compilation_Failures : out Natural;
629 Main_Index : Int := 0;
630 Check_Readonly_Files : Boolean := False;
631 Do_Not_Execute : Boolean := False;
632 Force_Compilations : Boolean := False;
633 Keep_Going : Boolean := False;
634 In_Place_Mode : Boolean := False;
635 Initialize_ALI_Data : Boolean := True;
636 Max_Process : Positive := 1);
637 -- Compile_Sources will recursively compile all the sources needed by
638 -- Main_Source. Before calling this routine make sure Namet has been
639 -- initialized. This routine can be called repeatedly with different
640 -- Main_Source file as long as all the source (-I flags), library
641 -- (-B flags) and ada library (-A flags) search paths between calls are
642 -- *exactly* the same. The default directory must also be the same.
644 -- Args contains the arguments to use during the compilations.
645 -- The lower bound of Args must be 1.
647 -- First_Compiled_File is set to the name of the first file that is
648 -- compiled or that needs to be compiled. This is set to No_Name if no
649 -- compilations were needed.
651 -- Most_Recent_Obj_File is set to the full name of the most recent
652 -- object file found when no compilations are needed, that is when
653 -- First_Compiled_File is set to No_Name. When First_Compiled_File
654 -- is set then Most_Recent_Obj_File is set to No_Name.
656 -- Most_Recent_Obj_Stamp is the time stamp of Most_Recent_Obj_File.
658 -- Main_Unit is set to True if Main_Source can be a main unit.
659 -- If Do_Not_Execute is False and First_Compiled_File /= No_Name
660 -- the value of Main_Unit is always False.
661 -- Is this used any more??? It is certainly not used by gnatmake???
663 -- Compilation_Failures is a count of compilation failures. This count
664 -- is used to extract compilation failure reports with Extract_Failure.
666 -- Main_Index, when not zero, is the index of the main unit in source
667 -- file Main_Source which is a multi-unit source.
668 -- Zero indicates that Main_Source is a single unit source file.
670 -- Check_Readonly_Files set it to True to compile source files
671 -- which library files are read-only. When compiling GNAT predefined
672 -- files the "-gnatg" flag is used.
674 -- Do_Not_Execute set it to True to find out the first source that
675 -- needs to be recompiled, but without recompiling it. This file is
676 -- saved in First_Compiled_File.
678 -- Force_Compilations forces all compilations no matter what but
679 -- recompiles read-only files only if Check_Readonly_Files
680 -- is set.
682 -- Keep_Going when True keep compiling even in the presence of
683 -- compilation errors.
685 -- In_Place_Mode when True save library/object files in their object
686 -- directory if they already exist; otherwise, in the source directory.
688 -- Initialize_ALI_Data set it to True when you want to initialize ALI
689 -- data-structures. This is what you should do most of the time.
690 -- (especially the first time around when you call this routine).
691 -- This parameter is set to False to preserve previously recorded
692 -- ALI file data.
694 -- Max_Process is the maximum number of processes that should be spawned
695 -- to carry out compilations.
697 -- Flags in Package Opt Affecting Compile_Sources
698 -- -----------------------------------------------
700 -- Check_Object_Consistency set it to False to omit all consistency
701 -- checks between an .ali file and its corresponding object file.
702 -- When this flag is set to true, every time an .ali is read,
703 -- package Osint checks that the corresponding object file
704 -- exists and is more recent than the .ali.
706 -- Use of Name Table Info
707 -- ----------------------
709 -- All file names manipulated by Compile_Sources are entered into the
710 -- Names table. The Byte field of a source file is used to mark it.
712 -- Calling Compile_Sources Several Times
713 -- -------------------------------------
715 -- Upon return from Compile_Sources all the ALI data structures are left
716 -- intact for further browsing. HOWEVER upon entry to this routine ALI
717 -- data structures are re-initialized if parameter Initialize_ALI_Data
718 -- above is set to true. Typically this is what you want the first time
719 -- you call Compile_Sources. You should not load an ali file, call this
720 -- routine with flag Initialize_ALI_Data set to True and then expect
721 -- that ALI information to be around after the call. Note that the first
722 -- time you call Compile_Sources you better set Initialize_ALI_Data to
723 -- True unless you have called Initialize_ALI yourself.
725 -- Compile_Sources ALGORITHM : Compile_Sources (Main_Source)
726 -- -------------------------
728 -- 1. Insert Main_Source in a Queue (Q) and mark it.
730 -- 2. Let unit.adb be the file at the head of the Q. If unit.adb is
731 -- missing but its corresponding ali file is in an Ada library directory
732 -- (see below) then, remove unit.adb from the Q and goto step 4.
733 -- Otherwise, look at the files under the D (dependency) section of
734 -- unit.ali. If unit.ali does not exist or some of the time stamps do
735 -- not match, (re)compile unit.adb.
737 -- An Ada library directory is a directory containing Ada specs, ali
738 -- and object files but no source files for the bodies. An Ada library
739 -- directory is communicated to gnatmake by means of some switch so that
740 -- gnatmake can skip the sources whole ali are in that directory.
741 -- There are two reasons for skipping the sources in this case. Firstly,
742 -- Ada libraries typically come without full sources but binding and
743 -- linking against those libraries is still possible. Secondly, it would
744 -- be very wasteful for gnatmake to systematically check the consistency
745 -- of every external Ada library used in a program. The binder is
746 -- already in charge of catching any potential inconsistencies.
748 -- 3. Look into the W section of unit.ali and insert into the Q all
749 -- unmarked source files. Mark all files newly inserted in the Q.
750 -- Specifically, assuming that the W section looks like
752 -- W types%s types.adb types.ali
753 -- W unchecked_deallocation%s
754 -- W xref_tab%s xref_tab.adb xref_tab.ali
756 -- Then xref_tab.adb and types.adb are inserted in the Q if they are not
757 -- already marked.
758 -- Note that there is no file listed under W unchecked_deallocation%s
759 -- so no generic body should ever be explicitly compiled (unless the
760 -- Main_Source at the start was a generic body).
762 -- 4. Repeat steps 2 and 3 above until the Q is empty
764 -- Note that the above algorithm works because the units withed in
765 -- subunits are transitively included in the W section (with section) of
766 -- the main unit. Likewise the withed units in a generic body needed
767 -- during a compilation are also transitively included in the W section
768 -- of the originally compiled file.
770 procedure Link
771 (ALI_File : File_Name_Type;
772 Args : Argument_List;
773 Success : out Boolean);
774 -- Links ALI_File. Args are the arguments to pass to the linker.
775 -- Args must have a lower bound of 1. Success indicates if the link
776 -- succeeded or not.
778 Gnatmake_Switch_Found : Boolean := False;
780 procedure Scan_Make_Arg (Argv : String);
781 -- Scan make arguments. Argv is a single argument to be processed.
783 -------------------
784 -- Add_Arguments --
785 -------------------
787 procedure Add_Arguments (Args : Argument_List) is
788 begin
789 if Arguments = null then
790 Arguments := new Argument_List (1 .. Args'Length + 10);
792 else
793 while Last_Argument + Args'Length > Arguments'Last loop
794 declare
795 New_Arguments : constant Argument_List_Access :=
796 new Argument_List (1 .. Arguments'Last * 2);
797 begin
798 New_Arguments (1 .. Last_Argument) :=
799 Arguments (1 .. Last_Argument);
800 Arguments := New_Arguments;
801 end;
802 end loop;
803 end if;
805 Arguments (Last_Argument + 1 .. Last_Argument + Args'Length) := Args;
806 Last_Argument := Last_Argument + Args'Length;
807 end Add_Arguments;
809 ----------------------------
810 -- Add_Library_Search_Dir --
811 ----------------------------
813 procedure Add_Library_Search_Dir (Path : String) is
814 begin
815 Add_Lib_Search_Dir (Normalize_Pathname (Path));
816 end Add_Library_Search_Dir;
818 ---------------------------
819 -- Add_Source_Search_Dir --
820 ---------------------------
822 procedure Add_Source_Search_Dir (Path : String) is
823 begin
824 Add_Src_Search_Dir (Normalize_Pathname (Path));
825 end Add_Source_Search_Dir;
827 ----------------
828 -- Add_Switch --
829 ----------------
831 procedure Add_Switch
832 (S : String_Access;
833 Program : Make_Program_Type;
834 Append_Switch : Boolean := True)
836 generic
837 with package T is new Table.Table (<>);
838 procedure Generic_Position (New_Position : out Integer);
839 -- Generic procedure that chooses a position for S in T at the
840 -- beginning or the end, depending on the boolean Append_Switch.
841 -- Calling this procedure may expand the table.
843 ----------------------
844 -- Generic_Position --
845 ----------------------
847 procedure Generic_Position (New_Position : out Integer) is
848 begin
849 T.Increment_Last;
851 if Append_Switch then
852 New_Position := Integer (T.Last);
853 else
854 for J in reverse T.Table_Index_Type'Succ (T.First) .. T.Last loop
855 T.Table (J) := T.Table (T.Table_Index_Type'Pred (J));
856 end loop;
858 New_Position := Integer (T.First);
859 end if;
860 end Generic_Position;
862 procedure Gcc_Switches_Pos is new Generic_Position (Gcc_Switches);
863 procedure Binder_Switches_Pos is new Generic_Position (Binder_Switches);
864 procedure Linker_Switches_Pos is new Generic_Position (Linker_Switches);
866 New_Position : Integer;
868 -- Start of processing for Add_Switch
870 begin
871 case Program is
872 when Compiler =>
873 Gcc_Switches_Pos (New_Position);
874 Gcc_Switches.Table (New_Position) := S;
876 when Binder =>
877 Binder_Switches_Pos (New_Position);
878 Binder_Switches.Table (New_Position) := S;
880 when Linker =>
881 Linker_Switches_Pos (New_Position);
882 Linker_Switches.Table (New_Position) := S;
884 when None =>
885 raise Program_Error;
886 end case;
887 end Add_Switch;
889 procedure Add_Switch
890 (S : String;
891 Program : Make_Program_Type;
892 Append_Switch : Boolean := True)
894 begin
895 Add_Switch (S => new String'(S),
896 Program => Program,
897 Append_Switch => Append_Switch);
898 end Add_Switch;
900 ----------
901 -- Bind --
902 ----------
904 procedure Bind (ALI_File : File_Name_Type; Args : Argument_List) is
905 Bind_Args : Argument_List (1 .. Args'Last + 2);
906 Bind_Last : Integer;
907 Success : Boolean;
909 begin
910 pragma Assert (Args'First = 1);
912 -- Optimize the simple case where the gnatbind command line looks like
913 -- gnatbind -aO. -I- file.ali
914 -- into
915 -- gnatbind file.adb
917 if Args'Length = 2
918 and then Args (Args'First).all = "-aO" & Normalized_CWD
919 and then Args (Args'Last).all = "-I-"
920 and then ALI_File = Strip_Directory (ALI_File)
921 then
922 Bind_Last := Args'First - 1;
924 else
925 Bind_Last := Args'Last;
926 Bind_Args (Args'Range) := Args;
927 end if;
929 -- It is completely pointless to re-check source file time stamps. This
930 -- has been done already by gnatmake
932 Bind_Last := Bind_Last + 1;
933 Bind_Args (Bind_Last) := Do_Not_Check_Flag;
935 Get_Name_String (ALI_File);
937 Bind_Last := Bind_Last + 1;
938 Bind_Args (Bind_Last) := new String'(Name_Buffer (1 .. Name_Len));
940 GNAT.OS_Lib.Normalize_Arguments (Bind_Args (Args'First .. Bind_Last));
942 Display (Gnatbind.all, Bind_Args (Args'First .. Bind_Last));
944 if Gnatbind_Path = null then
945 Make_Failed ("error, unable to locate " & Gnatbind.all);
946 end if;
948 GNAT.OS_Lib.Spawn
949 (Gnatbind_Path.all, Bind_Args (Args'First .. Bind_Last), Success);
951 if not Success then
952 Make_Failed ("*** bind failed.");
953 end if;
954 end Bind;
956 -----------
957 -- Check --
958 -----------
960 procedure Check
961 (Source_File : File_Name_Type;
962 The_Args : Argument_List;
963 Lib_File : File_Name_Type;
964 Full_Lib_File : File_Name_Type;
965 Lib_File_Attr : access File_Attributes;
966 Read_Only : Boolean;
967 ALI : out ALI_Id;
968 O_File : out File_Name_Type;
969 O_Stamp : out Time_Stamp_Type)
971 function First_New_Spec (A : ALI_Id) return File_Name_Type;
972 -- Looks in the with table entries of A and returns the spec file name
973 -- of the first withed unit (subprogram) for which no spec existed when
974 -- A was generated but for which there exists one now, implying that A
975 -- is now obsolete. If no such unit is found No_File is returned.
976 -- Otherwise the spec file name of the unit is returned.
978 -- **WARNING** in the event of Uname format modifications, one *MUST*
979 -- make sure this function is also updated.
981 -- Note: This function should really be in ali.adb and use Uname
982 -- services, but this causes the whole compiler to be dragged along
983 -- for gnatbind and gnatmake.
985 --------------------
986 -- First_New_Spec --
987 --------------------
989 function First_New_Spec (A : ALI_Id) return File_Name_Type is
990 Spec_File_Name : File_Name_Type := No_File;
992 function New_Spec (Uname : Unit_Name_Type) return Boolean;
993 -- Uname is the name of the spec or body of some ada unit. This
994 -- function returns True if the Uname is the name of a body which has
995 -- a spec not mentioned in ALI file A. If True is returned
996 -- Spec_File_Name above is set to the name of this spec file.
998 --------------
999 -- New_Spec --
1000 --------------
1002 function New_Spec (Uname : Unit_Name_Type) return Boolean is
1003 Spec_Name : Unit_Name_Type;
1004 File_Name : File_Name_Type;
1006 begin
1007 -- Test whether Uname is the name of a body unit (i.e. ends
1008 -- with %b).
1010 Get_Name_String (Uname);
1011 pragma
1012 Assert (Name_Len > 2 and then Name_Buffer (Name_Len - 1) = '%');
1014 if Name_Buffer (Name_Len) /= 'b' then
1015 return False;
1016 end if;
1018 -- Convert unit name into spec name
1020 -- ??? this code seems dubious in presence of pragma
1021 -- Source_File_Name since there is no more direct relationship
1022 -- between unit name and file name.
1024 -- ??? Further, what about alternative subunit naming
1026 Name_Buffer (Name_Len) := 's';
1027 Spec_Name := Name_Find;
1028 File_Name := Get_File_Name (Spec_Name, Subunit => False);
1030 -- Look if File_Name is mentioned in A's sdep list.
1031 -- If not look if the file exists. If it does return True.
1033 for D in
1034 ALIs.Table (A).First_Sdep .. ALIs.Table (A).Last_Sdep
1035 loop
1036 if Sdep.Table (D).Sfile = File_Name then
1037 return False;
1038 end if;
1039 end loop;
1041 if Full_Source_Name (File_Name) /= No_File then
1042 Spec_File_Name := File_Name;
1043 return True;
1044 end if;
1046 return False;
1047 end New_Spec;
1049 -- Start of processing for First_New_Spec
1051 begin
1052 U_Chk : for U in
1053 ALIs.Table (A).First_Unit .. ALIs.Table (A).Last_Unit
1054 loop
1055 exit U_Chk when Units.Table (U).Utype = Is_Body_Only
1056 and then New_Spec (Units.Table (U).Uname);
1058 for W in Units.Table (U).First_With
1060 Units.Table (U).Last_With
1061 loop
1062 exit U_Chk when
1063 Withs.Table (W).Afile /= No_File
1064 and then New_Spec (Withs.Table (W).Uname);
1065 end loop;
1066 end loop U_Chk;
1068 return Spec_File_Name;
1069 end First_New_Spec;
1071 ---------------------------------
1072 -- Data declarations for Check --
1073 ---------------------------------
1075 Full_Obj_File : File_Name_Type;
1076 -- Full name of the object file corresponding to Lib_File
1078 Lib_Stamp : Time_Stamp_Type;
1079 -- Time stamp of the current ada library file
1081 Obj_Stamp : Time_Stamp_Type;
1082 -- Time stamp of the current object file
1084 Modified_Source : File_Name_Type;
1085 -- The first source in Lib_File whose current time stamp differs from
1086 -- that stored in Lib_File.
1088 New_Spec : File_Name_Type;
1089 -- If Lib_File contains in its W (with) section a body (for a
1090 -- subprogram) for which there exists a spec, and the spec did not
1091 -- appear in the Sdep section of Lib_File, New_Spec contains the file
1092 -- name of this new spec.
1094 Source_Name : File_Name_Type;
1095 Text : Text_Buffer_Ptr;
1097 First_Arg : Arg_Id;
1098 -- Index of the first argument in Args.Table for a given unit
1100 Last_Arg : Arg_Id;
1101 -- Index of the last argument in Args.Table for a given unit
1103 Arg : Arg_Id := Arg_Id'First;
1104 -- Current index in Args.Table for a given unit (init to stop warning)
1106 Number_Of_Switches : Natural;
1107 -- Number of switches recorded for a given unit
1109 Prev_Switch : String_Access;
1110 -- Previous switch processed
1112 Switch_Found : Boolean;
1113 -- True if a given switch has been found
1115 begin
1116 pragma Assert (Lib_File /= No_File);
1118 -- If ALI file is read-only, temporarily set Check_Object_Consistency to
1119 -- False. We don't care if the object file is not there (presumably a
1120 -- library will be used for linking.)
1122 if Read_Only then
1123 declare
1124 Saved_Check_Object_Consistency : constant Boolean :=
1125 Check_Object_Consistency;
1126 begin
1127 Check_Object_Consistency := False;
1128 Text := Read_Library_Info_From_Full (Full_Lib_File, Lib_File_Attr);
1129 Check_Object_Consistency := Saved_Check_Object_Consistency;
1130 end;
1132 else
1133 Text := Read_Library_Info_From_Full (Full_Lib_File, Lib_File_Attr);
1134 end if;
1136 Full_Obj_File := Full_Object_File_Name;
1137 Lib_Stamp := Current_Library_File_Stamp;
1138 Obj_Stamp := Current_Object_File_Stamp;
1140 if Full_Lib_File = No_File then
1141 Verbose_Msg
1142 (Lib_File,
1143 "being checked ...",
1144 Prefix => " ",
1145 Minimum_Verbosity => Opt.Medium);
1146 else
1147 Verbose_Msg
1148 (Full_Lib_File,
1149 "being checked ...",
1150 Prefix => " ",
1151 Minimum_Verbosity => Opt.Medium);
1152 end if;
1154 ALI := No_ALI_Id;
1155 O_File := Full_Obj_File;
1156 O_Stamp := Obj_Stamp;
1158 if Text = null then
1159 if Full_Lib_File = No_File then
1160 Verbose_Msg (Lib_File, "missing.");
1162 elsif Obj_Stamp (Obj_Stamp'First) = ' ' then
1163 Verbose_Msg (Full_Obj_File, "missing.");
1165 else
1166 Verbose_Msg
1167 (Full_Lib_File, "(" & String (Lib_Stamp) & ") newer than",
1168 Full_Obj_File, "(" & String (Obj_Stamp) & ")");
1169 end if;
1171 else
1172 ALI := Scan_ALI (Lib_File, Text, Err => True);
1173 Free (Text);
1175 if ALI = No_ALI_Id then
1176 Verbose_Msg (Full_Lib_File, "incorrectly formatted ALI file");
1177 return;
1179 elsif ALIs.Table (ALI).Ver (1 .. ALIs.Table (ALI).Ver_Len) /=
1180 Verbose_Library_Version
1181 then
1182 Verbose_Msg (Full_Lib_File, "compiled with old GNAT version");
1183 ALI := No_ALI_Id;
1184 return;
1185 end if;
1187 -- Don't take ALI file into account if it was generated with errors
1189 if ALIs.Table (ALI).Compile_Errors then
1190 Verbose_Msg (Full_Lib_File, "had errors, must be recompiled");
1191 ALI := No_ALI_Id;
1192 return;
1193 end if;
1195 -- Don't take ALI file into account if no object was generated
1197 if Operating_Mode /= Check_Semantics
1198 and then ALIs.Table (ALI).No_Object
1199 then
1200 Verbose_Msg (Full_Lib_File, "has no corresponding object");
1201 ALI := No_ALI_Id;
1202 return;
1203 end if;
1205 -- When compiling with -gnatc, don't take ALI file into account if
1206 -- it has not been generated for the current source, for example if
1207 -- it has been generated for the spec, but we are compiling the body.
1209 if Operating_Mode = Check_Semantics then
1210 declare
1211 File_Name : String := Get_Name_String (Source_File);
1212 OK : Boolean := False;
1214 begin
1215 -- In the ALI file, the source file names are in canonical case
1217 Canonical_Case_File_Name (File_Name);
1219 for U in ALIs.Table (ALI).First_Unit ..
1220 ALIs.Table (ALI).Last_Unit
1221 loop
1222 OK := Get_Name_String (Units.Table (U).Sfile) = File_Name;
1223 exit when OK;
1224 end loop;
1226 if not OK then
1227 Verbose_Msg
1228 (Full_Lib_File, "not generated for the same source");
1229 ALI := No_ALI_Id;
1230 return;
1231 end if;
1232 end;
1233 end if;
1235 -- Check for matching compiler switches if needed
1237 if Check_Switches then
1239 -- First, collect all the switches
1241 Collect_Arguments (The_Args);
1242 Prev_Switch := Dummy_Switch;
1243 Get_Name_String (ALIs.Table (ALI).Sfile);
1244 Switches_To_Check.Set_Last (0);
1246 for J in 1 .. Last_Argument loop
1248 -- Skip -c, -I and -o switches
1250 if Arguments (J) (1) = '-'
1251 and then Arguments (J) (2) /= 'c'
1252 and then Arguments (J) (2) /= 'o'
1253 and then Arguments (J) (2) /= 'I'
1254 then
1255 Normalize_Compiler_Switches
1256 (Arguments (J).all,
1257 Normalized_Switches,
1258 Last_Norm_Switch);
1260 for K in 1 .. Last_Norm_Switch loop
1261 Switches_To_Check.Increment_Last;
1262 Switches_To_Check.Table (Switches_To_Check.Last) :=
1263 Normalized_Switches (K);
1264 end loop;
1265 end if;
1266 end loop;
1268 First_Arg := Units.Table (ALIs.Table (ALI).First_Unit).First_Arg;
1269 Last_Arg := Units.Table (ALIs.Table (ALI).First_Unit).Last_Arg;
1271 for J in 1 .. Switches_To_Check.Last loop
1273 -- Comparing switches is delicate because gcc reorders a number
1274 -- of switches, according to lang-specs.h, but gnatmake doesn't
1275 -- have sufficient knowledge to perform the same reordering.
1276 -- Instead, we ignore orders between different "first letter"
1277 -- switches, but keep orders between same switches, e.g -O -O2
1278 -- is different than -O2 -O, but -g -O is equivalent to -O -g.
1280 if Switches_To_Check.Table (J) (2) /= Prev_Switch (2) or else
1281 (Prev_Switch'Length >= 6 and then
1282 Prev_Switch (2 .. 5) = "gnat" and then
1283 Switches_To_Check.Table (J)'Length >= 6 and then
1284 Switches_To_Check.Table (J) (2 .. 5) = "gnat" and then
1285 Prev_Switch (6) /= Switches_To_Check.Table (J) (6))
1286 then
1287 Prev_Switch := Switches_To_Check.Table (J);
1288 Arg := First_Arg;
1289 end if;
1291 Switch_Found := False;
1293 for K in Arg .. Last_Arg loop
1295 Switches_To_Check.Table (J).all = Args.Table (K).all
1296 then
1297 Arg := K + 1;
1298 Switch_Found := True;
1299 exit;
1300 end if;
1301 end loop;
1303 if not Switch_Found then
1304 if Verbose_Mode then
1305 Verbose_Msg (ALIs.Table (ALI).Sfile,
1306 "switch mismatch """ &
1307 Switches_To_Check.Table (J).all & '"');
1308 end if;
1310 ALI := No_ALI_Id;
1311 return;
1312 end if;
1313 end loop;
1315 Number_Of_Switches := Natural (Last_Arg - First_Arg + 1);
1317 -- Do not count the multilib switches reinstated by the compiler
1318 -- according to the lang-specs.h.settings.
1320 for K in First_Arg .. Last_Arg loop
1321 if Args.Table (K).all = "-mrtp" then
1322 Number_Of_Switches := Number_Of_Switches - 1;
1323 end if;
1324 end loop;
1326 if Switches_To_Check.Last /= Number_Of_Switches then
1327 if Verbose_Mode then
1328 Verbose_Msg (ALIs.Table (ALI).Sfile,
1329 "different number of switches");
1331 for K in First_Arg .. Last_Arg loop
1332 Write_Str (Args.Table (K).all);
1333 Write_Char (' ');
1334 end loop;
1336 Write_Eol;
1338 for J in 1 .. Switches_To_Check.Last loop
1339 Write_Str (Switches_To_Check.Table (J).all);
1340 Write_Char (' ');
1341 end loop;
1343 Write_Eol;
1344 end if;
1346 ALI := No_ALI_Id;
1347 return;
1348 end if;
1349 end if;
1351 -- Get the source files and their message digests. Note that some
1352 -- sources may be missing if ALI is out-of-date.
1354 Set_Source_Table (ALI);
1356 Modified_Source := Time_Stamp_Mismatch (ALI, Read_Only);
1358 -- To avoid using too much memory when switch -m is used, free the
1359 -- memory allocated for the source file when computing the checksum.
1361 if Minimal_Recompilation then
1362 Sinput.Clear_Source_File_Table;
1363 end if;
1365 if Modified_Source /= No_File then
1366 ALI := No_ALI_Id;
1368 if Verbose_Mode then
1369 Source_Name := Full_Source_Name (Modified_Source);
1371 if Source_Name /= No_File then
1372 Verbose_Msg (Source_Name, "time stamp mismatch");
1373 else
1374 Verbose_Msg (Modified_Source, "missing");
1375 end if;
1376 end if;
1378 else
1379 New_Spec := First_New_Spec (ALI);
1381 if New_Spec /= No_File then
1382 ALI := No_ALI_Id;
1384 if Verbose_Mode then
1385 Source_Name := Full_Source_Name (New_Spec);
1387 if Source_Name /= No_File then
1388 Verbose_Msg (Source_Name, "new spec");
1389 else
1390 Verbose_Msg (New_Spec, "old spec missing");
1391 end if;
1392 end if;
1394 end if;
1395 end if;
1396 end if;
1397 end Check;
1399 ------------------------
1400 -- Check_For_S_Switch --
1401 ------------------------
1403 procedure Check_For_S_Switch is
1404 begin
1405 -- By default, we generate an object file
1407 Output_Is_Object := True;
1409 for Arg in 1 .. Last_Argument loop
1410 if Arguments (Arg).all = "-S" then
1411 Output_Is_Object := False;
1413 elsif Arguments (Arg).all = "-c" then
1414 Output_Is_Object := True;
1415 end if;
1416 end loop;
1417 end Check_For_S_Switch;
1419 --------------------------
1420 -- Check_Linker_Options --
1421 --------------------------
1423 procedure Check_Linker_Options
1424 (E_Stamp : Time_Stamp_Type;
1425 O_File : out File_Name_Type;
1426 O_Stamp : out Time_Stamp_Type)
1428 procedure Check_File (File : File_Name_Type);
1429 -- Update O_File and O_Stamp if the given file is younger than E_Stamp
1430 -- and O_Stamp, or if O_File is No_File and File does not exist.
1432 function Get_Library_File (Name : String) return File_Name_Type;
1433 -- Return the full file name including path of a library based
1434 -- on the name specified with the -l linker option, using the
1435 -- Ada object path. Return No_File if no such file can be found.
1437 type Char_Array is array (Natural) of Character;
1438 type Char_Array_Access is access constant Char_Array;
1440 Template : Char_Array_Access;
1441 pragma Import (C, Template, "__gnat_library_template");
1443 ----------------
1444 -- Check_File --
1445 ----------------
1447 procedure Check_File (File : File_Name_Type) is
1448 Stamp : Time_Stamp_Type;
1449 Name : File_Name_Type := File;
1451 begin
1452 Get_Name_String (Name);
1454 -- Remove any trailing NUL characters
1456 while Name_Len >= Name_Buffer'First
1457 and then Name_Buffer (Name_Len) = NUL
1458 loop
1459 Name_Len := Name_Len - 1;
1460 end loop;
1462 if Name_Len = 0 then
1463 return;
1465 elsif Name_Buffer (1) = '-' then
1467 -- Do not check if File is a switch other than "-l"
1469 if Name_Buffer (2) /= 'l' then
1470 return;
1471 end if;
1473 -- The argument is a library switch, get actual name. It
1474 -- is necessary to make a copy of the relevant part of
1475 -- Name_Buffer as Get_Library_Name uses Name_Buffer as well.
1477 declare
1478 Base_Name : constant String := Name_Buffer (3 .. Name_Len);
1480 begin
1481 Name := Get_Library_File (Base_Name);
1482 end;
1484 if Name = No_File then
1485 return;
1486 end if;
1487 end if;
1489 Stamp := File_Stamp (Name);
1491 -- Find the youngest object file that is younger than the
1492 -- executable. If no such file exist, record the first object
1493 -- file that is not found.
1495 if (O_Stamp < Stamp and then E_Stamp < Stamp)
1496 or else (O_File = No_File and then Stamp (Stamp'First) = ' ')
1497 then
1498 O_Stamp := Stamp;
1499 O_File := Name;
1501 -- Strip the trailing NUL if present
1503 Get_Name_String (O_File);
1505 if Name_Buffer (Name_Len) = NUL then
1506 Name_Len := Name_Len - 1;
1507 O_File := Name_Find;
1508 end if;
1509 end if;
1510 end Check_File;
1512 ----------------------
1513 -- Get_Library_Name --
1514 ----------------------
1516 -- See comments in a-adaint.c about template syntax
1518 function Get_Library_File (Name : String) return File_Name_Type is
1519 File : File_Name_Type := No_File;
1521 begin
1522 Name_Len := 0;
1524 for Ptr in Template'Range loop
1525 case Template (Ptr) is
1526 when '*' =>
1527 Add_Str_To_Name_Buffer (Name);
1529 when ';' =>
1530 File := Full_Lib_File_Name (Name_Find);
1531 exit when File /= No_File;
1532 Name_Len := 0;
1534 when NUL =>
1535 exit;
1537 when others =>
1538 Add_Char_To_Name_Buffer (Template (Ptr));
1539 end case;
1540 end loop;
1542 -- The for loop exited because the end of the template
1543 -- was reached. File contains the last possible file name
1544 -- for the library.
1546 if File = No_File and then Name_Len > 0 then
1547 File := Full_Lib_File_Name (Name_Find);
1548 end if;
1550 return File;
1551 end Get_Library_File;
1553 -- Start of processing for Check_Linker_Options
1555 begin
1556 O_File := No_File;
1557 O_Stamp := (others => ' ');
1559 -- Process linker options from the ALI files
1561 for Opt in 1 .. Linker_Options.Last loop
1562 Check_File (File_Name_Type (Linker_Options.Table (Opt).Name));
1563 end loop;
1565 -- Process options given on the command line
1567 for Opt in Linker_Switches.First .. Linker_Switches.Last loop
1569 -- Check if the previous Opt has one of the two switches
1570 -- that take an extra parameter. (See GCC manual.)
1572 if Opt = Linker_Switches.First
1573 or else (Linker_Switches.Table (Opt - 1).all /= "-u"
1574 and then
1575 Linker_Switches.Table (Opt - 1).all /= "-Xlinker"
1576 and then
1577 Linker_Switches.Table (Opt - 1).all /= "-L")
1578 then
1579 Name_Len := 0;
1580 Add_Str_To_Name_Buffer (Linker_Switches.Table (Opt).all);
1581 Check_File (Name_Find);
1582 end if;
1583 end loop;
1584 end Check_Linker_Options;
1586 -----------------------
1587 -- Collect_Arguments --
1588 -----------------------
1590 procedure Collect_Arguments (Args : Argument_List) is
1591 begin
1592 Last_Argument := 0;
1593 Add_Arguments (Args);
1595 -- Set Output_Is_Object, depending if there is a -S switch.
1596 -- If the bind step is not performed, and there is a -S switch,
1597 -- then we will not check for a valid object file.
1599 Check_For_S_Switch;
1600 end Collect_Arguments;
1602 ---------------------
1603 -- Compile_Sources --
1604 ---------------------
1606 procedure Compile_Sources
1607 (Main_Source : File_Name_Type;
1608 Args : Argument_List;
1609 First_Compiled_File : out File_Name_Type;
1610 Most_Recent_Obj_File : out File_Name_Type;
1611 Most_Recent_Obj_Stamp : out Time_Stamp_Type;
1612 Main_Unit : out Boolean;
1613 Compilation_Failures : out Natural;
1614 Main_Index : Int := 0;
1615 Check_Readonly_Files : Boolean := False;
1616 Do_Not_Execute : Boolean := False;
1617 Force_Compilations : Boolean := False;
1618 Keep_Going : Boolean := False;
1619 In_Place_Mode : Boolean := False;
1620 Initialize_ALI_Data : Boolean := True;
1621 Max_Process : Positive := 1)
1623 Mfile : Natural := No_Mapping_File;
1624 Mapping_File_Arg : String_Access;
1625 -- Info on the mapping file
1627 Need_To_Check_Standard_Library : Boolean :=
1628 (Check_Readonly_Files or Must_Compile)
1629 and not Unique_Compile;
1631 procedure Add_Process
1632 (Pid : Process_Id;
1633 Sfile : File_Name_Type;
1634 Afile : File_Name_Type;
1635 Uname : Unit_Name_Type;
1636 Full_Lib_File : File_Name_Type;
1637 Lib_File_Attr : File_Attributes;
1638 Mfile : Natural := No_Mapping_File);
1639 -- Adds process Pid to the current list of outstanding compilation
1640 -- processes and record the full name of the source file Sfile that
1641 -- we are compiling, the name of its library file Afile and the
1642 -- name of its unit Uname. If Mfile is not equal to No_Mapping_File,
1643 -- it is the index of the mapping file used during compilation in the
1644 -- array The_Mapping_File_Names.
1646 procedure Await_Compile
1647 (Data : out Compilation_Data;
1648 OK : out Boolean);
1649 -- Awaits that an outstanding compilation process terminates. When it
1650 -- does set Data to the information registered for the corresponding
1651 -- call to Add_Process. Note that this time stamp can be used to check
1652 -- whether the compilation did generate an object file. OK is set to
1653 -- True if the compilation succeeded. Data could be No_Compilation_Data
1654 -- if there was no compilation to wait for.
1656 function Bad_Compilation_Count return Natural;
1657 -- Returns the number of compilation failures
1659 procedure Check_Standard_Library;
1660 -- Check if s-stalib.adb needs to be compiled
1662 procedure Collect_Arguments_And_Compile
1663 (Full_Source_File : File_Name_Type;
1664 Lib_File : File_Name_Type;
1665 Source_Index : Int;
1666 Pid : out Process_Id;
1667 Process_Created : out Boolean);
1668 -- Collect arguments from project file (if any) and compile. If no
1669 -- compilation was attempted, Processed_Created is set to False, and the
1670 -- value of Pid is unknown.
1672 function Compile
1673 (S : File_Name_Type;
1674 L : File_Name_Type;
1675 Source_Index : Int;
1676 Args : Argument_List) return Process_Id;
1677 -- Compiles S using Args. If S is a GNAT predefined source "-gnatg" is
1678 -- added to Args. Non blocking call. L corresponds to the expected
1679 -- library file name. Process_Id of the process spawned to execute the
1680 -- compilation.
1682 package Good_ALI is new Table.Table (
1683 Table_Component_Type => ALI_Id,
1684 Table_Index_Type => Natural,
1685 Table_Low_Bound => 1,
1686 Table_Initial => 50,
1687 Table_Increment => 100,
1688 Table_Name => "Make.Good_ALI");
1689 -- Contains the set of valid ALI files that have not yet been scanned
1691 function Good_ALI_Present return Boolean;
1692 -- Returns True if any ALI file was recorded in the previous set
1694 procedure Get_Mapping_File;
1695 -- Get a mapping file name. If there is one to be reused, reuse it.
1696 -- Otherwise, create a new mapping file.
1698 function Get_Next_Good_ALI return ALI_Id;
1699 -- Returns the next good ALI_Id record
1701 procedure Record_Failure
1702 (File : File_Name_Type;
1703 Unit : Unit_Name_Type;
1704 Found : Boolean := True);
1705 -- Records in the previous table that the compilation for File failed.
1706 -- If Found is False then the compilation of File failed because we
1707 -- could not find it. Records also Unit when possible.
1709 procedure Record_Good_ALI (A : ALI_Id);
1710 -- Records in the previous set the Id of an ALI file
1712 function Must_Exit_Because_Of_Error return Boolean;
1713 -- Return True if there were errors and the user decided to exit in such
1714 -- a case. This waits for any outstanding compilation.
1716 function Start_Compile_If_Possible (Args : Argument_List) return Boolean;
1717 -- Check if there is more work that we can do (i.e. the Queue is non
1718 -- empty). If there is, do it only if we have not yet used up all the
1719 -- available processes.
1720 -- Returns True if we should exit the main loop
1722 procedure Wait_For_Available_Slot;
1723 -- Check if we should wait for a compilation to finish. This is the case
1724 -- if all the available processes are busy compiling sources or there is
1725 -- nothing else to do (that is the Q is empty and there are no good ALIs
1726 -- to process).
1728 procedure Fill_Queue_From_ALI_Files;
1729 -- Check if we recorded good ALI files. If yes process them now in the
1730 -- order in which they have been recorded. There are two occasions in
1731 -- which we record good ali files. The first is in phase 1 when, after
1732 -- scanning an existing ALI file we realize it is up-to-date, the second
1733 -- instance is after a successful compilation.
1735 -----------------
1736 -- Add_Process --
1737 -----------------
1739 procedure Add_Process
1740 (Pid : Process_Id;
1741 Sfile : File_Name_Type;
1742 Afile : File_Name_Type;
1743 Uname : Unit_Name_Type;
1744 Full_Lib_File : File_Name_Type;
1745 Lib_File_Attr : File_Attributes;
1746 Mfile : Natural := No_Mapping_File)
1748 OC1 : constant Positive := Outstanding_Compiles + 1;
1750 begin
1751 pragma Assert (OC1 <= Max_Process);
1752 pragma Assert (Pid /= Invalid_Pid);
1754 Running_Compile (OC1) :=
1755 (Pid => Pid,
1756 Full_Source_File => Sfile,
1757 Lib_File => Afile,
1758 Full_Lib_File => Full_Lib_File,
1759 Lib_File_Attr => Lib_File_Attr,
1760 Source_Unit => Uname,
1761 Mapping_File => Mfile);
1763 Outstanding_Compiles := OC1;
1765 end Add_Process;
1767 --------------------
1768 -- Await_Compile --
1769 -------------------
1771 procedure Await_Compile
1772 (Data : out Compilation_Data;
1773 OK : out Boolean)
1775 Pid : Process_Id;
1777 begin
1778 pragma Assert (Outstanding_Compiles > 0);
1780 Data := No_Compilation_Data;
1781 OK := False;
1783 Wait_Process (Pid, OK);
1785 if Pid = Invalid_Pid then
1786 return;
1787 end if;
1789 -- Look into the running compilation processes for this PID
1791 for J in Running_Compile'First .. Outstanding_Compiles loop
1792 if Pid = Running_Compile (J).Pid then
1793 Data := Running_Compile (J);
1794 -- If a mapping file was used by this compilation, get its file
1795 -- name for reuse by a subsequent compilation.
1797 if Running_Compile (J).Mapping_File /= No_Mapping_File then
1798 The_Mapping_Files.Last_Free_Indexes :=
1799 The_Mapping_Files.Last_Free_Indexes + 1;
1800 The_Mapping_Files.Free_Mapping_File_Indexes
1801 (The_Mapping_Files.Last_Free_Indexes) :=
1802 Running_Compile (J).Mapping_File;
1803 end if;
1805 -- To actually remove this Pid and related info from
1806 -- Running_Compile replace its entry with the last valid
1807 -- entry in Running_Compile.
1809 if J = Outstanding_Compiles then
1810 null;
1811 else
1812 Running_Compile (J) :=
1813 Running_Compile (Outstanding_Compiles);
1814 end if;
1816 Outstanding_Compiles := Outstanding_Compiles - 1;
1817 exit;
1818 end if;
1819 end loop;
1821 -- If the PID was not found, return with OK set to False
1823 if Data = No_Compilation_Data then
1824 OK := False;
1825 end if;
1826 end Await_Compile;
1828 ---------------------------
1829 -- Bad_Compilation_Count --
1830 ---------------------------
1832 function Bad_Compilation_Count return Natural is
1833 begin
1834 return Bad_Compilation.Last - Bad_Compilation.First + 1;
1835 end Bad_Compilation_Count;
1837 ----------------------------
1838 -- Check_Standard_Library --
1839 ----------------------------
1841 procedure Check_Standard_Library is
1842 begin
1843 Need_To_Check_Standard_Library := False;
1844 Name_Len := 0;
1846 if not Targparm.Suppress_Standard_Library_On_Target then
1847 Add_Str_To_Name_Buffer (Standard_Library_Package_Body_Name);
1848 else
1849 Add_Str_To_Name_Buffer (System_Package_Spec_Name);
1850 end if;
1852 declare
1853 Add_It : Boolean := True;
1854 Sfile : File_Name_Type;
1856 begin
1857 Sfile := Name_Enter;
1859 -- If we have a special runtime, we add the standard library only
1860 -- if we can find it.
1862 if RTS_Switch then
1863 Add_It := Full_Source_Name (Sfile) /= No_File;
1864 end if;
1866 if Add_It then
1867 if not Queue.Insert
1868 ((File => Sfile,
1869 Unit => No_Unit_Name,
1870 Index => 0))
1871 then
1872 if Is_In_Obsoleted (Sfile) then
1873 Executable_Obsolete := True;
1874 end if;
1875 end if;
1876 end if;
1877 end;
1878 end Check_Standard_Library;
1880 -----------------------------------
1881 -- Collect_Arguments_And_Compile --
1882 -----------------------------------
1884 procedure Collect_Arguments_And_Compile
1885 (Full_Source_File : File_Name_Type;
1886 Lib_File : File_Name_Type;
1887 Source_Index : Int;
1888 Pid : out Process_Id;
1889 Process_Created : out Boolean) is
1890 begin
1891 Process_Created := False;
1893 -- If we use mapping file (-P or -C switches), then get one
1895 if Create_Mapping_File then
1896 Get_Mapping_File;
1897 end if;
1899 Pid :=
1900 Compile
1901 (S => Full_Source_File,
1902 L => Lib_File,
1903 Source_Index => Source_Index,
1904 Args => Arguments (1 .. Last_Argument));
1905 Process_Created := True;
1906 end Collect_Arguments_And_Compile;
1908 -------------
1909 -- Compile --
1910 -------------
1912 function Compile
1913 (S : File_Name_Type;
1914 L : File_Name_Type;
1915 Source_Index : Int;
1916 Args : Argument_List) return Process_Id
1918 Comp_Args : Argument_List (Args'First .. Args'Last + 10);
1919 Comp_Next : Integer := Args'First;
1920 Comp_Last : Integer;
1921 Arg_Index : Integer;
1923 function Ada_File_Name (Name : File_Name_Type) return Boolean;
1924 -- Returns True if Name is the name of an ada source file
1925 -- (i.e. suffix is .ads or .adb)
1927 -------------------
1928 -- Ada_File_Name --
1929 -------------------
1931 function Ada_File_Name (Name : File_Name_Type) return Boolean is
1932 begin
1933 Get_Name_String (Name);
1934 return
1935 Name_Len > 4
1936 and then Name_Buffer (Name_Len - 3 .. Name_Len - 1) = ".ad"
1937 and then (Name_Buffer (Name_Len) = 'b'
1938 or else
1939 Name_Buffer (Name_Len) = 's');
1940 end Ada_File_Name;
1942 -- Start of processing for Compile
1944 begin
1945 Enter_Into_Obsoleted (S);
1947 -- By default, Syntax_Only is False
1949 Syntax_Only := False;
1951 for J in Args'Range loop
1952 if Args (J).all = "-gnats" then
1954 -- If we compile with -gnats, the bind step and the link step
1955 -- are inhibited. Also, we set Syntax_Only to True, so that
1956 -- we don't fail when we don't find the ALI file, after
1957 -- compilation.
1959 Do_Bind_Step := False;
1960 Do_Link_Step := False;
1961 Syntax_Only := True;
1963 elsif Args (J).all = "-gnatc" then
1965 -- If we compile with -gnatc, the bind step and the link step
1966 -- are inhibited. We set Syntax_Only to False for the case when
1967 -- -gnats was previously specified.
1969 Do_Bind_Step := False;
1970 Do_Link_Step := False;
1971 Syntax_Only := False;
1972 end if;
1973 end loop;
1975 Comp_Args (Comp_Next) := new String'("-gnatea");
1976 Comp_Next := Comp_Next + 1;
1978 Comp_Args (Comp_Next) := Comp_Flag;
1979 Comp_Next := Comp_Next + 1;
1981 -- Optimize the simple case where the gcc command line looks like
1982 -- gcc -c -I. ... -I- file.adb
1983 -- into
1984 -- gcc -c ... file.adb
1986 if Args (Args'First).all = "-I" & Normalized_CWD
1987 and then Args (Args'Last).all = "-I-"
1988 and then S = Strip_Directory (S)
1989 then
1990 Comp_Last := Comp_Next + Args'Length - 3;
1991 Arg_Index := Args'First + 1;
1993 else
1994 Comp_Last := Comp_Next + Args'Length - 1;
1995 Arg_Index := Args'First;
1996 end if;
1998 -- Make a deep copy of the arguments, because Normalize_Arguments
1999 -- may deallocate some arguments. Also strip target specific -mxxx
2000 -- switches in CodePeer mode.
2002 declare
2003 Index : Natural;
2004 Last : constant Natural := Comp_Last;
2006 begin
2007 Index := Comp_Next;
2008 for J in Comp_Next .. Last loop
2009 declare
2010 Str : String renames Args (Arg_Index).all;
2011 begin
2012 if CodePeer_Mode
2013 and then Str'Length > 2
2014 and then Str (Str'First .. Str'First + 1) = "-m"
2015 then
2016 Comp_Last := Comp_Last - 1;
2017 else
2018 Comp_Args (Index) := new String'(Str);
2019 Index := Index + 1;
2020 end if;
2021 end;
2023 Arg_Index := Arg_Index + 1;
2024 end loop;
2025 end;
2027 -- Set -gnatg for predefined files (for this purpose the renamings
2028 -- such as Text_IO do not count as predefined). Note that we strip
2029 -- the directory name from the source file name because the call to
2030 -- Fname.Is_Predefined_File_Name cannot deal with directory prefixes.
2032 declare
2033 Fname : constant File_Name_Type := Strip_Directory (S);
2035 begin
2036 if Is_Predefined_File_Name
2037 (Fname, Renamings_Included => False)
2038 then
2039 if Check_Readonly_Files or else Must_Compile then
2040 Comp_Args (Comp_Args'First + 2 .. Comp_Last + 1) :=
2041 Comp_Args (Comp_Args'First + 1 .. Comp_Last);
2042 Comp_Last := Comp_Last + 1;
2043 Comp_Args (Comp_Args'First + 1) := GNAT_Flag;
2045 else
2046 Make_Failed
2047 ("not allowed to compile """ &
2048 Get_Name_String (Fname) &
2049 """; use -a switch, or use the compiler directly with "
2050 & "the ""-gnatg"" switch");
2051 end if;
2052 end if;
2053 end;
2055 -- Now check if the file name has one of the suffixes familiar to
2056 -- the gcc driver. If this is not the case then add the ada flag
2057 -- "-x ada".
2058 -- Append systematically "-x adascil" in CodePeer mode instead, to
2059 -- force the use of gnat1scil instead of gnat1.
2061 if CodePeer_Mode then
2062 Comp_Last := Comp_Last + 1;
2063 Comp_Args (Comp_Last) := Ada_Flag_1;
2064 Comp_Last := Comp_Last + 1;
2065 Comp_Args (Comp_Last) := AdaSCIL_Flag;
2067 elsif not Ada_File_Name (S) then
2068 Comp_Last := Comp_Last + 1;
2069 Comp_Args (Comp_Last) := Ada_Flag_1;
2070 Comp_Last := Comp_Last + 1;
2071 Comp_Args (Comp_Last) := Ada_Flag_2;
2072 end if;
2074 if Source_Index /= 0 then
2075 declare
2076 Num : constant String := Source_Index'Img;
2077 begin
2078 Comp_Last := Comp_Last + 1;
2079 Comp_Args (Comp_Last) :=
2080 new String'("-gnateI" & Num (Num'First + 1 .. Num'Last));
2081 end;
2082 end if;
2084 if Source_Index /= 0
2085 or else L /= Strip_Directory (L)
2086 or else Object_Directory_Path /= null
2087 then
2088 -- Build -o argument
2090 Get_Name_String (L);
2092 for J in reverse 1 .. Name_Len loop
2093 if Name_Buffer (J) = '.' then
2094 Name_Len := J + Object_Suffix'Length - 1;
2095 Name_Buffer (J .. Name_Len) := Object_Suffix;
2096 exit;
2097 end if;
2098 end loop;
2100 Comp_Last := Comp_Last + 1;
2101 Comp_Args (Comp_Last) := Output_Flag;
2102 Comp_Last := Comp_Last + 1;
2104 -- If an object directory was specified, prepend the object file
2105 -- name with this object directory.
2107 if Object_Directory_Path /= null then
2108 Comp_Args (Comp_Last) :=
2109 new String'(Object_Directory_Path.all &
2110 Name_Buffer (1 .. Name_Len));
2112 else
2113 Comp_Args (Comp_Last) :=
2114 new String'(Name_Buffer (1 .. Name_Len));
2115 end if;
2116 end if;
2118 if Create_Mapping_File and then Mapping_File_Arg /= null then
2119 Comp_Last := Comp_Last + 1;
2120 Comp_Args (Comp_Last) := new String'(Mapping_File_Arg.all);
2121 end if;
2123 Get_Name_String (S);
2125 Comp_Last := Comp_Last + 1;
2126 Comp_Args (Comp_Last) := new String'(Name_Buffer (1 .. Name_Len));
2128 -- Change to object directory of the project file, if necessary
2130 GNAT.OS_Lib.Normalize_Arguments (Comp_Args (Args'First .. Comp_Last));
2132 Comp_Last := Comp_Last + 1;
2133 Comp_Args (Comp_Last) := new String'("-gnatez");
2135 Display (Gcc.all, Comp_Args (Args'First .. Comp_Last));
2137 if Gcc_Path = null then
2138 Make_Failed ("error, unable to locate " & Gcc.all);
2139 end if;
2141 return
2142 GNAT.OS_Lib.Non_Blocking_Spawn
2143 (Gcc_Path.all, Comp_Args (Args'First .. Comp_Last));
2144 end Compile;
2146 -------------------------------
2147 -- Fill_Queue_From_ALI_Files --
2148 -------------------------------
2150 procedure Fill_Queue_From_ALI_Files is
2151 ALI : ALI_Id;
2152 Source_Index : Int;
2153 Sfile : File_Name_Type;
2155 begin
2156 while Good_ALI_Present loop
2157 ALI := Get_Next_Good_ALI;
2158 Source_Index := Unit_Index_Of (ALIs.Table (ALI).Afile);
2160 -- If we are processing the library file corresponding to the
2161 -- main source file check if this source can be a main unit.
2163 if ALIs.Table (ALI).Sfile = Main_Source
2164 and then Source_Index = Main_Index
2165 then
2166 Main_Unit := ALIs.Table (ALI).Main_Program /= None;
2167 end if;
2169 -- The following adds the standard library (s-stalib) to the list
2170 -- of files to be handled by gnatmake: this file and any files it
2171 -- depends on are always included in every bind, even if they are
2172 -- not in the explicit dependency list. Of course, it is not added
2173 -- if Suppress_Standard_Library is True.
2175 -- However, to avoid annoying output about s-stalib.ali being read
2176 -- only, when "-v" is used, we add the standard library only when
2177 -- "-a" is used.
2179 if Need_To_Check_Standard_Library then
2180 Check_Standard_Library;
2181 end if;
2183 -- Now insert in the Q the unmarked source files (i.e. those which
2184 -- have never been inserted in the Q and hence never considered).
2185 -- Only do that if Unique_Compile is False.
2187 if not Unique_Compile then
2188 for J in
2189 ALIs.Table (ALI).First_Unit .. ALIs.Table (ALI).Last_Unit
2190 loop
2191 for K in
2192 Units.Table (J).First_With .. Units.Table (J).Last_With
2193 loop
2194 Sfile := Withs.Table (K).Sfile;
2196 Dependencies.Append ((ALIs.Table (ALI).Sfile, Sfile));
2198 if Is_In_Obsoleted (Sfile) then
2199 Executable_Obsolete := True;
2200 end if;
2202 if Sfile = No_File then
2203 Debug_Msg ("Skipping generic:", Withs.Table (K).Uname);
2205 else
2206 Source_Index := Unit_Index_Of (Withs.Table (K).Afile);
2208 if not (Check_Readonly_Files or Must_Compile)
2209 and then Is_Internal_File_Name (Sfile, False)
2210 then
2211 Debug_Msg ("Skipping internal file:", Sfile);
2213 else
2214 Queue.Insert
2215 ((File => Sfile,
2216 Unit => Withs.Table (K).Uname,
2217 Index => Source_Index));
2218 end if;
2219 end if;
2220 end loop;
2221 end loop;
2222 end if;
2223 end loop;
2224 end Fill_Queue_From_ALI_Files;
2226 ----------------------
2227 -- Get_Mapping_File --
2228 ----------------------
2230 procedure Get_Mapping_File is
2231 begin
2232 -- If there is a mapping file ready to be reused, reuse it
2234 if The_Mapping_Files.Last_Free_Indexes > 0 then
2235 Mfile :=
2236 The_Mapping_Files.Free_Mapping_File_Indexes
2237 (The_Mapping_Files.Last_Free_Indexes);
2238 The_Mapping_Files.Last_Free_Indexes :=
2239 The_Mapping_Files.Last_Free_Indexes - 1;
2241 -- Otherwise, create and initialize a new one
2243 else
2244 Init_Mapping_File (File_Index => Mfile);
2245 end if;
2247 -- Put the name in the mapping file argument for the invocation
2248 -- of the compiler.
2250 Free (Mapping_File_Arg);
2251 Mapping_File_Arg :=
2252 new String'
2253 ("-gnatem=" &
2254 Get_Name_String
2255 (The_Mapping_Files.Mapping_File_Names (Mfile)));
2256 end Get_Mapping_File;
2258 -----------------------
2259 -- Get_Next_Good_ALI --
2260 -----------------------
2262 function Get_Next_Good_ALI return ALI_Id is
2263 ALIP : ALI_Id;
2265 begin
2266 pragma Assert (Good_ALI_Present);
2267 ALIP := Good_ALI.Table (Good_ALI.Last);
2268 Good_ALI.Decrement_Last;
2269 return ALIP;
2270 end Get_Next_Good_ALI;
2272 ----------------------
2273 -- Good_ALI_Present --
2274 ----------------------
2276 function Good_ALI_Present return Boolean is
2277 begin
2278 return Good_ALI.First <= Good_ALI.Last;
2279 end Good_ALI_Present;
2281 --------------------------------
2282 -- Must_Exit_Because_Of_Error --
2283 --------------------------------
2285 function Must_Exit_Because_Of_Error return Boolean is
2286 Data : Compilation_Data;
2287 Success : Boolean;
2289 begin
2290 if Bad_Compilation_Count > 0 and then not Keep_Going then
2291 while Outstanding_Compiles > 0 loop
2292 Await_Compile (Data, Success);
2294 if not Success then
2295 Record_Failure (Data.Full_Source_File, Data.Source_Unit);
2296 end if;
2297 end loop;
2299 return True;
2300 end if;
2302 return False;
2303 end Must_Exit_Because_Of_Error;
2305 --------------------
2306 -- Record_Failure --
2307 --------------------
2309 procedure Record_Failure
2310 (File : File_Name_Type;
2311 Unit : Unit_Name_Type;
2312 Found : Boolean := True)
2314 begin
2315 Bad_Compilation.Increment_Last;
2316 Bad_Compilation.Table (Bad_Compilation.Last) := (File, Unit, Found);
2317 end Record_Failure;
2319 ---------------------
2320 -- Record_Good_ALI --
2321 ---------------------
2323 procedure Record_Good_ALI (A : ALI_Id) is
2324 begin
2325 Good_ALI.Increment_Last;
2326 Good_ALI.Table (Good_ALI.Last) := A;
2327 end Record_Good_ALI;
2329 -------------------------------
2330 -- Start_Compile_If_Possible --
2331 -------------------------------
2333 function Start_Compile_If_Possible
2334 (Args : Argument_List) return Boolean
2336 In_Lib_Dir : Boolean;
2337 Need_To_Compile : Boolean;
2338 Pid : Process_Id := Invalid_Pid;
2339 Process_Created : Boolean;
2341 Source : Queue.Source_Info;
2342 Full_Source_File : File_Name_Type := No_File;
2343 Source_File_Attr : aliased File_Attributes;
2344 -- The full name of the source file and its attributes (size, ...)
2346 Lib_File : File_Name_Type;
2347 Full_Lib_File : File_Name_Type := No_File;
2348 Lib_File_Attr : aliased File_Attributes;
2349 Read_Only : Boolean := False;
2350 ALI : ALI_Id := No_ALI_Id;
2351 -- The ALI file and its attributes (size, stamp, ...)
2353 Obj_File : File_Name_Type := No_File;
2354 Obj_Stamp : Time_Stamp_Type;
2355 -- The object file
2357 Found : Boolean;
2359 begin
2360 if not Queue.Is_Empty and then
2361 Outstanding_Compiles < Max_Process
2362 then
2363 Queue.Extract (Found, Source);
2365 Osint.Full_Source_Name
2366 (Source.File,
2367 Full_File => Full_Source_File,
2368 Attr => Source_File_Attr'Unchecked_Access);
2370 Lib_File := Osint.Lib_File_Name (Source.File, Source.Index);
2372 Osint.Full_Lib_File_Name
2373 (Lib_File,
2374 Lib_File => Full_Lib_File,
2375 Attr => Lib_File_Attr);
2377 -- If source has already been compiled, executable is obsolete
2379 if Is_In_Obsoleted (Source.File) then
2380 Executable_Obsolete := True;
2381 end if;
2383 In_Lib_Dir := Full_Lib_File /= No_File
2384 and then In_Ada_Lib_Dir (Full_Lib_File);
2386 -- Since the following requires a system call, we precompute it
2387 -- when needed.
2389 if not In_Lib_Dir then
2390 if Full_Lib_File /= No_File
2391 and then not (Check_Readonly_Files or else Must_Compile)
2392 then
2393 Get_Name_String (Full_Lib_File);
2394 Name_Buffer (Name_Len + 1) := ASCII.NUL;
2395 Read_Only := not Is_Writable_File
2396 (Name_Buffer'Address, Lib_File_Attr'Unchecked_Access);
2397 else
2398 Read_Only := False;
2399 end if;
2400 end if;
2402 -- If the library file is an Ada library skip it
2404 if In_Lib_Dir then
2405 Verbose_Msg
2406 (Lib_File,
2407 "is in an Ada library",
2408 Prefix => " ",
2409 Minimum_Verbosity => Opt.High);
2411 -- If the library file is a read-only library skip it, but only
2412 -- if, when using project files, this library file is in the
2413 -- right object directory (a read-only ALI file in the object
2414 -- directory of a project being extended must not be skipped).
2416 elsif Read_Only then
2417 Verbose_Msg
2418 (Lib_File,
2419 "is a read-only library",
2420 Prefix => " ",
2421 Minimum_Verbosity => Opt.High);
2423 -- The source file that we are checking cannot be located
2425 elsif Full_Source_File = No_File then
2426 Record_Failure (Source.File, Source.Unit, False);
2428 -- Source and library files can be located but are internal
2429 -- files.
2431 elsif not (Check_Readonly_Files or else Must_Compile)
2432 and then Full_Lib_File /= No_File
2433 and then Is_Internal_File_Name (Source.File, False)
2434 then
2435 if Force_Compilations then
2436 Fail
2437 ("not allowed to compile """ &
2438 Get_Name_String (Source.File) &
2439 """; use -a switch, or use the compiler directly with "
2440 & "the ""-gnatg"" switch");
2441 end if;
2443 Verbose_Msg
2444 (Lib_File,
2445 "is an internal library",
2446 Prefix => " ",
2447 Minimum_Verbosity => Opt.High);
2449 -- The source file that we are checking can be located
2451 else
2452 Collect_Arguments (Args);
2454 -- Don't waste any time if we have to recompile anyway
2456 Obj_Stamp := Empty_Time_Stamp;
2457 Need_To_Compile := Force_Compilations;
2459 if not Force_Compilations then
2460 Check (Source_File => Source.File,
2461 The_Args => Args,
2462 Lib_File => Lib_File,
2463 Full_Lib_File => Full_Lib_File,
2464 Lib_File_Attr => Lib_File_Attr'Unchecked_Access,
2465 Read_Only => Read_Only,
2466 ALI => ALI,
2467 O_File => Obj_File,
2468 O_Stamp => Obj_Stamp);
2469 Need_To_Compile := (ALI = No_ALI_Id);
2470 end if;
2472 if not Need_To_Compile then
2474 -- The ALI file is up-to-date; record its Id
2476 Record_Good_ALI (ALI);
2478 -- Record the time stamp of the most recent object
2479 -- file as long as no (re)compilations are needed.
2481 if First_Compiled_File = No_File
2482 and then (Most_Recent_Obj_File = No_File
2483 or else Obj_Stamp > Most_Recent_Obj_Stamp)
2484 then
2485 Most_Recent_Obj_File := Obj_File;
2486 Most_Recent_Obj_Stamp := Obj_Stamp;
2487 end if;
2489 else
2490 -- Is this the first file we have to compile?
2492 if First_Compiled_File = No_File then
2493 First_Compiled_File := Full_Source_File;
2494 Most_Recent_Obj_File := No_File;
2496 if Do_Not_Execute then
2498 -- Exit the main loop
2500 return True;
2501 end if;
2502 end if;
2504 -- Compute where the ALI file must be generated in
2505 -- In_Place_Mode (this does not require to know the
2506 -- location of the object directory).
2508 if In_Place_Mode then
2509 if Full_Lib_File = No_File then
2511 -- If the library file was not found, then save
2512 -- the library file near the source file.
2514 Lib_File :=
2515 Osint.Lib_File_Name
2516 (Full_Source_File, Source.Index);
2517 Full_Lib_File := Lib_File;
2519 else
2520 -- If the library file was found, then save the
2521 -- library file in the same place.
2523 Lib_File := Full_Lib_File;
2524 end if;
2525 end if;
2527 -- Start the compilation and record it. We can do this
2528 -- because there is at least one free process. This might
2529 -- change the current directory.
2531 Collect_Arguments_And_Compile
2532 (Full_Source_File => Full_Source_File,
2533 Lib_File => Lib_File,
2534 Source_Index => Source.Index,
2535 Pid => Pid,
2536 Process_Created => Process_Created);
2538 -- Compute where the ALI file will be generated (for
2539 -- cases that might require to know the current
2540 -- directory). The current directory might be changed
2541 -- when compiling other files so we cannot rely on it
2542 -- being the same to find the resulting ALI file.
2544 if not In_Place_Mode then
2546 -- Compute the expected location of the ALI file. This
2547 -- can be from several places:
2548 -- -i => in place mode. In such a case,
2549 -- Full_Lib_File has already been set above
2550 -- -D => if specified
2551 -- or defaults in current dir
2552 -- We could simply use a call similar to
2553 -- Osint.Full_Lib_File_Name (Lib_File)
2554 -- but that involves system calls and is thus slower
2556 if Object_Directory_Path /= null then
2557 Name_Len := 0;
2558 Add_Str_To_Name_Buffer (Object_Directory_Path.all);
2559 Add_Str_To_Name_Buffer (Get_Name_String (Lib_File));
2560 Full_Lib_File := Name_Find;
2562 else
2563 Full_Lib_File := Lib_File;
2564 end if;
2566 end if;
2568 Lib_File_Attr := Unknown_Attributes;
2570 -- Make sure we could successfully start the compilation
2572 if Process_Created then
2573 if Pid = Invalid_Pid then
2574 Record_Failure (Full_Source_File, Source.Unit);
2575 else
2576 Add_Process
2577 (Pid => Pid,
2578 Sfile => Full_Source_File,
2579 Afile => Lib_File,
2580 Uname => Source.Unit,
2581 Mfile => Mfile,
2582 Full_Lib_File => Full_Lib_File,
2583 Lib_File_Attr => Lib_File_Attr);
2584 end if;
2585 end if;
2586 end if;
2587 end if;
2588 end if;
2589 return False;
2590 end Start_Compile_If_Possible;
2592 -----------------------------
2593 -- Wait_For_Available_Slot --
2594 -----------------------------
2596 procedure Wait_For_Available_Slot is
2597 Compilation_OK : Boolean;
2598 Text : Text_Buffer_Ptr;
2599 ALI : ALI_Id;
2600 Data : Compilation_Data;
2602 begin
2603 if Outstanding_Compiles = Max_Process
2604 or else (Queue.Is_Empty
2605 and then not Good_ALI_Present
2606 and then Outstanding_Compiles > 0)
2607 then
2608 Await_Compile (Data, Compilation_OK);
2610 if not Compilation_OK then
2611 Record_Failure (Data.Full_Source_File, Data.Source_Unit);
2612 end if;
2614 if Compilation_OK or else Keep_Going then
2616 -- Re-read the updated library file
2618 declare
2619 Saved_Object_Consistency : constant Boolean :=
2620 Check_Object_Consistency;
2622 begin
2623 -- If compilation was not OK, or if output is not an object
2624 -- file and we don't do the bind step, don't check for
2625 -- object consistency.
2627 Check_Object_Consistency :=
2628 Check_Object_Consistency
2629 and Compilation_OK
2630 and (Output_Is_Object or Do_Bind_Step);
2632 Text :=
2633 Read_Library_Info_From_Full
2634 (Data.Full_Lib_File,
2635 Data.Lib_File_Attr'Unchecked_Access);
2637 -- Restore Check_Object_Consistency to its initial value
2639 Check_Object_Consistency := Saved_Object_Consistency;
2640 end;
2642 -- If an ALI file was generated by this compilation, scan the
2643 -- ALI file and record it.
2645 -- If the scan fails, a previous ali file is inconsistent with
2646 -- the unit just compiled.
2648 if Text /= null then
2649 ALI :=
2650 Scan_ALI
2651 (Data.Lib_File, Text, Err => True);
2653 if ALI = No_ALI_Id then
2655 -- Record a failure only if not already done
2657 if Compilation_OK then
2658 Inform
2659 (Data.Lib_File,
2660 "incompatible ALI file, please recompile");
2661 Record_Failure
2662 (Data.Full_Source_File, Data.Source_Unit);
2663 end if;
2665 else
2666 Record_Good_ALI (ALI);
2667 end if;
2669 Free (Text);
2671 -- If we could not read the ALI file that was just generated
2672 -- then there could be a problem reading either the ALI or the
2673 -- corresponding object file (if Check_Object_Consistency is
2674 -- set Read_Library_Info checks that the time stamp of the
2675 -- object file is more recent than that of the ALI). However,
2676 -- we record a failure only if not already done.
2678 else
2679 if Compilation_OK and not Syntax_Only then
2680 Inform
2681 (Data.Lib_File,
2682 "WARNING: ALI or object file not found after compile");
2684 if not Is_Regular_File
2685 (Get_Name_String (Name_Id (Data.Full_Lib_File)))
2686 then
2687 Inform (Data.Full_Lib_File, "not found");
2688 end if;
2690 Record_Failure (Data.Full_Source_File, Data.Source_Unit);
2691 end if;
2692 end if;
2693 end if;
2694 end if;
2695 end Wait_For_Available_Slot;
2697 -- Start of processing for Compile_Sources
2699 begin
2700 pragma Assert (Args'First = 1);
2702 Outstanding_Compiles := 0;
2703 Running_Compile := new Comp_Data_Arr (1 .. Max_Process);
2705 -- Package and Queue initializations
2707 Good_ALI.Init;
2709 if Initialize_ALI_Data then
2710 Initialize_ALI;
2711 Initialize_ALI_Source;
2712 end if;
2714 -- The following two flags affect the behavior of ALI.Set_Source_Table.
2715 -- We set Check_Source_Files to True to ensure that source file time
2716 -- stamps are checked, and we set All_Sources to False to avoid checking
2717 -- the presence of the source files listed in the source dependency
2718 -- section of an ali file (which would be a mistake since the ali file
2719 -- may be obsolete).
2721 Check_Source_Files := True;
2722 All_Sources := False;
2724 Queue.Insert
2725 ((File => Main_Source,
2726 Unit => No_Unit_Name,
2727 Index => Main_Index));
2729 First_Compiled_File := No_File;
2730 Most_Recent_Obj_File := No_File;
2731 Most_Recent_Obj_Stamp := Empty_Time_Stamp;
2732 Main_Unit := False;
2734 -- Keep looping until there is no more work to do (the Q is empty)
2735 -- and all the outstanding compilations have terminated.
2737 Make_Loop :
2738 while not Queue.Is_Empty or else Outstanding_Compiles > 0 loop
2739 exit Make_Loop when Must_Exit_Because_Of_Error;
2740 exit Make_Loop when Start_Compile_If_Possible (Args);
2742 Wait_For_Available_Slot;
2744 -- ??? Should be done as soon as we add a Good_ALI, wouldn't it avoid
2745 -- the need for a list of good ALI?
2747 Fill_Queue_From_ALI_Files;
2749 if Display_Compilation_Progress then
2750 Write_Str ("completed ");
2751 Write_Int (Int (Queue.Processed));
2752 Write_Str (" out of ");
2753 Write_Int (Int (Queue.Size));
2754 Write_Str (" (");
2755 Write_Int (Int ((Queue.Processed * 100) / Queue.Size));
2756 Write_Str ("%)...");
2757 Write_Eol;
2758 end if;
2759 end loop Make_Loop;
2761 Compilation_Failures := Bad_Compilation_Count;
2763 -- Compilation is finished
2765 end Compile_Sources;
2767 ---------------
2768 -- Debug_Msg --
2769 ---------------
2771 procedure Debug_Msg (S : String; N : Name_Id) is
2772 begin
2773 if Debug.Debug_Flag_W then
2774 Write_Str (" ... ");
2775 Write_Str (S);
2776 Write_Str (" ");
2777 Write_Name (N);
2778 Write_Eol;
2779 end if;
2780 end Debug_Msg;
2782 procedure Debug_Msg (S : String; N : File_Name_Type) is
2783 begin
2784 Debug_Msg (S, Name_Id (N));
2785 end Debug_Msg;
2787 procedure Debug_Msg (S : String; N : Unit_Name_Type) is
2788 begin
2789 Debug_Msg (S, Name_Id (N));
2790 end Debug_Msg;
2792 -------------
2793 -- Display --
2794 -------------
2796 procedure Display (Program : String; Args : Argument_List) is
2797 begin
2798 pragma Assert (Args'First = 1);
2800 if not Quiet_Output then
2801 Write_Str (Program);
2803 for J in Args'Range loop
2805 -- Never display -gnatea nor -gnatez
2807 if Args (J).all /= "-gnatea"
2808 and then
2809 Args (J).all /= "-gnatez"
2810 then
2811 -- Do not display the -F=mapping_file switch for gnatbind if
2812 -- -dn is not specified.
2814 if Opt.Keep_Temporary_Files
2815 or else Args (J)'Length < 4
2816 or else
2817 Args (J) (Args (J)'First .. Args (J)'First + 2) /= "-F="
2818 then
2819 Write_Str (" ");
2821 -- If -df is used, only display file names, not path
2822 -- names.
2824 if Debug.Debug_Flag_F then
2825 declare
2826 Equal_Pos : Natural;
2828 begin
2829 Equal_Pos := Args (J)'First - 1;
2830 for K in Args (J)'Range loop
2831 if Args (J) (K) = '=' then
2832 Equal_Pos := K;
2833 exit;
2834 end if;
2835 end loop;
2837 if Is_Absolute_Path
2838 (Args (J) (Equal_Pos + 1 .. Args (J)'Last))
2839 then
2840 Write_Str
2841 (Args (J) (Args (J)'First .. Equal_Pos));
2842 Write_Str
2843 (File_Name
2844 (Args (J)
2845 (Equal_Pos + 1 .. Args (J)'Last)));
2847 else
2848 Write_Str (Args (J).all);
2849 end if;
2850 end;
2852 else
2853 Write_Str (Args (J).all);
2854 end if;
2855 end if;
2856 end if;
2857 end loop;
2859 Write_Eol;
2860 end if;
2861 end Display;
2863 --------------------------
2864 -- Enter_Into_Obsoleted --
2865 --------------------------
2867 procedure Enter_Into_Obsoleted (F : File_Name_Type) is
2868 Name : constant String := Get_Name_String (F);
2869 First : Natural;
2870 F2 : File_Name_Type;
2872 begin
2873 First := Name'Last;
2874 while First > Name'First
2875 and then not Is_Directory_Separator (Name (First - 1))
2876 loop
2877 First := First - 1;
2878 end loop;
2880 if First /= Name'First then
2881 Name_Len := 0;
2882 Add_Str_To_Name_Buffer (Name (First .. Name'Last));
2883 F2 := Name_Find;
2885 else
2886 F2 := F;
2887 end if;
2889 Debug_Msg ("New entry in Obsoleted table:", F2);
2890 Obsoleted.Set (F2, True);
2891 end Enter_Into_Obsoleted;
2893 -------------------
2894 -- Linking_Phase --
2895 -------------------
2897 procedure Linking_Phase
2898 (Non_Std_Executable : Boolean := False;
2899 Executable : File_Name_Type := No_File;
2900 Main_ALI_File : File_Name_Type)
2902 Linker_Switches_Last : constant Integer := Linker_Switches.Last;
2904 begin
2905 if not Run_Path_Option then
2906 Linker_Switches.Increment_Last;
2907 Linker_Switches.Table (Linker_Switches.Last) :=
2908 new String'("-R");
2909 end if;
2911 if CodePeer_Mode then
2912 Linker_Switches.Increment_Last;
2913 Linker_Switches.Table (Linker_Switches.Last) :=
2914 new String'(CodePeer_Mode_String);
2915 end if;
2917 -- Add switch -M to gnatlink if builder switch --create-map-file
2918 -- has been specified.
2920 if Map_File /= null then
2921 Linker_Switches.Increment_Last;
2922 Linker_Switches.Table (Linker_Switches.Last) :=
2923 new String'("-M" & Map_File.all);
2924 end if;
2926 declare
2927 Args : Argument_List
2928 (Linker_Switches.First .. Linker_Switches.Last + 2);
2930 Last_Arg : Integer := Linker_Switches.First - 1;
2931 Skip : Boolean := False;
2933 begin
2934 -- Get all the linker switches
2936 for J in Linker_Switches.First .. Linker_Switches.Last loop
2937 if Skip then
2938 Skip := False;
2940 elsif Non_Std_Executable
2941 and then Linker_Switches.Table (J).all = "-o"
2942 then
2943 Skip := True;
2945 -- Here we capture and duplicate the linker argument. We
2946 -- need to do the duplication since the arguments will get
2947 -- normalized. Not doing so will result in calling normalized
2948 -- two times for the same set of arguments if gnatmake is
2949 -- passed multiple mains. This can result in the wrong
2950 -- argument being passed to the linker.
2952 else
2953 Last_Arg := Last_Arg + 1;
2954 Args (Last_Arg) := new String'(Linker_Switches.Table (J).all);
2955 end if;
2956 end loop;
2958 -- If need be, add the -o switch
2960 if Non_Std_Executable then
2961 Last_Arg := Last_Arg + 1;
2962 Args (Last_Arg) := new String'("-o");
2963 Last_Arg := Last_Arg + 1;
2964 Args (Last_Arg) := new String'(Get_Name_String (Executable));
2965 end if;
2967 -- And invoke the linker
2969 declare
2970 Success : Boolean := False;
2972 begin
2973 -- If gnatmake was invoked with --subdirs, put the executable in
2974 -- the subdirectory specified.
2976 if Subdirs /= null then
2977 Change_Dir (Object_Directory_Path.all);
2978 end if;
2980 Link (Main_ALI_File,
2981 Link_With_Shared_Libgcc.all &
2982 Args (Args'First .. Last_Arg),
2983 Success);
2985 if Success then
2986 Successful_Links.Increment_Last;
2987 Successful_Links.Table (Successful_Links.Last) := Main_ALI_File;
2989 elsif Osint.Number_Of_Files = 1 or else not Keep_Going then
2990 Make_Failed ("*** link failed.");
2992 else
2993 Set_Standard_Error;
2994 Write_Line ("*** link failed");
2996 if Commands_To_Stdout then
2997 Set_Standard_Output;
2998 end if;
3000 Failed_Links.Increment_Last;
3001 Failed_Links.Table (Failed_Links.Last) := Main_ALI_File;
3002 end if;
3003 end;
3004 end;
3006 Linker_Switches.Set_Last (Linker_Switches_Last);
3007 end Linking_Phase;
3009 -------------------
3010 -- Binding_Phase --
3011 -------------------
3013 procedure Binding_Phase (Main_ALI_File : File_Name_Type) is
3014 Args : Argument_List (Binder_Switches.First .. Binder_Switches.Last + 2);
3015 -- The arguments for the invocation of gnatbind
3017 Last_Arg : Natural := Binder_Switches.Last;
3018 -- Index of the last argument in Args
3020 Shared_Libs : Boolean := False;
3021 -- Set to True when there are shared library project files or
3022 -- when gnatbind is invoked with -shared.
3024 begin
3026 -- Check now for switch -shared
3028 for J in Binder_Switches.First .. Last_Arg loop
3029 if Binder_Switches.Table (J).all = "-shared" then
3030 Shared_Libs := True;
3031 exit;
3032 end if;
3033 end loop;
3035 -- If shared libraries present, invoke gnatlink with
3036 -- -shared-libgcc.
3038 if Shared_Libs then
3039 Link_With_Shared_Libgcc := Shared_Libgcc_Switch'Access;
3040 end if;
3042 -- Get all the binder switches
3044 for J in Binder_Switches.First .. Last_Arg loop
3045 Args (J) := Binder_Switches.Table (J);
3046 end loop;
3048 if CodePeer_Mode then
3049 Last_Arg := Last_Arg + 1;
3050 Args (Last_Arg) := CodePeer_Mode_String'Access;
3051 end if;
3053 -- If gnatmake was invoked with --subdirs, put the
3054 -- binder generated files in the subdirectory specified.
3056 if Subdirs /= null then
3057 Change_Dir (Object_Directory_Path.all);
3058 end if;
3060 Bind (Main_ALI_File, Bind_Shared.all & Args (Args'First .. Last_Arg));
3062 end Binding_Phase;
3064 -----------------------
3065 -- Compilation_Phase --
3066 -----------------------
3068 procedure Compilation_Phase
3069 (Main_Source_File : File_Name_Type;
3070 Current_Main_Index : Int := 0;
3071 Total_Compilation_Failures : in out Natural;
3072 Executable : File_Name_Type := No_File;
3073 Stop_Compile : out Boolean)
3075 Args : Argument_List (1 .. Gcc_Switches.Last);
3076 First_Compiled_File : File_Name_Type;
3077 Youngest_Obj_File : File_Name_Type;
3078 Youngest_Obj_Stamp : Time_Stamp_Type;
3080 Is_Main_Unit : Boolean;
3081 -- Set True by Compile_Sources if Main_Source_File can be a main unit
3083 Compilation_Failures : Natural;
3085 Executable_Stamp : Time_Stamp_Type;
3087 begin
3088 Stop_Compile := False;
3090 for J in 1 .. Gcc_Switches.Last loop
3091 Args (J) := Gcc_Switches.Table (J);
3092 end loop;
3094 -- Now we invoke Compile_Sources for the current main
3096 Compile_Sources
3097 (Main_Source => Main_Source_File,
3098 Args => Args,
3099 First_Compiled_File => First_Compiled_File,
3100 Most_Recent_Obj_File => Youngest_Obj_File,
3101 Most_Recent_Obj_Stamp => Youngest_Obj_Stamp,
3102 Main_Unit => Is_Main_Unit,
3103 Main_Index => Current_Main_Index,
3104 Compilation_Failures => Compilation_Failures,
3105 Check_Readonly_Files => Check_Readonly_Files,
3106 Do_Not_Execute => Do_Not_Execute,
3107 Force_Compilations => Force_Compilations,
3108 In_Place_Mode => In_Place_Mode,
3109 Keep_Going => Keep_Going,
3110 Initialize_ALI_Data => True,
3111 Max_Process => Maximum_Processes);
3113 if Verbose_Mode then
3114 Write_Str ("End of compilation");
3115 Write_Eol;
3116 end if;
3118 Total_Compilation_Failures :=
3119 Total_Compilation_Failures + Compilation_Failures;
3121 if Total_Compilation_Failures /= 0 then
3122 Stop_Compile := True;
3123 return;
3124 end if;
3126 if List_Dependencies then
3127 if First_Compiled_File /= No_File then
3128 Inform
3129 (First_Compiled_File,
3130 "must be recompiled. Can't generate dependence list.");
3131 else
3132 List_Depend;
3133 end if;
3135 elsif First_Compiled_File = No_File
3136 and then not Do_Bind_Step
3137 and then not Quiet_Output
3138 and then Osint.Number_Of_Files = 1
3139 then
3140 Inform (Msg => "objects up to date.");
3141 Stop_Compile := True;
3142 return;
3144 elsif Do_Not_Execute and then First_Compiled_File /= No_File then
3145 Write_Name (First_Compiled_File);
3146 Write_Eol;
3147 end if;
3149 -- Stop after compile step if any of:
3151 -- 1) -n (Do_Not_Execute) specified
3153 -- 2) -M (List_Dependencies) specified (also sets
3154 -- Do_Not_Execute above, so this is probably superfluous).
3156 -- 3) -c (Compile_Only) specified, but not -b (Bind_Only)
3158 -- 4) Made unit cannot be a main unit
3160 if ((Do_Not_Execute
3161 or List_Dependencies
3162 or not Do_Bind_Step
3163 or not Is_Main_Unit)
3164 and not No_Main_Subprogram
3165 and not Build_Bind_And_Link_Full_Project)
3166 or Unique_Compile
3167 then
3168 Stop_Compile := True;
3169 return;
3170 end if;
3172 -- If the objects were up-to-date check if the executable file is also
3173 -- up-to-date. For now always bind and link in CodePeer mode where there
3174 -- is no executable.
3176 if not CodePeer_Mode
3177 and then Do_Link_Step
3178 and then First_Compiled_File = No_File
3179 then
3180 Executable_Stamp := File_Stamp (Executable);
3182 if not Executable_Obsolete then
3183 Executable_Obsolete := Youngest_Obj_Stamp > Executable_Stamp;
3184 end if;
3186 if not Executable_Obsolete then
3187 for Index in reverse 1 .. Dependencies.Last loop
3188 if Is_In_Obsoleted (Dependencies.Table (Index).Depends_On) then
3189 Enter_Into_Obsoleted (Dependencies.Table (Index).This);
3190 end if;
3191 end loop;
3193 Executable_Obsolete := Is_In_Obsoleted (Main_Source_File);
3194 Dependencies.Init;
3195 end if;
3197 if not Executable_Obsolete then
3199 -- If no Ada object files obsolete the executable, check
3200 -- for younger or missing linker files.
3202 Check_Linker_Options
3203 (Executable_Stamp,
3204 Youngest_Obj_File,
3205 Youngest_Obj_Stamp);
3207 Executable_Obsolete := Youngest_Obj_File /= No_File;
3208 end if;
3210 -- Return if the executable is up to date and otherwise
3211 -- motivate the relink/rebind.
3213 if not Executable_Obsolete then
3214 if not Quiet_Output then
3215 Inform (Executable, "up to date.");
3216 end if;
3218 Stop_Compile := True;
3219 return;
3220 end if;
3222 if Executable_Stamp (1) = ' ' then
3223 if not No_Main_Subprogram then
3224 Verbose_Msg (Executable, "missing.", Prefix => " ");
3225 end if;
3227 elsif Youngest_Obj_Stamp (1) = ' ' then
3228 Verbose_Msg
3229 (Youngest_Obj_File, "missing.", Prefix => " ");
3231 elsif Youngest_Obj_Stamp > Executable_Stamp then
3232 Verbose_Msg
3233 (Youngest_Obj_File,
3234 "(" & String (Youngest_Obj_Stamp) & ") newer than",
3235 Executable,
3236 "(" & String (Executable_Stamp) & ")");
3238 else
3239 Verbose_Msg
3240 (Executable, "needs to be rebuilt", Prefix => " ");
3242 end if;
3243 end if;
3244 end Compilation_Phase;
3246 ------------------------
3247 -- Compute_Executable --
3248 ------------------------
3250 procedure Compute_Executable
3251 (Main_Source_File : File_Name_Type;
3252 Executable : out File_Name_Type;
3253 Non_Std_Executable : out Boolean)
3255 begin
3256 Executable := No_File;
3257 Non_Std_Executable :=
3258 Targparm.Executable_Extension_On_Target /= No_Name;
3260 -- Look inside the linker switches to see if the name of the final
3261 -- executable program was specified.
3263 for J in reverse Linker_Switches.First .. Linker_Switches.Last loop
3264 if Linker_Switches.Table (J).all = Output_Flag.all then
3265 pragma Assert (J < Linker_Switches.Last);
3267 -- We cannot specify a single executable for several main
3268 -- subprograms
3270 if Osint.Number_Of_Files > 1 then
3271 Fail ("cannot specify a single executable for several mains");
3272 end if;
3274 Name_Len := 0;
3275 Add_Str_To_Name_Buffer (Linker_Switches.Table (J + 1).all);
3276 Executable := Name_Enter;
3278 Verbose_Msg (Executable, "final executable");
3279 end if;
3280 end loop;
3282 -- If the name of the final executable program was not specified then
3283 -- construct it from the main input file.
3285 if Executable = No_File then
3286 Executable := Executable_Name (Strip_Suffix (Main_Source_File));
3287 end if;
3289 end Compute_Executable;
3291 --------------
3292 -- Gnatmake --
3293 --------------
3295 procedure Gnatmake is
3296 Main_Source_File : File_Name_Type;
3297 -- The source file containing the main compilation unit
3299 Total_Compilation_Failures : Natural := 0;
3301 Main_ALI_File : File_Name_Type;
3302 -- The ali file corresponding to Main_Source_File
3304 Executable : File_Name_Type := No_File;
3305 -- The file name of an executable
3307 Non_Std_Executable : Boolean := False;
3308 -- Non_Std_Executable is set to True when there is a possibility that
3309 -- the linker will not choose the correct executable file name.
3311 Current_Main_Index : Int := 0;
3312 -- If not zero, the index of the current main unit in its source file
3314 Is_First_Main : Boolean;
3315 -- Whether we are processing the first main
3317 Stop_Compile : Boolean;
3319 Discard : Boolean;
3320 pragma Warnings (Off, Discard);
3322 begin
3323 GNAT.Ctrl_C.Install_Handler (Sigint_Intercepted'Access);
3325 Do_Compile_Step := True;
3326 Do_Bind_Step := True;
3327 Do_Link_Step := True;
3329 Obsoleted.Reset;
3331 Make.Initialize;
3333 Bind_Shared := No_Shared_Switch'Access;
3334 Link_With_Shared_Libgcc := No_Shared_Libgcc_Switch'Access;
3336 Failed_Links.Set_Last (0);
3337 Successful_Links.Set_Last (0);
3339 -- Special case when switch -B was specified
3341 if Main_Index /= 0 and then Osint.Number_Of_Files > 1 then
3342 Make_Failed ("cannot specify several mains with a multi-unit index");
3343 end if;
3345 if Verbose_Mode then
3346 Write_Eol;
3347 Display_Version ("GNATMAKE", "1992");
3348 end if;
3350 if Osint.Number_Of_Files = 0 then
3351 -- Call Get_Target_Parameters to ensure that flags are properly
3352 -- set before calling Usage.
3354 Targparm.Get_Target_Parameters;
3356 -- Output usage information if no argument on the command line
3358 if Argument_Count = 0 then
3359 Usage;
3360 else
3361 Try_Help;
3362 end if;
3364 Finish_Program (E_Success);
3365 end if;
3367 -- Get the first executable.
3368 -- ??? This needs to be done early, because Osint.Next_Main_File also
3369 -- initializes the primary search directory, used below to initialize
3370 -- the "-I" parameter
3372 Main_Source_File := Next_Main_Source; -- No directory information
3374 -- If -M was specified, behave as if -n was specified
3376 if List_Dependencies then
3377 Do_Not_Execute := True;
3378 end if;
3380 Add_Switch ("-I-", Compiler);
3382 if Look_In_Primary_Dir then
3383 Add_Switch
3384 ("-I" &
3385 Normalize_Directory_Name
3386 (Get_Primary_Src_Search_Directory.all).all,
3387 Compiler,
3388 Append_Switch => False);
3390 end if;
3392 -- If the user wants a program without a main subprogram, add the
3393 -- appropriate switch to the binder.
3395 if No_Main_Subprogram then
3396 Add_Switch ("-z", Binder);
3397 end if;
3399 -- The combination of -f -u and one or several mains on the command line
3400 -- implies -a.
3402 if Force_Compilations
3403 and then Unique_Compile
3404 and then Main_On_Command_Line
3405 then
3406 Must_Compile := True;
3407 end if;
3409 Bad_Compilation.Init;
3411 -- Here is where the make process is started
3413 Queue.Initialize;
3415 Is_First_Main := True;
3417 Multiple_Main_Loop : for N_File in 1 .. Osint.Number_Of_Files loop
3418 if Current_File_Index /= No_Index then
3419 Main_Index := Current_File_Index;
3420 end if;
3422 Current_Main_Index := Main_Index;
3424 if Is_First_Main then
3426 -- Put the default source dirs in the source path only now, so
3427 -- that we take the correct ones in the case where --RTS= is
3428 -- specified in the Builder switches.
3430 Osint.Add_Default_Search_Dirs;
3432 -- Get the target parameters, which are only needed for a couple
3433 -- of cases in gnatmake. Protect against an exception, such as the
3434 -- case of system.ads missing from the library, and fail
3435 -- gracefully.
3437 begin
3438 Targparm.Get_Target_Parameters;
3439 exception
3440 when Unrecoverable_Error =>
3441 Make_Failed ("*** make failed.");
3442 end;
3444 Gcc_Path := GNAT.OS_Lib.Locate_Exec_On_Path (Gcc.all);
3445 Gnatbind_Path := GNAT.OS_Lib.Locate_Exec_On_Path (Gnatbind.all);
3446 Gnatlink_Path := GNAT.OS_Lib.Locate_Exec_On_Path (Gnatlink.all);
3448 -- If we have specified -j switch both from the project file
3449 -- and on the command line, the one from the command line takes
3450 -- precedence.
3452 if Debug.Debug_Flag_M then
3453 Write_Line ("Maximum number of simultaneous compilations =" &
3454 Maximum_Processes'Img);
3455 end if;
3457 -- Allocate as many temporary mapping file names as the maximum
3458 -- number of compilations processed.
3460 The_Mapping_Files :=
3461 (Mapping_File_Names =>
3462 new Temp_Path_Names (1 .. Maximum_Processes),
3463 Last_Mapping_File_Names => 0,
3464 Free_Mapping_File_Indexes =>
3465 new Free_File_Indexes (1 .. Maximum_Processes),
3466 Last_Free_Indexes => 0);
3468 Is_First_Main := False;
3469 end if;
3471 Executable_Obsolete := False;
3473 Compute_Executable
3474 (Main_Source_File => Main_Source_File,
3475 Executable => Executable,
3476 Non_Std_Executable => Non_Std_Executable);
3478 if Do_Compile_Step then
3479 Compilation_Phase
3480 (Main_Source_File => Main_Source_File,
3481 Current_Main_Index => Current_Main_Index,
3482 Total_Compilation_Failures => Total_Compilation_Failures,
3483 Executable => Executable,
3484 Stop_Compile => Stop_Compile);
3486 if Stop_Compile then
3487 if Total_Compilation_Failures /= 0 then
3488 if Keep_Going then
3489 goto Next_Main;
3491 else
3492 List_Bad_Compilations;
3493 Report_Compilation_Failed;
3494 end if;
3496 elsif Osint.Number_Of_Files = 1 then
3497 exit Multiple_Main_Loop;
3498 else
3499 goto Next_Main;
3500 end if;
3501 end if;
3502 end if;
3504 -- If we are here, it means that we need to rebuilt the current main,
3505 -- so we set Executable_Obsolete to True to make sure that subsequent
3506 -- mains will be rebuilt.
3508 Main_ALI_In_Place_Mode_Step : declare
3509 ALI_File : File_Name_Type;
3510 Src_File : File_Name_Type;
3512 begin
3513 Src_File := Strip_Directory (Main_Source_File);
3514 ALI_File := Lib_File_Name (Src_File, Current_Main_Index);
3515 Main_ALI_File := Full_Lib_File_Name (ALI_File);
3517 -- When In_Place_Mode, the library file can be located in the
3518 -- Main_Source_File directory which may not be present in the
3519 -- library path. If it is not present then use the corresponding
3520 -- library file name.
3522 if Main_ALI_File = No_File and then In_Place_Mode then
3523 Get_Name_String (Get_Directory (Full_Source_Name (Src_File)));
3524 Get_Name_String_And_Append (ALI_File);
3525 Main_ALI_File := Name_Find;
3526 Main_ALI_File := Full_Lib_File_Name (Main_ALI_File);
3527 end if;
3529 if Main_ALI_File = No_File then
3530 Make_Failed ("could not find the main ALI file");
3531 end if;
3532 end Main_ALI_In_Place_Mode_Step;
3534 if Do_Bind_Step then
3535 Binding_Phase (Main_ALI_File);
3536 end if;
3538 if Do_Link_Step then
3539 Linking_Phase
3540 (Non_Std_Executable => Non_Std_Executable,
3541 Executable => Executable,
3542 Main_ALI_File => Main_ALI_File);
3543 end if;
3545 -- We go to here when we skip the bind and link steps
3547 <<Next_Main>>
3549 Queue.Remove_Marks;
3551 if N_File < Osint.Number_Of_Files then
3552 Main_Source_File := Next_Main_Source; -- No directory information
3553 end if;
3554 end loop Multiple_Main_Loop;
3556 if Failed_Links.Last > 0 then
3557 for Index in 1 .. Successful_Links.Last loop
3558 Write_Str ("Linking of """);
3559 Write_Str (Get_Name_String (Successful_Links.Table (Index)));
3560 Write_Line (""" succeeded.");
3561 end loop;
3563 Set_Standard_Error;
3565 for Index in 1 .. Failed_Links.Last loop
3566 Write_Str ("Linking of """);
3567 Write_Str (Get_Name_String (Failed_Links.Table (Index)));
3568 Write_Line (""" failed.");
3569 end loop;
3571 if Commands_To_Stdout then
3572 Set_Standard_Output;
3573 end if;
3575 if Total_Compilation_Failures = 0 then
3576 Report_Compilation_Failed;
3577 end if;
3578 end if;
3580 if Total_Compilation_Failures /= 0 then
3581 List_Bad_Compilations;
3582 Report_Compilation_Failed;
3583 end if;
3585 Finish_Program (E_Success);
3587 exception
3588 when X : others =>
3589 Set_Standard_Error;
3590 Write_Line (Exception_Information (X));
3591 Make_Failed ("INTERNAL ERROR. Please report.");
3592 end Gnatmake;
3594 ----------
3595 -- Hash --
3596 ----------
3598 function Hash (F : File_Name_Type) return Header_Num is
3599 begin
3600 return Header_Num (1 + F mod Max_Header);
3601 end Hash;
3603 --------------------
3604 -- In_Ada_Lib_Dir --
3605 --------------------
3607 function In_Ada_Lib_Dir (File : File_Name_Type) return Boolean is
3608 D : constant File_Name_Type := Get_Directory (File);
3609 B : constant Byte := Get_Name_Table_Byte (D);
3610 begin
3611 return (B and Ada_Lib_Dir) /= 0;
3612 end In_Ada_Lib_Dir;
3614 -----------------------
3615 -- Init_Mapping_File --
3616 -----------------------
3618 procedure Init_Mapping_File (File_Index : out Natural) is
3619 FD : File_Descriptor;
3620 Status : Boolean;
3621 -- For call to Close
3623 begin
3624 -- Increase the index of the last mapping file for this project
3626 The_Mapping_Files.Last_Mapping_File_Names :=
3627 The_Mapping_Files.Last_Mapping_File_Names + 1;
3629 -- Just create an empty file
3631 Tempdir.Create_Temp_File
3632 (FD,
3633 The_Mapping_Files.Mapping_File_Names
3634 (The_Mapping_Files.Last_Mapping_File_Names));
3636 if FD = Invalid_FD then
3637 Make_Failed ("disk full");
3638 else
3639 Record_Temp_File
3640 (The_Mapping_Files.Mapping_File_Names
3641 (The_Mapping_Files.Last_Mapping_File_Names));
3642 end if;
3644 Close (FD, Status);
3646 if not Status then
3647 Make_Failed ("disk full");
3648 end if;
3650 -- And return the index of the newly created file
3652 File_Index := The_Mapping_Files.Last_Mapping_File_Names;
3653 end Init_Mapping_File;
3655 ----------------
3656 -- Initialize --
3657 ----------------
3659 procedure Initialize is
3660 procedure Check_Version_And_Help is
3661 new Check_Version_And_Help_G (Makeusg);
3663 begin
3664 -- Override default initialization of Check_Object_Consistency since
3665 -- this is normally False for GNATBIND, but is True for GNATMAKE since
3666 -- we do not need to check source consistency again once GNATMAKE has
3667 -- looked at the sources to check.
3669 Check_Object_Consistency := True;
3671 -- Package initializations (the order of calls is important here)
3673 Output.Set_Standard_Error;
3675 Gcc_Switches.Init;
3676 Binder_Switches.Init;
3677 Linker_Switches.Init;
3679 Csets.Initialize;
3680 Uintp.Initialize;
3681 Snames.Initialize;
3682 Stringt.Initialize;
3684 Dependencies.Init;
3686 RTS_Specified := null;
3687 N_M_Switch := 0;
3689 Mains.Delete;
3691 -- Add the directory where gnatmake is invoked in front of the path,
3692 -- if gnatmake is invoked from a bin directory or with directory
3693 -- information.
3695 declare
3696 Prefix : constant String := Executable_Prefix_Path;
3697 Command : constant String := Command_Name;
3699 begin
3700 if Prefix'Length > 0 then
3701 declare
3702 PATH : constant String :=
3703 Prefix & Directory_Separator & "bin" & Path_Separator
3704 & Getenv ("PATH").all;
3705 begin
3706 Setenv ("PATH", PATH);
3707 end;
3709 else
3710 for Index in reverse Command'Range loop
3711 if Command (Index) = Directory_Separator then
3712 declare
3713 Absolute_Dir : constant String :=
3714 Normalize_Pathname
3715 (Command (Command'First .. Index));
3716 PATH : constant String :=
3717 Absolute_Dir &
3718 Path_Separator &
3719 Getenv ("PATH").all;
3720 begin
3721 Setenv ("PATH", PATH);
3722 end;
3724 exit;
3725 end if;
3726 end loop;
3727 end if;
3728 end;
3730 -- Scan the switches and arguments
3732 -- First, scan to detect --version and/or --help
3734 Check_Version_And_Help ("GNATMAKE", "1995");
3736 -- Scan again the switch and arguments, now that we are sure that they
3737 -- do not include --version or --help.
3739 -- First, check for switch -P and, if found and gprbuild is available,
3740 -- silently invoke gprbuild, with switch --target if not on a native
3741 -- platform.
3743 declare
3744 Arg_Len : Natural := Argument_Count;
3745 Call_Gprbuild : Boolean := False;
3746 Gprbuild : String_Access := null;
3747 Pos : Natural := 0;
3748 Success : Boolean;
3749 Target : String_Access := null;
3751 In_Gnatmake_Switches : Boolean := True;
3752 -- Set to False after -cargs, -bargs, or -largs, to avoid detecting
3753 -- -P switches that are not for gnatmake.
3755 begin
3756 Find_Program_Name;
3758 if Name_Len >= 8
3759 and then Name_Buffer (Name_Len - 7 .. Name_Len) = "gnatmake"
3760 then
3761 if Name_Len > 9 then
3762 Target := new String'(Name_Buffer (1 .. Name_Len - 9));
3763 Arg_Len := Arg_Len + 1;
3764 end if;
3766 for J in 1 .. Argument_Count loop
3767 declare
3768 Arg : constant String := Argument (J);
3769 begin
3770 if Arg in "-cargs" | "-bargs" | "-largs" then
3771 In_Gnatmake_Switches := False;
3773 elsif Arg = "-margs" then
3774 In_Gnatmake_Switches := True;
3776 elsif In_Gnatmake_Switches
3777 and then Arg'Length >= 2
3778 and then Arg (Arg'First .. Arg'First + 1) = "-P"
3779 then
3780 Call_Gprbuild := True;
3781 exit;
3782 end if;
3783 end;
3784 end loop;
3786 if Call_Gprbuild then
3787 Gprbuild := Locate_Exec_On_Path (Exec_Name => "gprbuild");
3789 if Gprbuild = null then
3790 Fail_Program
3791 ("project files are no longer supported by gnatmake;" &
3792 " use gprbuild instead");
3793 end if;
3795 declare
3796 Args : Argument_List (1 .. Arg_Len);
3797 begin
3798 if Target /= null then
3799 Args (1) := new String'("--target=" & Target.all);
3800 Pos := 1;
3801 end if;
3803 for J in 1 .. Argument_Count loop
3804 Pos := Pos + 1;
3805 Args (Pos) := new String'(Argument (J));
3806 end loop;
3808 Spawn (Gprbuild.all, Args, Success);
3810 Free (Gprbuild);
3812 if Success then
3813 Exit_Program (E_Success);
3814 else
3815 Exit_Program (E_Errors);
3816 end if;
3817 end;
3818 end if;
3819 end if;
3820 end;
3822 Scan_Args : for Next_Arg in 1 .. Argument_Count loop
3823 Scan_Make_Arg (Argument (Next_Arg));
3824 end loop Scan_Args;
3826 if Make_Steps then
3827 Do_Compile_Step := Compile_Only;
3828 Do_Bind_Step := Bind_Only;
3829 Do_Link_Step := Link_Only;
3831 if Do_Compile_Step and then Do_Link_Step then
3832 Do_Bind_Step := True;
3833 end if;
3834 end if;
3836 if N_M_Switch > 0 and RTS_Specified = null then
3837 Process_Multilib;
3838 end if;
3840 if Commands_To_Stdout then
3841 Set_Standard_Output;
3842 end if;
3844 if Usage_Requested then
3845 Usage;
3846 end if;
3848 -- Test for trailing -P switch
3850 if Project_File_Name_Present and then Project_File_Name = null then
3851 Make_Failed ("project file name missing after -P");
3853 -- Test for trailing -o switch
3855 elsif Output_File_Name_Present and then not Output_File_Name_Seen then
3856 Make_Failed ("output file name missing after -o");
3858 -- Test for trailing -D switch
3860 elsif Object_Directory_Present and then not Object_Directory_Seen then
3861 Make_Failed ("object directory missing after -D");
3862 end if;
3864 -- Test for simultaneity of -i and -D
3866 if Object_Directory_Path /= null and then In_Place_Mode then
3867 Make_Failed ("-i and -D cannot be used simultaneously");
3868 end if;
3870 -- If --subdirs= is specified, but not -P, this is equivalent to -D,
3871 -- except that the directory is created if it does not exist.
3873 if Subdirs /= null then
3874 if Object_Directory_Path /= null then
3875 Make_Failed ("--subdirs and -D cannot be used simultaneously");
3877 elsif In_Place_Mode then
3878 Make_Failed ("--subdirs and -i cannot be used simultaneously");
3880 else
3881 if not Is_Directory (Subdirs.all) then
3882 begin
3883 Ada.Directories.Create_Path (Subdirs.all);
3884 exception
3885 when others =>
3886 Make_Failed ("unable to create object directory " &
3887 Subdirs.all);
3888 end;
3889 end if;
3891 Object_Directory_Present := True;
3893 declare
3894 Argv : constant String (1 .. Subdirs'Length) :=
3895 Subdirs.all;
3896 begin
3897 Scan_Make_Arg (Argv);
3898 end;
3899 end if;
3900 end if;
3902 -- Deal with -C= switch
3904 if Gnatmake_Mapping_File /= null then
3906 -- First, check compatibility with other switches
3908 if Maximum_Processes > 1 then
3909 Make_Failed ("-C= switch is not compatible with -jnnn switch");
3910 end if;
3912 Fmap.Initialize (Gnatmake_Mapping_File.all);
3913 Add_Switch
3914 ("-gnatem=" & Gnatmake_Mapping_File.all,
3915 Compiler);
3916 end if;
3918 Osint.Add_Default_Search_Dirs;
3920 -- Source file lookups should be cached for efficiency. Source files
3921 -- are not supposed to change. However, we do that now only if no
3922 -- project file is used; if a project file is used, we do it just
3923 -- after changing the directory to the object directory.
3925 Osint.Source_File_Data (Cache => True);
3927 -- Read gnat.adc file to initialize Fname.UF
3929 Fname.UF.Initialize;
3931 if Config_File then
3932 begin
3933 Fname.SF.Read_Source_File_Name_Pragmas;
3935 exception
3936 when Err : SFN_Scan.Syntax_Error_In_GNAT_ADC =>
3937 Make_Failed (Exception_Message (Err));
3938 end;
3939 end if;
3941 if Debug.Debug_Flag_N then
3942 Opt.Keep_Temporary_Files := True;
3943 end if;
3944 end Initialize;
3946 ---------------------
3947 -- Is_In_Obsoleted --
3948 ---------------------
3950 function Is_In_Obsoleted (F : File_Name_Type) return Boolean is
3951 begin
3952 if F = No_File then
3953 return False;
3955 else
3956 declare
3957 Name : constant String := Get_Name_String (F);
3958 First : Natural;
3959 F2 : File_Name_Type;
3961 begin
3962 First := Name'Last;
3963 while First > Name'First
3964 and then not Is_Directory_Separator (Name (First - 1))
3965 loop
3966 First := First - 1;
3967 end loop;
3969 if First /= Name'First then
3970 Name_Len := 0;
3971 Add_Str_To_Name_Buffer (Name (First .. Name'Last));
3972 F2 := Name_Find;
3974 else
3975 F2 := F;
3976 end if;
3978 return Obsoleted.Get (F2);
3979 end;
3980 end if;
3981 end Is_In_Obsoleted;
3983 ----------
3984 -- Link --
3985 ----------
3987 procedure Link
3988 (ALI_File : File_Name_Type;
3989 Args : Argument_List;
3990 Success : out Boolean)
3992 Link_Args : Argument_List (1 .. Args'Length + 1);
3994 begin
3995 Get_Name_String (ALI_File);
3996 Link_Args (1) := new String'(Name_Buffer (1 .. Name_Len));
3998 Link_Args (2 .. Args'Length + 1) := Args;
4000 GNAT.OS_Lib.Normalize_Arguments (Link_Args);
4002 Display (Gnatlink.all, Link_Args);
4004 if Gnatlink_Path = null then
4005 Make_Failed ("error, unable to locate " & Gnatlink.all);
4006 end if;
4008 GNAT.OS_Lib.Spawn (Gnatlink_Path.all, Link_Args, Success);
4009 end Link;
4011 ---------------------------
4012 -- List_Bad_Compilations --
4013 ---------------------------
4015 procedure List_Bad_Compilations is
4016 begin
4017 if not No_Exit_Message then
4018 for J in Bad_Compilation.First .. Bad_Compilation.Last loop
4019 if Bad_Compilation.Table (J).File = No_File then
4020 null;
4021 elsif not Bad_Compilation.Table (J).Found then
4022 Inform (Bad_Compilation.Table (J).File, "not found");
4023 else
4024 Inform (Bad_Compilation.Table (J).File, "compilation error");
4025 end if;
4026 end loop;
4027 end if;
4028 end List_Bad_Compilations;
4030 -----------------
4031 -- List_Depend --
4032 -----------------
4034 procedure List_Depend is
4035 Lib_Name : File_Name_Type;
4036 Obj_Name : File_Name_Type;
4037 Src_Name : File_Name_Type;
4039 Len : Natural;
4040 Line_Pos : Natural;
4041 Line_Size : constant := 77;
4043 begin
4044 Set_Standard_Output;
4046 for A in ALIs.First .. ALIs.Last loop
4047 Lib_Name := ALIs.Table (A).Afile;
4049 -- We have to provide the full library file name in In_Place_Mode
4051 if In_Place_Mode then
4052 Lib_Name := Full_Lib_File_Name (Lib_Name);
4053 end if;
4055 Obj_Name := Object_File_Name (Lib_Name);
4056 Write_Name (Obj_Name);
4057 Write_Str (" :");
4059 Get_Name_String (Obj_Name);
4060 Len := Name_Len;
4061 Line_Pos := Len + 2;
4063 for D in ALIs.Table (A).First_Sdep .. ALIs.Table (A).Last_Sdep loop
4064 Src_Name := Sdep.Table (D).Sfile;
4066 if Is_Internal_File_Name (Src_Name)
4067 and then not Check_Readonly_Files
4068 then
4069 null;
4070 else
4071 if not Quiet_Output then
4072 Src_Name := Full_Source_Name (Src_Name);
4073 end if;
4075 Get_Name_String (Src_Name);
4076 Len := Name_Len;
4078 if Line_Pos + Len + 1 > Line_Size then
4079 Write_Str (" \");
4080 Write_Eol;
4081 Line_Pos := 0;
4082 end if;
4084 Line_Pos := Line_Pos + Len + 1;
4086 Write_Str (" ");
4087 Write_Name (Src_Name);
4088 end if;
4089 end loop;
4091 Write_Eol;
4092 end loop;
4094 if not Commands_To_Stdout then
4095 Set_Standard_Error;
4096 end if;
4097 end List_Depend;
4099 -----------------
4100 -- Make_Failed --
4101 -----------------
4103 procedure Make_Failed (S : String) is
4104 begin
4105 Fail_Program (S);
4106 end Make_Failed;
4108 --------------------
4109 -- Mark_Directory --
4110 --------------------
4112 procedure Mark_Directory (Dir : String; Mark : Lib_Mark_Type) is
4113 N : Name_Id;
4114 B : Byte;
4116 Real_Path : constant String := Normalize_Pathname (Dir, "");
4118 begin
4119 Name_Len := 0;
4121 if Real_Path'Length = 0 then
4122 Add_Str_To_Name_Buffer (Dir);
4124 else
4125 Add_Str_To_Name_Buffer (Real_Path);
4126 end if;
4128 -- Last character is supposed to be a directory separator
4130 if not Is_Directory_Separator (Name_Buffer (Name_Len)) then
4131 Add_Char_To_Name_Buffer (Directory_Separator);
4132 end if;
4134 -- Add flags to the already existing flags
4136 N := Name_Find;
4137 B := Get_Name_Table_Byte (N);
4138 Set_Name_Table_Byte (N, B or Mark);
4139 end Mark_Directory;
4141 ----------------------
4142 -- Process_Multilib --
4143 ----------------------
4145 procedure Process_Multilib is
4146 Output_FD : File_Descriptor;
4147 Output_Name : String_Access;
4148 Arg_Index : Natural := 0;
4149 Success : Boolean := False;
4150 Return_Code : Integer := 0;
4151 Multilib_Gcc_Path : String_Access;
4152 Multilib_Gcc : String_Access;
4153 N_Read : Integer := 0;
4154 Line : String (1 .. 1000);
4155 Args : Argument_List (1 .. N_M_Switch + 1);
4157 begin
4158 pragma Assert (N_M_Switch > 0 and RTS_Specified = null);
4160 -- In case we detected a multilib switch and the user has not
4161 -- manually specified a specific RTS we emulate the following command:
4162 -- gnatmake $FLAGS --RTS=$(gcc -print-multi-directory $FLAGS)
4164 -- First select the flags which might have an impact on multilib
4165 -- processing. Note that this is an heuristic selection and it
4166 -- will need to be maintained over time. The condition has to
4167 -- be kept synchronized with N_M_Switch counting in Scan_Make_Arg.
4169 for Next_Arg in 1 .. Argument_Count loop
4170 declare
4171 Argv : constant String := Argument (Next_Arg);
4173 begin
4174 if Argv'Length > 2
4175 and then Argv (1) = '-'
4176 and then Argv (2) = 'm'
4177 and then Argv /= "-margs"
4179 -- Ignore -mieee to avoid spawning an extra gcc in this case
4181 and then Argv /= "-mieee"
4182 then
4183 Arg_Index := Arg_Index + 1;
4184 Args (Arg_Index) := new String'(Argv);
4185 end if;
4186 end;
4187 end loop;
4189 pragma Assert (Arg_Index = N_M_Switch);
4191 Args (Args'Last) := new String'("-print-multi-directory");
4193 -- Call the GCC driver with the collected flags and save its
4194 -- output. Alternate design would be to link in gnatmake the
4195 -- relevant part of the GCC driver.
4197 Multilib_Gcc := Gcc;
4199 Multilib_Gcc_Path := GNAT.OS_Lib.Locate_Exec_On_Path (Multilib_Gcc.all);
4201 Create_Temp_Output_File (Output_FD, Output_Name);
4203 if Output_FD = Invalid_FD then
4204 return;
4205 end if;
4207 GNAT.OS_Lib.Spawn
4208 (Multilib_Gcc_Path.all, Args, Output_FD, Return_Code, False);
4209 Close (Output_FD);
4211 if Return_Code /= 0 then
4212 return;
4213 end if;
4215 -- Parse the GCC driver output which is a single line, removing CR/LF
4217 Output_FD := Open_Read (Output_Name.all, Binary);
4219 if Output_FD = Invalid_FD then
4220 return;
4221 end if;
4223 N_Read := Read (Output_FD, Line (1)'Address, Line'Length);
4224 Close (Output_FD);
4225 Delete_File (Output_Name.all, Success);
4227 for J in reverse 1 .. N_Read loop
4228 if Line (J) = ASCII.CR or else Line (J) = ASCII.LF then
4229 N_Read := N_Read - 1;
4230 else
4231 exit;
4232 end if;
4233 end loop;
4235 -- In case the standard RTS is selected do nothing
4237 if N_Read = 0 or else Line (1 .. N_Read) = "." then
4238 return;
4239 end if;
4241 -- Otherwise add -margs --RTS=output
4243 Scan_Make_Arg ("-margs");
4244 Scan_Make_Arg ("--RTS=" & Line (1 .. N_Read));
4245 end Process_Multilib;
4247 -------------------------------
4248 -- Report_Compilation_Failed --
4249 -------------------------------
4251 procedure Report_Compilation_Failed is
4252 begin
4253 Fail_Program ("");
4254 end Report_Compilation_Failed;
4256 ------------------------
4257 -- Sigint_Intercepted --
4258 ------------------------
4260 procedure Sigint_Intercepted is
4261 begin
4262 Set_Standard_Error;
4263 Write_Line ("*** Interrupted ***");
4265 -- Send SIGINT to all outstanding compilation processes spawned
4267 for J in 1 .. Outstanding_Compiles loop
4268 Kill (Running_Compile (J).Pid, Hard_Kill => False);
4269 end loop;
4271 Finish_Program (E_No_Compile);
4272 end Sigint_Intercepted;
4274 -------------------
4275 -- Scan_Make_Arg --
4276 -------------------
4278 procedure Scan_Make_Arg (Argv : String) is
4279 Success : Boolean;
4281 begin
4282 Gnatmake_Switch_Found := True;
4284 pragma Assert (Argv'First = 1);
4286 if Argv'Length = 0 then
4287 return;
4288 end if;
4290 -- If the previous switch has set the Output_File_Name_Present flag
4291 -- (that is we have seen a -o), then the next argument is the name of
4292 -- the output executable.
4294 if Output_File_Name_Present and then not Output_File_Name_Seen then
4295 Output_File_Name_Seen := True;
4297 if Argv (1) = '-' then
4298 Make_Failed ("output file name missing after -o");
4300 else
4301 Add_Switch ("-o", Linker);
4302 Add_Switch (Executable_Name (Argv), Linker);
4303 end if;
4305 -- If the previous switch has set the Object_Directory_Present flag
4306 -- (that is we have seen a -D), then the next argument is the path name
4307 -- of the object directory.
4309 elsif Object_Directory_Present
4310 and then not Object_Directory_Seen
4311 then
4312 Object_Directory_Seen := True;
4314 if Argv (1) = '-' then
4315 Make_Failed ("object directory path name missing after -D");
4317 elsif not Is_Directory (Argv) then
4318 Make_Failed ("cannot find object directory """ & Argv & """");
4320 else
4321 -- Record the object directory. Make sure it ends with a directory
4322 -- separator.
4324 declare
4325 Norm : constant String := Normalize_Pathname (Argv);
4327 begin
4328 if Norm (Norm'Last) = Directory_Separator then
4329 Object_Directory_Path := new String'(Norm);
4330 else
4331 Object_Directory_Path :=
4332 new String'(Norm & Directory_Separator);
4333 end if;
4335 Add_Lib_Search_Dir (Norm);
4337 -- Specify the object directory to the binder
4339 Add_Switch ("-aO" & Norm, Binder);
4340 end;
4342 end if;
4344 -- Then check if we are dealing with -cargs/-bargs/-largs/-margs. These
4345 -- options are taken as is when found in package Compiler, Binder or
4346 -- Linker of the main project file.
4348 elsif Argv = "-bargs" or else
4349 Argv = "-cargs" or else
4350 Argv = "-largs" or else
4351 Argv = "-margs"
4352 then
4353 case Argv (2) is
4354 when 'c' => Program_Args := Compiler;
4355 when 'b' => Program_Args := Binder;
4356 when 'l' => Program_Args := Linker;
4357 when 'm' => Program_Args := None;
4359 when others =>
4360 raise Program_Error;
4361 end case;
4363 -- A special test is needed for the -o switch within a -largs since that
4364 -- is another way to specify the name of the final executable.
4366 elsif Program_Args = Linker and then Argv = "-o" then
4367 Make_Failed
4368 ("switch -o not allowed within a -largs. Use -o directly.");
4370 -- Check to see if we are reading switches after a -cargs, -bargs or
4371 -- -largs switch. If so, save it.
4373 elsif Program_Args /= None then
4375 -- Check to see if we are reading -I switches in order to take into
4376 -- account in the src & lib search directories.
4378 if Argv'Length > 2 and then Argv (1 .. 2) = "-I" then
4379 if Argv (3 .. Argv'Last) = "-" then
4380 Look_In_Primary_Dir := False;
4382 elsif Program_Args = Compiler then
4383 Add_Source_Search_Dir (Argv (3 .. Argv'Last));
4385 elsif Program_Args = Binder then
4386 Add_Library_Search_Dir (Argv (3 .. Argv'Last));
4387 end if;
4388 end if;
4390 Add_Switch (Argv, Program_Args);
4392 -- Make sure that all significant switches -m on the command line
4393 -- are counted.
4395 if Argv'Length > 2
4396 and then Argv (1 .. 2) = "-m"
4397 and then Argv /= "-mieee"
4398 then
4399 N_M_Switch := N_M_Switch + 1;
4400 end if;
4402 -- Handle non-default compiler, binder, linker, and handle --RTS switch
4404 elsif Argv'Length > 2 and then Argv (1 .. 2) = "--" then
4405 if Argv'Length > 6
4406 and then Argv (1 .. 6) = "--GCC="
4407 then
4408 declare
4409 Program_Args : constant Argument_List_Access :=
4410 Argument_String_To_List
4411 (Argv (7 .. Argv'Last));
4413 begin
4414 Gcc := new String'(Program_Args.all (1).all);
4416 for J in 2 .. Program_Args.all'Last loop
4417 Add_Switch
4418 (Program_Args.all (J).all, Compiler);
4419 end loop;
4420 end;
4422 elsif Argv'Length > 11
4423 and then Argv (1 .. 11) = "--GNATBIND="
4424 then
4425 declare
4426 Program_Args : constant Argument_List_Access :=
4427 Argument_String_To_List
4428 (Argv (12 .. Argv'Last));
4430 begin
4431 Gnatbind := new String'(Program_Args.all (1).all);
4433 for J in 2 .. Program_Args.all'Last loop
4434 Add_Switch
4435 (Program_Args.all (J).all, Binder);
4436 end loop;
4437 end;
4439 elsif Argv'Length > 11
4440 and then Argv (1 .. 11) = "--GNATLINK="
4441 then
4442 declare
4443 Program_Args : constant Argument_List_Access :=
4444 Argument_String_To_List
4445 (Argv (12 .. Argv'Last));
4446 begin
4447 Gnatlink := new String'(Program_Args.all (1).all);
4449 for J in 2 .. Program_Args.all'Last loop
4450 Add_Switch (Program_Args.all (J).all, Linker);
4451 end loop;
4452 end;
4454 elsif Argv'Length >= 5 and then
4455 Argv (1 .. 5) = "--RTS"
4456 then
4457 Add_Switch (Argv, Compiler);
4458 Add_Switch (Argv, Binder);
4460 if Argv'Length <= 6 or else Argv (6) /= '=' then
4461 Make_Failed ("missing path for --RTS");
4463 else
4464 -- Check that this is the first time we see this switch or
4465 -- if it is not the first time, the same path is specified.
4467 if RTS_Specified = null then
4468 RTS_Specified := new String'(Argv (7 .. Argv'Last));
4470 elsif RTS_Specified.all /= Argv (7 .. Argv'Last) then
4471 Make_Failed ("--RTS cannot be specified multiple times");
4472 end if;
4474 -- Valid --RTS switch
4476 No_Stdinc := True;
4477 No_Stdlib := True;
4478 RTS_Switch := True;
4480 declare
4481 Src_Path_Name : constant String_Ptr :=
4482 Get_RTS_Search_Dir
4483 (Argv (7 .. Argv'Last), Include);
4485 Lib_Path_Name : constant String_Ptr :=
4486 Get_RTS_Search_Dir
4487 (Argv (7 .. Argv'Last), Objects);
4489 begin
4490 if Src_Path_Name /= null
4491 and then Lib_Path_Name /= null
4492 then
4493 -- Set RTS_*_Path_Name variables, so that correct direct-
4494 -- ories will be set when Osint.Add_Default_Search_Dirs
4495 -- is called later.
4497 RTS_Src_Path_Name := Src_Path_Name;
4498 RTS_Lib_Path_Name := Lib_Path_Name;
4500 elsif Src_Path_Name = null
4501 and then Lib_Path_Name = null
4502 then
4503 Make_Failed
4504 ("RTS path not valid: missing adainclude and adalib "
4505 & "directories");
4507 elsif Src_Path_Name = null then
4508 Make_Failed
4509 ("RTS path not valid: missing adainclude directory");
4511 elsif Lib_Path_Name = null then
4512 Make_Failed
4513 ("RTS path not valid: missing adalib directory");
4514 end if;
4515 end;
4516 end if;
4518 elsif (Argv'Length >= 8 and then Argv (1 .. 8) = "--param=")
4519 or else (Argv'Length >= 10 and then Argv (1 .. 10) = "--sysroot=")
4520 then
4521 Add_Switch (Argv, Compiler);
4522 Add_Switch (Argv, Linker);
4524 elsif Argv = Create_Map_File_Switch then
4525 Map_File := new String'("");
4527 elsif Argv'Length > Create_Map_File_Switch'Length + 1
4528 and then
4529 Argv (1 .. Create_Map_File_Switch'Length) = Create_Map_File_Switch
4530 and then
4531 Argv (Create_Map_File_Switch'Length + 1) = '='
4532 then
4533 Map_File :=
4534 new String'
4535 (Argv (Create_Map_File_Switch'Length + 2 .. Argv'Last));
4537 else
4538 Scan_Make_Switches (Argv, Success);
4539 end if;
4541 -- If we have seen a regular switch process it
4543 elsif Argv (1) = '-' then
4544 if Argv'Length = 1 then
4545 Make_Failed ("switch character cannot be followed by a blank");
4547 -- Incorrect switches that should start with "--"
4549 elsif (Argv'Length > 5 and then Argv (1 .. 5) = "-RTS=")
4550 or else (Argv'Length > 5 and then Argv (1 .. 5) = "-GCC=")
4551 or else (Argv'Length > 8 and then Argv (1 .. 7) = "-param=")
4552 or else (Argv'Length > 10 and then Argv (1 .. 10) = "-GNATLINK=")
4553 or else (Argv'Length > 10 and then Argv (1 .. 10) = "-GNATBIND=")
4554 then
4555 Make_Failed ("option " & Argv & " should start with '--'");
4557 -- -I-
4559 elsif Argv (2 .. Argv'Last) = "I-" then
4560 Look_In_Primary_Dir := False;
4562 -- Forbid -?- or -??- where ? is any character
4564 elsif (Argv'Length = 3 and then Argv (3) = '-')
4565 or else (Argv'Length = 4 and then Argv (4) = '-')
4566 then
4567 Make_Failed
4568 ("trailing ""-"" at the end of " & Argv & " forbidden.");
4570 -- -Idir
4572 elsif Argv (2) = 'I' then
4573 Add_Source_Search_Dir (Argv (3 .. Argv'Last));
4574 Add_Library_Search_Dir (Argv (3 .. Argv'Last));
4575 Add_Switch (Argv, Compiler);
4576 Add_Switch (Argv, Binder);
4578 -- -aIdir (to gcc this is like a -I switch)
4580 elsif Argv'Length >= 3 and then Argv (2 .. 3) = "aI" then
4581 Add_Source_Search_Dir (Argv (4 .. Argv'Last));
4582 Add_Switch
4583 ("-I" & Argv (4 .. Argv'Last), Compiler);
4584 Add_Switch (Argv, Binder);
4586 -- -aOdir
4588 elsif Argv'Length >= 3 and then Argv (2 .. 3) = "aO" then
4589 Add_Library_Search_Dir (Argv (4 .. Argv'Last));
4590 Add_Switch (Argv, Binder);
4592 -- -aLdir (to gnatbind this is like a -aO switch)
4594 elsif Argv'Length >= 3 and then Argv (2 .. 3) = "aL" then
4595 Mark_Directory (Argv (4 .. Argv'Last), Ada_Lib_Dir);
4596 Add_Library_Search_Dir (Argv (4 .. Argv'Last));
4597 Add_Switch
4598 ("-aO" & Argv (4 .. Argv'Last), Binder);
4600 -- -Adir (to gnatbind this is like a -aO switch, to gcc like a -I)
4602 elsif Argv (2) = 'A' then
4603 Mark_Directory (Argv (3 .. Argv'Last), Ada_Lib_Dir);
4604 Add_Source_Search_Dir (Argv (3 .. Argv'Last));
4605 Add_Library_Search_Dir (Argv (3 .. Argv'Last));
4606 Add_Switch ("-I" & Argv (3 .. Argv'Last), Compiler);
4607 Add_Switch ("-aO" & Argv (3 .. Argv'Last), Binder);
4609 -- -Ldir
4611 elsif Argv (2) = 'L' then
4612 Add_Switch (Argv, Linker);
4614 -- For -gxxx, -pg, -mxxx, -fxxx, -Oxxx, pass the switch to both the
4615 -- compiler and the linker (except for -gnatxxx which is only for the
4616 -- compiler). Some of the -mxxx (for example -m64) and -fxxx (for
4617 -- example -ftest-coverage for gcov) need to be used when compiling
4618 -- the binder generated files, and using all these gcc switches for
4619 -- them should not be a problem. Pass -Oxxx to the linker for LTO.
4621 elsif
4622 (Argv (2) = 'g' and then (Argv'Last < 5
4623 or else Argv (2 .. 5) /= "gnat"))
4624 or else Argv (2 .. Argv'Last) = "pg"
4625 or else (Argv (2) = 'm' and then Argv'Last > 2)
4626 or else (Argv (2) = 'f' and then Argv'Last > 2)
4627 or else Argv (2) = 'O'
4628 then
4629 Add_Switch (Argv, Compiler);
4630 Add_Switch (Argv, Linker);
4632 -- The following condition has to be kept synchronized with
4633 -- the Process_Multilib one.
4635 if Argv (2) = 'm'
4636 and then Argv /= "-mieee"
4637 then
4638 N_M_Switch := N_M_Switch + 1;
4639 end if;
4641 -- -C=<mapping file>
4643 elsif Argv'Last > 2 and then Argv (2) = 'C' then
4644 if Argv (3) /= '=' or else Argv'Last <= 3 then
4645 Make_Failed ("illegal switch " & Argv);
4646 end if;
4648 Gnatmake_Mapping_File := new String'(Argv (4 .. Argv'Last));
4650 -- -D
4652 elsif Argv'Last = 2 and then Argv (2) = 'D' then
4653 if Project_File_Name /= null then
4654 Make_Failed
4655 ("-D cannot be used in conjunction with a project file");
4657 else
4658 Scan_Make_Switches (Argv, Success);
4659 end if;
4661 -- -d
4663 elsif Argv (2) = 'd' and then Argv'Last = 2 then
4664 Display_Compilation_Progress := True;
4666 -- -i
4668 elsif Argv'Last = 2 and then Argv (2) = 'i' then
4669 if Project_File_Name /= null then
4670 Make_Failed
4671 ("-i cannot be used in conjunction with a project file");
4672 else
4673 Scan_Make_Switches (Argv, Success);
4674 end if;
4676 -- -j (need to save the result)
4678 elsif Argv (2) = 'j' then
4679 Scan_Make_Switches (Argv, Success);
4681 -- -m
4683 elsif Argv (2) = 'm' then
4684 pragma Assert (Argv'Last = 2);
4685 Minimal_Recompilation := True;
4687 -- -u and -U (they are differentiated elsewhere)
4689 elsif Argv (2) in 'u' | 'U' and then Argv'Last = 2 then
4690 Unique_Compile := True;
4691 Compile_Only := True;
4692 Do_Bind_Step := False;
4693 Do_Link_Step := False;
4695 -- -Pprj or -P prj (only once, and only on the command line)
4697 elsif Argv (2) = 'P' then
4698 if Project_File_Name /= null then
4699 Make_Failed ("cannot have several project files specified");
4701 elsif Object_Directory_Path /= null then
4702 Make_Failed
4703 ("-D cannot be used in conjunction with a project file");
4705 elsif In_Place_Mode then
4706 Make_Failed
4707 ("-i cannot be used in conjunction with a project file");
4709 elsif Argv'Last = 2 then
4711 -- -P is used alone: the project file name is the next option
4713 Project_File_Name_Present := True;
4715 else
4716 Project_File_Name := new String'(Argv (3 .. Argv'Last));
4717 end if;
4719 -- -vPx (verbosity of the parsing of the project files)
4721 elsif Argv'Length >= 3 and then Argv (2 .. 3) = "vP" then
4722 if Argv'Last /= 4 or else Argv (4) not in '0' .. '2' then
4723 Make_Failed
4724 ("invalid verbosity level " & Argv (4 .. Argv'Last));
4725 end if;
4727 -- -Xext=val (External assignment)
4729 elsif Argv (2) = 'X' then
4730 null;
4732 -- If -gnath is present, then generate the usage information right
4733 -- now and do not pass this option on to the compiler calls.
4735 elsif Argv = "-gnath" then
4736 Usage;
4738 -- If -gnatc is specified, make sure the bind and link steps are not
4739 -- executed.
4741 elsif Argv'Length >= 6 and then Argv (2 .. 6) = "gnatc" then
4743 -- If -gnatc is specified, make sure the bind and link steps are
4744 -- not executed.
4746 Add_Switch (Argv, Compiler);
4747 Operating_Mode := Check_Semantics;
4748 Check_Object_Consistency := False;
4750 -- Except in CodePeer mode (set by -gnatcC), where we do want to
4751 -- call bind/link in CodePeer mode (-P switch).
4753 if Argv'Last >= 7 and then Argv (7) = 'C' then
4754 CodePeer_Mode := True;
4755 else
4756 Compile_Only := True;
4757 Do_Bind_Step := False;
4758 Do_Link_Step := False;
4759 end if;
4761 -- If -gnatA is specified, make sure that gnat.adc is never read
4763 elsif Argv'Length >= 6 and then Argv (2 .. 6) = "gnatA" then
4764 Add_Switch (Argv, Compiler);
4765 Opt.Config_File := False;
4767 elsif Argv (2 .. Argv'Last) = "nostdlib" then
4769 -- Pass -nstdlib to gnatbind and gnatlink
4771 No_Stdlib := True;
4772 Add_Switch (Argv, Binder);
4773 Add_Switch (Argv, Linker);
4775 elsif Argv (2 .. Argv'Last) = "nostdinc" then
4777 -- Pass -nostdinc to the Compiler and to gnatbind
4779 No_Stdinc := True;
4780 Add_Switch (Argv, Compiler);
4781 Add_Switch (Argv, Binder);
4783 -- All other switches are processed by Scan_Make_Switches. If the
4784 -- call returns with Gnatmake_Switch_Found = False, then the switch
4785 -- is passed to the compiler.
4787 else
4788 Scan_Make_Switches (Argv, Gnatmake_Switch_Found);
4790 if not Gnatmake_Switch_Found then
4791 Add_Switch (Argv, Compiler);
4792 end if;
4793 end if;
4795 -- If not a switch it must be a file name
4797 else
4798 Main_On_Command_Line := True;
4800 Add_File (Argv);
4801 Mains.Add_Main (Argv);
4802 end if;
4803 end Scan_Make_Arg;
4805 -----------
4806 -- Usage --
4807 -----------
4809 procedure Usage is
4810 begin
4811 if Usage_Needed then
4812 Usage_Needed := False;
4813 Makeusg;
4814 end if;
4815 end Usage;
4817 end Make;