1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 1992-2004 Free Software Foundation, Inc. --
11 -- GNAT is free software; you can redistribute it and/or modify it under --
12 -- terms of the GNU General Public License as published by the Free Soft- --
13 -- ware Foundation; either version 2, 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 COPYING. If not, write --
19 -- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
20 -- MA 02111-1307, USA. --
22 -- GNAT was originally developed by the GNAT team at New York University. --
23 -- Extensive contributions were provided by Ada Core Technologies Inc. --
25 ------------------------------------------------------------------------------
28 with ALI.Util; use ALI.Util;
32 with Fname; use Fname;
33 with Fname.SF; use Fname.SF;
34 with Fname.UF; use Fname.UF;
35 with Gnatvsn; use Gnatvsn;
36 with Hostparm; use Hostparm;
39 with MLib.Tgt; use MLib.Tgt;
41 with Namet; use Namet;
43 with Osint.M; use Osint.M;
44 with Osint; use Osint;
46 with Output; use Output;
55 with Snames; use Snames;
56 with Switch; use Switch;
57 with Switch.M; use Switch.M;
61 with Ada.Exceptions; use Ada.Exceptions;
62 with Ada.Command_Line; use Ada.Command_Line;
64 with GNAT.Directory_Operations; use GNAT.Directory_Operations;
65 with GNAT.Case_Util; use GNAT.Case_Util;
72 -- Make control characters visible
74 Standard_Library_Package_Body_Name : constant String := "s-stalib.adb";
75 -- Every program depends on this package, that must then be checked,
76 -- especially when -f and -a are used.
78 type Sigint_Handler is access procedure;
80 procedure Install_Int_Handler (Handler : Sigint_Handler);
81 pragma Import (C, Install_Int_Handler, "__gnat_install_int_handler");
82 -- Called by Gnatmake to install the SIGINT handler below
84 procedure Sigint_Intercepted;
85 -- Called when the program is interrupted by Ctrl-C to delete the
86 -- temporary mapping files and configuration pragmas files.
88 -------------------------
89 -- Note on terminology --
90 -------------------------
92 -- In this program, we use the phrase "termination" of a file name to
93 -- refer to the suffix that appears after the unit name portion. Very
94 -- often this is simply the extension, but in some cases, the sequence
95 -- may be more complex, for example in main.1.ada, the termination in
96 -- this name is ".1.ada" and in main_.ada the termination is "_.ada".
98 -------------------------------------
99 -- Queue (Q) Manipulation Routines --
100 -------------------------------------
102 -- The Q is used in Compile_Sources below. Its implementation uses the
103 -- GNAT generic package Table (basically an extensible array). Q_Front
104 -- points to the first valid element in the Q, whereas Q.First is the first
105 -- element ever enqueued, while Q.Last - 1 is the last element in the Q.
107 -- +---+--------------+---+---+---+-----------+---+--------
108 -- Q | | ........ | | | | ....... | |
109 -- +---+--------------+---+---+---+-----------+---+--------
111 -- Q.First Q_Front Q.Last - 1
113 -- The elements comprised between Q.First and Q_Front - 1 are the
114 -- elements that have been enqueued and then dequeued, while the
115 -- elements between Q_Front and Q.Last - 1 are the elements currently
116 -- in the Q. When the Q is initialized Q_Front = Q.First = Q.Last.
117 -- After Compile_Sources has terminated its execution, Q_Front = Q.Last
118 -- and the elements contained between Q.Front and Q.Last-1 are those that
119 -- were explored and thus marked by Compile_Sources. Whenever the Q is
120 -- reinitialized, the elements between Q.First and Q.Last - 1 are unmarked.
123 -- Must be called to (re)initialize the Q.
126 (Source_File : File_Name_Type;
127 Source_Unit : Unit_Name_Type := No_Name);
128 -- Inserts Source_File at the end of Q. Provide Source_Unit when
129 -- possible for external use (gnatdist).
131 function Empty_Q return Boolean;
132 -- Returns True if Q is empty.
134 procedure Extract_From_Q
135 (Source_File : out File_Name_Type;
136 Source_Unit : out Unit_Name_Type);
137 -- Extracts the first element from the Q.
139 procedure Insert_Project_Sources
140 (The_Project : Project_Id;
141 All_Projects : Boolean;
143 -- If Into_Q is True, insert all sources of the project file(s) that are
144 -- not already marked into the Q. If Into_Q is False, call Osint.Add_File
145 -- for the first source, then insert all other sources that are not already
146 -- marked into the Q. If All_Projects is True, all sources of all projects
147 -- are concerned; otherwise, only sources of The_Project are concerned,
148 -- including, if The_Project is an extending project, sources inherited
149 -- from projects being extended.
151 First_Q_Initialization : Boolean := True;
152 -- Will be set to false after Init_Q has been called once.
155 -- Points to the first valid element in the Q.
157 Unique_Compile : Boolean := False;
158 -- Set to True if -u or -U or a project file with no main is used
160 Unique_Compile_All_Projects : Boolean := False;
161 -- Set to True if -U is used
163 RTS_Specified : String_Access := null;
164 -- Used to detect multiple --RTS= switches
166 type Q_Record is record
167 File : File_Name_Type;
168 Unit : Unit_Name_Type;
170 -- File is the name of the file to compile. Unit is for gnatdist
171 -- use in order to easily get the unit name of a file to compile
172 -- when its name is krunched or declared in gnat.adc.
174 package Q is new Table.Table (
175 Table_Component_Type => Q_Record,
176 Table_Index_Type => Natural,
177 Table_Low_Bound => 0,
178 Table_Initial => 4000,
179 Table_Increment => 100,
180 Table_Name => "Make.Q");
181 -- This is the actual Q.
183 -- Package Mains is used to store the mains specified on the command line
184 -- and to retrieve them when a project file is used, to verify that the
185 -- files exist and that they belong to a project file.
189 -- Mains are stored in a table. An index is used to retrieve the mains
192 procedure Add_Main (Name : String);
193 -- Add one main to the table
199 -- Reset the index to the beginning of the table
201 function Next_Main return String;
202 -- Increase the index and return the next main.
203 -- If table is exhausted, return an empty string.
207 -- The following instantiations and variables are necessary to save what
208 -- is found on the command line, in case there is a project file specified.
210 package Saved_Gcc_Switches is new Table.Table (
211 Table_Component_Type => String_Access,
212 Table_Index_Type => Integer,
213 Table_Low_Bound => 1,
215 Table_Increment => 100,
216 Table_Name => "Make.Saved_Gcc_Switches");
218 package Saved_Binder_Switches is new Table.Table (
219 Table_Component_Type => String_Access,
220 Table_Index_Type => Integer,
221 Table_Low_Bound => 1,
223 Table_Increment => 100,
224 Table_Name => "Make.Saved_Binder_Switches");
226 package Saved_Linker_Switches is new Table.Table
227 (Table_Component_Type => String_Access,
228 Table_Index_Type => Integer,
229 Table_Low_Bound => 1,
231 Table_Increment => 100,
232 Table_Name => "Make.Saved_Linker_Switches");
234 package Switches_To_Check is new Table.Table (
235 Table_Component_Type => String_Access,
236 Table_Index_Type => Integer,
237 Table_Low_Bound => 1,
239 Table_Increment => 100,
240 Table_Name => "Make.Switches_To_Check");
242 package Library_Paths is new Table.Table (
243 Table_Component_Type => String_Access,
244 Table_Index_Type => Integer,
245 Table_Low_Bound => 1,
247 Table_Increment => 100,
248 Table_Name => "Make.Library_Paths");
250 package Failed_Links is new Table.Table (
251 Table_Component_Type => File_Name_Type,
252 Table_Index_Type => Integer,
253 Table_Low_Bound => 1,
255 Table_Increment => 100,
256 Table_Name => "Make.Failed_Links");
258 package Successful_Links is new Table.Table (
259 Table_Component_Type => File_Name_Type,
260 Table_Index_Type => Integer,
261 Table_Low_Bound => 1,
263 Table_Increment => 100,
264 Table_Name => "Make.Successful_Links");
266 package Library_Projs is new Table.Table (
267 Table_Component_Type => Project_Id,
268 Table_Index_Type => Integer,
269 Table_Low_Bound => 1,
271 Table_Increment => 100,
272 Table_Name => "Make.Library_Projs");
274 type Linker_Options_Data is record
275 Project : Project_Id;
276 Options : String_List_Id;
279 package Linker_Opts is new Table.Table (
280 Table_Component_Type => Linker_Options_Data,
281 Table_Index_Type => Integer,
282 Table_Low_Bound => 1,
284 Table_Increment => 100,
285 Table_Name => "Make.Linker_Opts");
287 -- Two variables to keep the last binder and linker switch index
288 -- in tables Binder_Switches and Linker_Switches, before adding
289 -- switches from the project file (if any) and switches from the
290 -- command line (if any).
292 Last_Binder_Switch : Integer := 0;
293 Last_Linker_Switch : Integer := 0;
295 Normalized_Switches : Argument_List_Access := new Argument_List (1 .. 10);
296 Last_Norm_Switch : Natural := 0;
298 Saved_Maximum_Processes : Natural := 0;
300 type Arg_List_Ref is access Argument_List;
301 The_Saved_Gcc_Switches : Arg_List_Ref;
303 Project_File_Name : String_Access := null;
304 -- The path name of the main project file, if any
306 Project_File_Name_Present : Boolean := False;
307 -- True when -P is used with a space between -P and the project file name
309 Current_Verbosity : Prj.Verbosity := Prj.Default;
310 -- Verbosity to parse the project files
312 Main_Project : Prj.Project_Id := No_Project;
313 -- The project id of the main project file, if any
315 Project_Object_Directory : Project_Id := No_Project;
316 -- The object directory of the project for the last compilation.
317 -- Avoid calling Change_Dir if the current working directory is already
320 -- Packages of project files where unknown attributes are errors.
322 Naming_String : aliased String := "naming";
323 Builder_String : aliased String := "builder";
324 Compiler_String : aliased String := "compiler";
325 Binder_String : aliased String := "binder";
326 Linker_String : aliased String := "linker";
328 Gnatmake_Packages : aliased String_List :=
329 (Naming_String 'Access,
330 Builder_String 'Access,
331 Compiler_String 'Access,
332 Binder_String 'Access,
333 Linker_String 'Access);
335 Packages_To_Check_By_Gnatmake : constant String_List_Access :=
336 Gnatmake_Packages'Access;
338 procedure Add_Source_Dir (N : String);
339 -- Call Add_Src_Search_Dir.
340 -- Output one line when in verbose mode.
342 procedure Add_Source_Directories is
343 new Prj.Env.For_All_Source_Dirs (Action => Add_Source_Dir);
345 procedure Add_Object_Dir (N : String);
346 -- Call Add_Lib_Search_Dir.
347 -- Output one line when in verbose mode.
349 procedure Add_Object_Directories is
350 new Prj.Env.For_All_Object_Dirs (Action => Add_Object_Dir);
352 procedure Change_To_Object_Directory (Project : Project_Id);
353 -- Change to the object directory of project Project, if this is not
354 -- already the current working directory.
356 type Bad_Compilation_Info is record
357 File : File_Name_Type;
358 Unit : Unit_Name_Type;
361 -- File is the name of the file for which a compilation failed.
362 -- Unit is for gnatdist use in order to easily get the unit name
363 -- of a file when its name is krunched or declared in gnat.adc.
364 -- Found is False if the compilation failed because the file could
367 package Bad_Compilation is new Table.Table (
368 Table_Component_Type => Bad_Compilation_Info,
369 Table_Index_Type => Natural,
370 Table_Low_Bound => 1,
372 Table_Increment => 100,
373 Table_Name => "Make.Bad_Compilation");
374 -- Full name of all the source files for which compilation fails.
376 Do_Compile_Step : Boolean := True;
377 Do_Bind_Step : Boolean := True;
378 Do_Link_Step : Boolean := True;
379 -- Flags to indicate what step should be executed.
380 -- Can be set to False with the switches -c, -b and -l.
381 -- These flags are reset to True for each invokation of procedure Gnatmake.
383 Shared_String : aliased String := "-shared";
385 No_Shared_Switch : aliased Argument_List := (1 .. 0 => null);
386 Shared_Switch : aliased Argument_List := (1 => Shared_String'Access);
387 Bind_Shared : Argument_List_Access := No_Shared_Switch'Access;
388 -- Switch to added in front of gnatbind switches. By default no switch is
389 -- added. Switch "-shared" is added if there is a non-static Library
392 Bind_Shared_Known : Boolean := False;
393 -- Set to True after the first time Bind_Shared is computed
395 Shared_Libgcc : aliased String := "-shared-libgcc";
397 No_Shared_Libgcc_Switch : aliased Argument_List := (1 .. 0 => null);
398 Shared_Libgcc_Switch : aliased Argument_List :=
399 (1 => Shared_Libgcc'Access);
400 Link_With_Shared_Libgcc : Argument_List_Access :=
401 No_Shared_Libgcc_Switch'Access;
403 procedure Make_Failed (S1 : String; S2 : String := ""; S3 : String := "");
404 -- Delete all temp files created by Gnatmake and call Osint.Fail,
405 -- with the parameter S1, S2 and S3 (see osint.ads).
406 -- This is called from the Prj hierarchy and the MLib hierarchy.
408 --------------------------
409 -- Obsolete Executables --
410 --------------------------
412 Executable_Obsolete : Boolean := False;
413 -- Executable_Obsolete is initially set to False for each executable,
414 -- and is set to True whenever one of the source of the executable is
415 -- compiled, or has already been compiled for another executable.
417 Max_Header : constant := 200; -- Arbitrary
419 type Header_Num is range 1 .. Max_Header;
420 -- Header_Num for the hash table Obsoleted below
422 function Hash (F : Name_Id) return Header_Num;
423 -- Hash function for the hash table Obsoleted below
425 package Obsoleted is new System.HTable.Simple_HTable
426 (Header_Num => Header_Num,
432 -- A hash table to keep all files that have been compiled, to detect
433 -- if an executable is up to date or not.
435 procedure Enter_Into_Obsoleted (F : Name_Id);
436 -- Enter a file name, without directory information, into the has table
439 function Is_In_Obsoleted (F : Name_Id) return Boolean;
440 -- Check if a file name, without directory information, has already been
441 -- entered into the hash table Obsoleted.
443 type Dependency is record
445 Depends_On : Name_Id;
447 -- Components of table Dependencies below.
449 package Dependencies is new Table.Table (
450 Table_Component_Type => Dependency,
451 Table_Index_Type => Integer,
452 Table_Low_Bound => 1,
454 Table_Increment => 100,
455 Table_Name => "Make.Dependencies");
456 -- A table to keep dependencies, to be able to decide if an executable
459 procedure Add_Dependency (S : Name_Id; On : Name_Id);
460 -- Add one entry in table Dependencies
462 ----------------------------
463 -- Arguments and Switches --
464 ----------------------------
466 Arguments : Argument_List_Access;
467 -- Used to gather the arguments for invocation of the compiler
469 Last_Argument : Natural := 0;
470 -- Last index of arguments in Arguments above
472 Arguments_Collected : Boolean := False;
473 -- Set to True when the arguments for the next invocation of the compiler
474 -- have been collected.
476 Arguments_Project : Project_Id;
477 -- Project id, if any, of the source to be compiled
479 Arguments_Path_Name : File_Name_Type;
480 -- Full path of the source to be compiled, when Arguments_Project is not
483 Dummy_Switch : constant String_Access := new String'("- ");
484 -- Used to initialized Prev_Switch in procedure Check
486 procedure Add_Arguments (Args : Argument_List);
487 -- Add arguments to global variable Arguments, increasing its size
488 -- if necessary and adjusting Last_Argument.
490 function Configuration_Pragmas_Switch
491 (For_Project : Project_Id) return Argument_List;
492 -- Return an argument list of one element, if there is a configuration
493 -- pragmas file to be specified for For_Project,
494 -- otherwise return an empty argument list.
496 ----------------------
497 -- Marking Routines --
498 ----------------------
500 Marking_Label : Byte := 1;
501 -- Value to mark the source files
503 procedure Mark (Source_File : File_Name_Type);
504 -- Mark Source_File. Marking is used to signal that Source_File has
505 -- already been inserted in the Q.
507 function Is_Marked (Source_File : File_Name_Type) return Boolean;
508 -- Returns True if Source_File was previously marked.
514 procedure List_Depend;
515 -- Prints to standard output the list of object dependencies. This list
516 -- can be used directly in a Makefile. A call to Compile_Sources must
517 -- precede the call to List_Depend. Also because this routine uses the
518 -- ALI files that were originally loaded and scanned by Compile_Sources,
519 -- no additional ALI files should be scanned between the two calls (i.e.
520 -- between the call to Compile_Sources and List_Depend.)
522 procedure Inform (N : Name_Id := No_Name; Msg : String);
523 -- Prints out the program name followed by a colon, N and S.
525 procedure List_Bad_Compilations;
526 -- Prints out the list of all files for which the compilation failed.
528 procedure Verbose_Msg
531 N2 : Name_Id := No_Name;
533 Prefix : String := " -> ");
534 -- If the verbose flag (Verbose_Mode) is set then print Prefix to standard
535 -- output followed by N1 and S1. If N2 /= No_Name then N2 is then printed
536 -- after S1. S2 is printed last. Both N1 and N2 are printed in quotation
539 Usage_Needed : Boolean := True;
540 -- Flag used to make sure Makeusg is call at most once
543 -- Call Makeusg, if Usage_Needed is True.
544 -- Set Usage_Needed to False.
546 procedure Debug_Msg (S : String; N : Name_Id);
547 -- If Debug.Debug_Flag_W is set outputs string S followed by name N.
549 type Project_Array is array (Positive range <>) of Project_Id;
550 No_Projects : constant Project_Array := (1 .. 0 => No_Project);
552 procedure Recursive_Compute_Depth
553 (Project : Project_Id;
554 Visited : Project_Array;
556 -- Compute depth of Project and of the projects it depends on
558 -----------------------
559 -- Gnatmake Routines --
560 -----------------------
562 Gnatmake_Called : Boolean := False;
563 -- Set to True when procedure Gnatmake is called.
564 -- Attempt to delete temporary files is made only when Gnatmake_Called
567 subtype Lib_Mark_Type is Byte;
568 -- Used in Mark_Directory
570 Ada_Lib_Dir : constant Lib_Mark_Type := 1;
571 -- Used to mark a directory as a GNAT lib dir
573 -- Note that the notion of GNAT lib dir is no longer used. The code
574 -- related to it has not been removed to give an idea on how to use
575 -- the directory prefix marking mechanism.
577 -- An Ada library directory is a directory containing ali and object
578 -- files but no source files for the bodies (the specs can be in the
579 -- same or some other directory). These directories are specified
580 -- in the Gnatmake command line with the switch "-Adir" (to specify the
581 -- spec location -Idir cab be used). Gnatmake skips the missing sources
582 -- whose ali are in Ada library directories. For an explanation of why
583 -- Gnatmake behaves that way, see the spec of Make.Compile_Sources.
584 -- The directory lookup penalty is incurred every single time this
585 -- routine is called.
587 procedure Check_Steps;
588 -- Check what steps (Compile, Bind, Link) must be executed.
589 -- Set the step flags accordingly.
591 function Is_External_Assignment (Argv : String) return Boolean;
592 -- Verify that an external assignment switch is syntactically correct.
595 -- -X"name=other value"
596 -- Assumptions: 'First = 1, Argv (1 .. 2) = "-X"
597 -- When this function returns True, the external assignment has
598 -- been entered by a call to Prj.Ext.Add, so that in a project
599 -- file, External ("name") will return "value".
601 function In_Ada_Lib_Dir (File : File_Name_Type) return Boolean;
602 -- Get directory prefix of this file and get lib mark stored in name
603 -- table for this directory. Then check if an Ada lib mark has been set.
605 procedure Mark_Directory
607 Mark : Lib_Mark_Type);
608 -- Store Dir in name table and set lib mark as name info to identify
611 Output_Is_Object : Boolean := True;
612 -- Set to False when using a switch -S for the compiler
614 procedure Check_For_S_Switch;
615 -- Set Output_Is_Object to False when the -S switch is used for the
619 (Source_File : Name_Id;
620 Source_File_Name : String;
621 Naming : Naming_Data;
622 In_Package : Package_Id;
623 Allow_ALI : Boolean) return Variable_Value;
624 -- Return the switches for the source file in the specified package
625 -- of a project file. If the Source_File ends with a standard GNAT
626 -- extension (".ads" or ".adb"), try first the full name, then the
627 -- name without the extension, then, if Allow_ALI is True, the name with
628 -- the extension ".ali". If there is no switches for either names, try the
629 -- default switches for Ada. If all failed, return No_Variable_Value.
631 procedure Test_If_Relative_Path
632 (Switch : in out String_Access;
633 Parent : String_Access;
634 Including_L_Switch : Boolean := True);
635 -- Test if Switch is a relative search path switch.
636 -- If it is, fail if Parent is null, otherwise prepend the path with
637 -- Parent. This subprogram is only called when using project files.
638 -- For gnatbind switches, Including_L_Switch is False, because the
639 -- argument of the -L switch is not a path.
641 function Is_In_Object_Directory
642 (Source_File : File_Name_Type;
643 Full_Lib_File : File_Name_Type) return Boolean;
644 -- Check if, when using a project file, the ALI file is in the project
645 -- directory of the ultimate extending project. If it is not, we ignore
646 -- the fact that this ALI file is read-only.
648 ----------------------------------------------------
649 -- Compiler, Binder & Linker Data and Subprograms --
650 ----------------------------------------------------
652 Gcc : String_Access := Program_Name ("gcc");
653 Gnatbind : String_Access := Program_Name ("gnatbind");
654 Gnatlink : String_Access := Program_Name ("gnatlink");
655 -- Default compiler, binder, linker programs
657 Saved_Gcc : String_Access := null;
658 Saved_Gnatbind : String_Access := null;
659 Saved_Gnatlink : String_Access := null;
660 -- Given by the command line. Will be used, if non null.
662 Gcc_Path : String_Access :=
663 GNAT.OS_Lib.Locate_Exec_On_Path (Gcc.all);
664 Gnatbind_Path : String_Access :=
665 GNAT.OS_Lib.Locate_Exec_On_Path (Gnatbind.all);
666 Gnatlink_Path : String_Access :=
667 GNAT.OS_Lib.Locate_Exec_On_Path (Gnatlink.all);
668 -- Path for compiler, binder, linker programs, defaulted now for gnatdist.
669 -- Changed later if overridden on command line.
671 Comp_Flag : constant String_Access := new String'("-c");
672 Output_Flag : constant String_Access := new String'("-o");
673 Ada_Flag_1 : constant String_Access := new String'("-x");
674 Ada_Flag_2 : constant String_Access := new String'("ada");
675 No_gnat_adc : constant String_Access := new String'("-gnatA");
676 GNAT_Flag : constant String_Access := new String'("-gnatpg");
677 Do_Not_Check_Flag : constant String_Access := new String'("-x");
679 Object_Suffix : constant String := Get_Object_Suffix.all;
680 Executable_Suffix : constant String := Get_Executable_Suffix.all;
682 Syntax_Only : Boolean := False;
683 -- Set to True when compiling with -gnats
685 Display_Executed_Programs : Boolean := True;
686 -- Set to True if name of commands should be output on stderr.
688 Output_File_Name_Seen : Boolean := False;
689 -- Set to True after having scanned the file_name for
690 -- switch "-o file_name"
692 Object_Directory_Seen : Boolean := False;
693 -- Set to True after having scanned the object directory for
694 -- switch "-D obj_dir".
696 Object_Directory_Path : String_Access := null;
697 -- The path name of the object directory, set with switch -D.
699 type Make_Program_Type is (None, Compiler, Binder, Linker);
701 Program_Args : Make_Program_Type := None;
702 -- Used to indicate if we are scanning gnatmake, gcc, gnatbind, or gnatbind
703 -- options within the gnatmake command line.
704 -- Used in Scan_Make_Arg only, but must be a global variable.
706 Temporary_Config_File : Boolean := False;
707 -- Set to True when there is a temporary config file used for a project
708 -- file, to avoid displaying the -gnatec switch for a temporary file.
710 procedure Add_Switches
711 (The_Package : Package_Id;
713 Program : Make_Program_Type);
716 Program : Make_Program_Type;
717 Append_Switch : Boolean := True;
718 And_Save : Boolean := True);
721 Program : Make_Program_Type;
722 Append_Switch : Boolean := True;
723 And_Save : Boolean := True);
724 -- Make invokes one of three programs (the compiler, the binder or the
725 -- linker). For the sake of convenience, some program specific switches
726 -- can be passed directly on the gnatmake commande line. This procedure
727 -- records these switches so that gnamake can pass them to the right
728 -- program. S is the switch to be added at the end of the command line
729 -- for Program if Append_Switch is True. If Append_Switch is False S is
730 -- added at the beginning of the command line.
733 (Source_File : File_Name_Type;
734 The_Args : Argument_List;
735 Lib_File : File_Name_Type;
738 O_File : out File_Name_Type;
739 O_Stamp : out Time_Stamp_Type);
740 -- Determines whether the library file Lib_File is up-to-date or not. The
741 -- full name (with path information) of the object file corresponding to
742 -- Lib_File is returned in O_File. Its time stamp is saved in O_Stamp.
743 -- ALI is the ALI_Id corresponding to Lib_File. If Lib_File in not
744 -- up-to-date, then the corresponding source file needs to be recompiled.
745 -- In this case ALI = No_ALI_Id.
747 procedure Check_Linker_Options
748 (E_Stamp : Time_Stamp_Type;
749 O_File : out File_Name_Type;
750 O_Stamp : out Time_Stamp_Type);
751 -- Checks all linker options for linker files that are newer
752 -- than E_Stamp. If such objects are found, the youngest object
753 -- is returned in O_File and its stamp in O_Stamp.
755 -- If no obsolete linker files were found, the first missing
756 -- linker file is returned in O_File and O_Stamp is empty.
757 -- Otherwise O_File is No_File.
759 procedure Collect_Arguments
760 (Source_File : File_Name_Type;
761 Args : Argument_List);
762 -- Collect all arguments for a source to be compiled, including those
763 -- that come from a project file.
765 procedure Display (Program : String; Args : Argument_List);
766 -- Displays Program followed by the arguments in Args if variable
767 -- Display_Executed_Programs is set. The lower bound of Args must be 1.
773 type Temp_File_Names is
774 array (Project_Id range <>, Positive range <>) of Name_Id;
776 type Temp_Files_Ptr is access Temp_File_Names;
778 type Indices is array (Project_Id range <>) of Natural;
780 type Indices_Ptr is access Indices;
782 type Free_File_Indices is array
783 (Project_Id range <>, Positive range <>) of Positive;
785 type Free_Indices_Ptr is access Free_File_Indices;
787 The_Mapping_File_Names : Temp_Files_Ptr;
788 -- For each project, the name ids of the temporary mapping files used
790 Last_Mapping_File_Names : Indices_Ptr;
791 -- For each project, the index of the last mapping file created
793 The_Free_Mapping_File_Indices : Free_Indices_Ptr;
794 -- For each project, the indices in The_Mapping_File_Names of the mapping
795 -- file names that can be reused for subsequent compilations.
797 Last_Free_Indices : Indices_Ptr;
798 -- For each project, the number of mapping files that can be reused
800 Gnatmake_Mapping_File : String_Access := null;
801 -- The path name of a mapping file specified by switch -C=
803 procedure Delete_Mapping_Files;
804 -- Delete all temporary mapping files
806 procedure Init_Mapping_File
807 (Project : Project_Id;
808 File_Index : in out Natural);
809 -- Create a new temporary mapping file, and fill it with the project file
810 -- mappings, when using project file(s). The out parameter File_Index is
811 -- the index to the name of the file in the array The_Mapping_File_Names.
813 procedure Delete_Temp_Config_Files;
814 -- Delete all temporary config files
816 procedure Delete_All_Temp_Files;
817 -- Delete all temp files (config files, mapping files, path files)
823 procedure Add_Arguments (Args : Argument_List) is
825 if Arguments = null then
826 Arguments := new Argument_List (1 .. Args'Length + 10);
829 while Last_Argument + Args'Length > Arguments'Last loop
831 New_Arguments : Argument_List_Access :=
832 new Argument_List (1 .. Arguments'Last * 2);
835 New_Arguments (1 .. Last_Argument) :=
836 Arguments (1 .. Last_Argument);
837 Arguments := New_Arguments;
842 Arguments (Last_Argument + 1 .. Last_Argument + Args'Length) := Args;
843 Last_Argument := Last_Argument + Args'Length;
850 procedure Add_Dependency (S : Name_Id; On : Name_Id) is
852 Dependencies.Increment_Last;
853 Dependencies.Table (Dependencies.Last) := (S, On);
860 procedure Add_Object_Dir (N : String) is
862 Add_Lib_Search_Dir (N);
865 Write_Str ("Adding object directory """);
876 procedure Add_Source_Dir (N : String) is
878 Add_Src_Search_Dir (N);
881 Write_Str ("Adding source directory """);
894 Program : Make_Program_Type;
895 Append_Switch : Boolean := True;
896 And_Save : Boolean := True)
899 with package T is new Table.Table (<>);
900 procedure Generic_Position (New_Position : out Integer);
901 -- Generic procedure that chooses a position for S in T at the
902 -- beginning or the end, depending on the boolean Append_Switch.
903 -- Calling this procedure may expand the table.
905 ----------------------
906 -- Generic_Position --
907 ----------------------
909 procedure Generic_Position (New_Position : out Integer) is
913 if Append_Switch then
914 New_Position := Integer (T.Last);
916 for J in reverse T.Table_Index_Type'Succ (T.First) .. T.Last loop
917 T.Table (J) := T.Table (T.Table_Index_Type'Pred (J));
920 New_Position := Integer (T.First);
922 end Generic_Position;
924 procedure Gcc_Switches_Pos is new Generic_Position (Gcc_Switches);
925 procedure Binder_Switches_Pos is new Generic_Position (Binder_Switches);
926 procedure Linker_Switches_Pos is new Generic_Position (Linker_Switches);
928 procedure Saved_Gcc_Switches_Pos is new
929 Generic_Position (Saved_Gcc_Switches);
931 procedure Saved_Binder_Switches_Pos is new
932 Generic_Position (Saved_Binder_Switches);
934 procedure Saved_Linker_Switches_Pos is new
935 Generic_Position (Saved_Linker_Switches);
937 New_Position : Integer;
939 -- Start of processing for Add_Switch
945 Saved_Gcc_Switches_Pos (New_Position);
946 Saved_Gcc_Switches.Table (New_Position) := S;
949 Saved_Binder_Switches_Pos (New_Position);
950 Saved_Binder_Switches.Table (New_Position) := S;
953 Saved_Linker_Switches_Pos (New_Position);
954 Saved_Linker_Switches.Table (New_Position) := S;
963 Gcc_Switches_Pos (New_Position);
964 Gcc_Switches.Table (New_Position) := S;
967 Binder_Switches_Pos (New_Position);
968 Binder_Switches.Table (New_Position) := S;
971 Linker_Switches_Pos (New_Position);
972 Linker_Switches.Table (New_Position) := S;
982 Program : Make_Program_Type;
983 Append_Switch : Boolean := True;
984 And_Save : Boolean := True)
987 Add_Switch (S => new String'(S),
989 Append_Switch => Append_Switch,
990 And_Save => And_Save);
997 procedure Add_Switches
998 (The_Package : Package_Id;
1000 Program : Make_Program_Type)
1002 Switches : Variable_Value;
1003 Switch_List : String_List_Id;
1004 Element : String_Element;
1007 if File_Name'Length > 0 then
1008 Name_Len := File_Name'Length;
1009 Name_Buffer (1 .. Name_Len) := File_Name;
1012 (Source_File => Name_Find,
1013 Source_File_Name => File_Name,
1014 Naming => Projects.Table (Main_Project).Naming,
1015 In_Package => The_Package,
1017 Program = Binder or else Program = Linker);
1019 case Switches.Kind is
1024 Program_Args := Program;
1026 Switch_List := Switches.Values;
1028 while Switch_List /= Nil_String loop
1029 Element := String_Elements.Table (Switch_List);
1030 Get_Name_String (Element.Value);
1032 if Name_Len > 0 then
1034 Argv : constant String := Name_Buffer (1 .. Name_Len);
1035 -- We need a copy, because Name_Buffer may be
1039 if Verbose_Mode then
1040 Write_Str (" Adding ");
1044 Scan_Make_Arg (Argv, And_Save => False);
1048 Switch_List := Element.Next;
1052 Program_Args := Program;
1053 Get_Name_String (Switches.Value);
1055 if Name_Len > 0 then
1057 Argv : constant String := Name_Buffer (1 .. Name_Len);
1058 -- We need a copy, because Name_Buffer may be modified
1061 if Verbose_Mode then
1062 Write_Str (" Adding ");
1066 Scan_Make_Arg (Argv, And_Save => False);
1077 procedure Bind (ALI_File : File_Name_Type; Args : Argument_List) is
1078 Bind_Args : Argument_List (1 .. Args'Last + 2);
1079 Bind_Last : Integer;
1083 pragma Assert (Args'First = 1);
1085 -- Optimize the simple case where the gnatbind command line looks like
1086 -- gnatbind -aO. -I- file.ali --into-> gnatbind file.adb
1089 and then Args (Args'First).all = "-aO" & Normalized_CWD
1090 and then Args (Args'Last).all = "-I-"
1091 and then ALI_File = Strip_Directory (ALI_File)
1093 Bind_Last := Args'First - 1;
1096 Bind_Last := Args'Last;
1097 Bind_Args (Args'Range) := Args;
1100 -- It is completely pointless to re-check source file time stamps.
1101 -- This has been done already by gnatmake
1103 Bind_Last := Bind_Last + 1;
1104 Bind_Args (Bind_Last) := Do_Not_Check_Flag;
1106 Get_Name_String (ALI_File);
1108 Bind_Last := Bind_Last + 1;
1109 Bind_Args (Bind_Last) := new String'(Name_Buffer (1 .. Name_Len));
1111 GNAT.OS_Lib.Normalize_Arguments (Bind_Args (Args'First .. Bind_Last));
1113 Display (Gnatbind.all, Bind_Args (Args'First .. Bind_Last));
1115 if Gnatbind_Path = null then
1116 Make_Failed ("error, unable to locate ", Gnatbind.all);
1120 (Gnatbind_Path.all, Bind_Args (Args'First .. Bind_Last), Success);
1127 --------------------------------
1128 -- Change_To_Object_Directory --
1129 --------------------------------
1131 procedure Change_To_Object_Directory (Project : Project_Id) is
1133 -- Nothing to do if the current working directory is alresdy the one
1136 if Project_Object_Directory /= Project then
1137 Project_Object_Directory := Project;
1139 -- If in a real project, set the working directory to the object
1140 -- directory of the project.
1142 if Project /= No_Project then
1144 (Get_Name_String (Projects.Table (Project).Object_Directory));
1146 -- Otherwise, for sources outside of any project, set the working
1147 -- directory to the object directory of the main project.
1149 elsif Main_Project /= No_Project then
1152 (Projects.Table (Main_Project).Object_Directory));
1155 end Change_To_Object_Directory;
1162 (Source_File : File_Name_Type;
1163 The_Args : Argument_List;
1164 Lib_File : File_Name_Type;
1165 Read_Only : Boolean;
1167 O_File : out File_Name_Type;
1168 O_Stamp : out Time_Stamp_Type)
1170 function First_New_Spec (A : ALI_Id) return File_Name_Type;
1171 -- Looks in the with table entries of A and returns the spec file name
1172 -- of the first withed unit (subprogram) for which no spec existed when
1173 -- A was generated but for which there exists one now, implying that A
1174 -- is now obsolete. If no such unit is found No_File is returned.
1175 -- Otherwise the spec file name of the unit is returned.
1177 -- **WARNING** in the event of Uname format modifications, one *MUST*
1178 -- make sure this function is also updated.
1180 -- Note: This function should really be in ali.adb and use Uname
1181 -- services, but this causes the whole compiler to be dragged along
1182 -- for gnatbind and gnatmake.
1184 --------------------
1185 -- First_New_Spec --
1186 --------------------
1188 function First_New_Spec (A : ALI_Id) return File_Name_Type is
1189 Spec_File_Name : File_Name_Type := No_File;
1191 function New_Spec (Uname : Unit_Name_Type) return Boolean;
1192 -- Uname is the name of the spec or body of some ada unit.
1193 -- This function returns True if the Uname is the name of a body
1194 -- which has a spec not mentioned inali file A. If True is returned
1195 -- Spec_File_Name above is set to the name of this spec file.
1201 function New_Spec (Uname : Unit_Name_Type) return Boolean is
1202 Spec_Name : Unit_Name_Type;
1203 File_Name : File_Name_Type;
1206 -- Test whether Uname is the name of a body unit (ie ends with %b)
1208 Get_Name_String (Uname);
1210 Assert (Name_Len > 2 and then Name_Buffer (Name_Len - 1) = '%');
1212 if Name_Buffer (Name_Len) /= 'b' then
1216 -- Convert unit name into spec name
1218 -- ??? this code seems dubious in presence of pragma
1219 -- Source_File_Name since there is no more direct relationship
1220 -- between unit name and file name.
1222 -- ??? Further, what about alternative subunit naming
1224 Name_Buffer (Name_Len) := 's';
1225 Spec_Name := Name_Find;
1226 File_Name := Get_File_Name (Spec_Name, Subunit => False);
1228 -- Look if File_Name is mentioned in A's sdep list.
1229 -- If not look if the file exists. If it does return True.
1232 ALIs.Table (A).First_Sdep .. ALIs.Table (A).Last_Sdep
1234 if Sdep.Table (D).Sfile = File_Name then
1239 if Full_Source_Name (File_Name) /= No_File then
1240 Spec_File_Name := File_Name;
1247 -- Start of processing for First_New_Spec
1251 ALIs.Table (A).First_Unit .. ALIs.Table (A).Last_Unit
1253 exit U_Chk when Units.Table (U).Utype = Is_Body_Only
1254 and then New_Spec (Units.Table (U).Uname);
1256 for W in Units.Table (U).First_With
1258 Units.Table (U).Last_With
1261 Withs.Table (W).Afile /= No_File
1262 and then New_Spec (Withs.Table (W).Uname);
1266 return Spec_File_Name;
1269 ---------------------------------
1270 -- Data declarations for Check --
1271 ---------------------------------
1273 Full_Lib_File : File_Name_Type;
1274 -- Full name of current library file
1276 Full_Obj_File : File_Name_Type;
1277 -- Full name of the object file corresponding to Lib_File.
1279 Lib_Stamp : Time_Stamp_Type;
1280 -- Time stamp of the current ada library file.
1282 Obj_Stamp : Time_Stamp_Type;
1283 -- Time stamp of the current object file.
1285 Modified_Source : File_Name_Type;
1286 -- The first source in Lib_File whose current time stamp differs
1287 -- from that stored in Lib_File.
1289 New_Spec : File_Name_Type;
1290 -- If Lib_File contains in its W (with) section a body (for a
1291 -- subprogram) for which there exists a spec and the spec did not
1292 -- appear in the Sdep section of Lib_File, New_Spec contains the file
1293 -- name of this new spec.
1295 Source_Name : Name_Id;
1296 Text : Text_Buffer_Ptr;
1298 Prev_Switch : String_Access;
1299 -- Previous switch processed
1301 Arg : Arg_Id := Arg_Id'First;
1302 -- Current index in Args.Table for a given unit (init to stop warning)
1304 Switch_Found : Boolean;
1305 -- True if a given switch has been found
1307 -- Start of processing for Check
1310 pragma Assert (Lib_File /= No_File);
1312 -- If the ALI file is read-only, set temporarily
1313 -- Check_Object_Consistency to False: we don't care if the object file
1314 -- is not there; presumably, a library will be used for linking.
1318 Saved_Check_Object_Consistency : constant Boolean :=
1319 Check_Object_Consistency;
1321 Check_Object_Consistency := False;
1322 Text := Read_Library_Info (Lib_File);
1323 Check_Object_Consistency := Saved_Check_Object_Consistency;
1327 Text := Read_Library_Info (Lib_File);
1330 Full_Lib_File := Full_Library_Info_Name;
1331 Full_Obj_File := Full_Object_File_Name;
1332 Lib_Stamp := Current_Library_File_Stamp;
1333 Obj_Stamp := Current_Object_File_Stamp;
1335 if Full_Lib_File = No_File then
1336 Verbose_Msg (Lib_File, "being checked ...", Prefix => " ");
1338 Verbose_Msg (Full_Lib_File, "being checked ...", Prefix => " ");
1342 O_File := Full_Obj_File;
1343 O_Stamp := Obj_Stamp;
1346 if Full_Lib_File = No_File then
1347 Verbose_Msg (Lib_File, "missing.");
1349 elsif Obj_Stamp (Obj_Stamp'First) = ' ' then
1350 Verbose_Msg (Full_Obj_File, "missing.");
1354 (Full_Lib_File, "(" & String (Lib_Stamp) & ") newer than",
1355 Full_Obj_File, "(" & String (Obj_Stamp) & ")");
1359 ALI := Scan_ALI (Lib_File, Text, Ignore_ED => False, Err => True);
1362 if ALI = No_ALI_Id then
1363 Verbose_Msg (Full_Lib_File, "incorrectly formatted ALI file");
1366 elsif ALIs.Table (ALI).Ver (1 .. ALIs.Table (ALI).Ver_Len) /=
1367 Verbose_Library_Version
1369 Verbose_Msg (Full_Lib_File, "compiled with old GNAT version");
1374 -- Don't take Ali file into account if it was generated with
1377 if ALIs.Table (ALI).Compile_Errors then
1378 Verbose_Msg (Full_Lib_File, "had errors, must be recompiled");
1383 -- Don't take Ali file into account if it was generated without
1386 if Operating_Mode /= Check_Semantics
1387 and then ALIs.Table (ALI).No_Object
1389 Verbose_Msg (Full_Lib_File, "has no corresponding object");
1394 -- Check for matching compiler switches if needed
1396 if Check_Switches then
1398 -- First, collect all the switches
1400 Collect_Arguments (Source_File, The_Args);
1402 Prev_Switch := Dummy_Switch;
1404 Get_Name_String (ALIs.Table (ALI).Sfile);
1406 Switches_To_Check.Set_Last (0);
1408 for J in 1 .. Last_Argument loop
1410 -- Skip non switches -c, -I and -o switches
1412 if Arguments (J) (1) = '-'
1413 and then Arguments (J) (2) /= 'c'
1414 and then Arguments (J) (2) /= 'o'
1415 and then Arguments (J) (2) /= 'I'
1417 Normalize_Compiler_Switches
1419 Normalized_Switches,
1422 for K in 1 .. Last_Norm_Switch loop
1423 Switches_To_Check.Increment_Last;
1424 Switches_To_Check.Table (Switches_To_Check.Last) :=
1425 Normalized_Switches (K);
1430 for J in 1 .. Switches_To_Check.Last loop
1432 -- Comparing switches is delicate because gcc reorders
1433 -- a number of switches, according to lang-specs.h, but
1434 -- gnatmake doesn't have the sufficient knowledge to
1435 -- perform the same reordering. Instead, we ignore orders
1436 -- between different "first letter" switches, but keep
1437 -- orders between same switches, e.g -O -O2 is different
1438 -- than -O2 -O, but -g -O is equivalent to -O -g.
1440 if Switches_To_Check.Table (J) (2) /= Prev_Switch (2) or else
1441 (Prev_Switch'Length >= 6 and then
1442 Prev_Switch (2 .. 5) = "gnat" and then
1443 Switches_To_Check.Table (J)'Length >= 6 and then
1444 Switches_To_Check.Table (J) (2 .. 5) = "gnat" and then
1445 Prev_Switch (6) /= Switches_To_Check.Table (J) (6))
1447 Prev_Switch := Switches_To_Check.Table (J);
1449 Units.Table (ALIs.Table (ALI).First_Unit).First_Arg;
1452 Switch_Found := False;
1455 Units.Table (ALIs.Table (ALI).First_Unit).Last_Arg
1458 Switches_To_Check.Table (J).all = Args.Table (K).all
1461 Switch_Found := True;
1466 if not Switch_Found then
1467 if Verbose_Mode then
1468 Verbose_Msg (ALIs.Table (ALI).Sfile,
1469 "switch mismatch """ &
1470 Switches_To_Check.Table (J).all & '"');
1478 if Switches_To_Check.Last /=
1479 Integer (Units.Table (ALIs.Table (ALI).First_Unit).Last_Arg -
1480 Units.Table (ALIs.Table (ALI).First_Unit).First_Arg + 1)
1482 if Verbose_Mode then
1483 Verbose_Msg (ALIs.Table (ALI).Sfile,
1484 "different number of switches");
1486 for K in Units.Table (ALIs.Table (ALI).First_Unit).First_Arg
1487 .. Units.Table (ALIs.Table (ALI).First_Unit).Last_Arg
1489 Write_Str (Args.Table (K).all);
1495 for J in 1 .. Switches_To_Check.Last loop
1496 Write_Str (Switches_To_Check.Table (J).all);
1508 -- Get the source files and their message digests. Note that some
1509 -- sources may be missing if ALI is out-of-date.
1511 Set_Source_Table (ALI);
1513 Modified_Source := Time_Stamp_Mismatch (ALI, Read_Only);
1515 if Modified_Source /= No_File then
1518 if Verbose_Mode then
1519 Source_Name := Full_Source_Name (Modified_Source);
1521 if Source_Name /= No_File then
1522 Verbose_Msg (Source_Name, "time stamp mismatch");
1524 Verbose_Msg (Modified_Source, "missing");
1529 New_Spec := First_New_Spec (ALI);
1531 if New_Spec /= No_File then
1534 if Verbose_Mode then
1535 Source_Name := Full_Source_Name (New_Spec);
1537 if Source_Name /= No_File then
1538 Verbose_Msg (Source_Name, "new spec");
1540 Verbose_Msg (New_Spec, "old spec missing");
1548 ------------------------
1549 -- Check_For_S_Switch --
1550 ------------------------
1552 procedure Check_For_S_Switch is
1554 -- By default, we generate an object file
1556 Output_Is_Object := True;
1558 for Arg in 1 .. Last_Argument loop
1559 if Arguments (Arg).all = "-S" then
1560 Output_Is_Object := False;
1562 elsif Arguments (Arg).all = "-c" then
1563 Output_Is_Object := True;
1566 end Check_For_S_Switch;
1568 --------------------------
1569 -- Check_Linker_Options --
1570 --------------------------
1572 procedure Check_Linker_Options
1573 (E_Stamp : Time_Stamp_Type;
1574 O_File : out File_Name_Type;
1575 O_Stamp : out Time_Stamp_Type)
1577 procedure Check_File (File : File_Name_Type);
1578 -- Update O_File and O_Stamp if the given file is younger than E_Stamp
1579 -- and O_Stamp, or if O_File is No_File and File does not exist.
1581 function Get_Library_File (Name : String) return File_Name_Type;
1582 -- Return the full file name including path of a library based
1583 -- on the name specified with the -l linker option, using the
1584 -- Ada object path. Return No_File if no such file can be found.
1586 type Char_Array is array (Natural) of Character;
1587 type Char_Array_Access is access constant Char_Array;
1589 Template : Char_Array_Access;
1590 pragma Import (C, Template, "__gnat_library_template");
1596 procedure Check_File (File : File_Name_Type) is
1597 Stamp : Time_Stamp_Type;
1598 Name : File_Name_Type := File;
1601 Get_Name_String (Name);
1603 -- Remove any trailing NUL characters
1605 while Name_Len >= Name_Buffer'First
1606 and then Name_Buffer (Name_Len) = NUL
1608 Name_Len := Name_Len - 1;
1611 if Name_Len <= 0 then
1614 elsif Name_Buffer (1) = '-' then
1616 -- Do not check if File is a switch other than "-l"
1618 if Name_Buffer (2) /= 'l' then
1622 -- The argument is a library switch, get actual name. It
1623 -- is necessary to make a copy of the relevant part of
1624 -- Name_Buffer as Get_Library_Name uses Name_Buffer as well.
1627 Base_Name : constant String := Name_Buffer (3 .. Name_Len);
1630 Name := Get_Library_File (Base_Name);
1633 if Name = No_File then
1638 Stamp := File_Stamp (Name);
1640 -- Find the youngest object file that is younger than the
1641 -- executable. If no such file exist, record the first object
1642 -- file that is not found.
1644 if (O_Stamp < Stamp and then E_Stamp < Stamp)
1645 or else (O_File = No_File and then Stamp (Stamp'First) = ' ')
1650 -- Strip the trailing NUL if present
1652 Get_Name_String (O_File);
1654 if Name_Buffer (Name_Len) = NUL then
1655 Name_Len := Name_Len - 1;
1656 O_File := Name_Find;
1661 ----------------------
1662 -- Get_Library_Name --
1663 ----------------------
1665 -- See comments in a-adaint.c about template syntax
1667 function Get_Library_File (Name : String) return File_Name_Type is
1668 File : File_Name_Type := No_File;
1673 for Ptr in Template'Range loop
1674 case Template (Ptr) is
1676 Add_Str_To_Name_Buffer (Name);
1679 File := Full_Lib_File_Name (Name_Find);
1680 exit when File /= No_File;
1687 Add_Char_To_Name_Buffer (Template (Ptr));
1691 -- The for loop exited because the end of the template
1692 -- was reached. File contains the last possible file name
1695 if File = No_File and then Name_Len > 0 then
1696 File := Full_Lib_File_Name (Name_Find);
1700 end Get_Library_File;
1702 -- Start of processing for Check_Linker_Options
1706 O_Stamp := (others => ' ');
1708 -- Process linker options from the ALI files.
1710 for Opt in 1 .. Linker_Options.Last loop
1711 Check_File (Linker_Options.Table (Opt).Name);
1714 -- Process options given on the command line.
1716 for Opt in Linker_Switches.First .. Linker_Switches.Last loop
1718 -- Check if the previous Opt has one of the two switches
1719 -- that take an extra parameter. (See GCC manual.)
1721 if Opt = Linker_Switches.First
1722 or else (Linker_Switches.Table (Opt - 1).all /= "-u"
1724 Linker_Switches.Table (Opt - 1).all /= "-Xlinker"
1726 Linker_Switches.Table (Opt - 1).all /= "-L")
1729 Add_Str_To_Name_Buffer (Linker_Switches.Table (Opt).all);
1730 Check_File (Name_Find);
1734 end Check_Linker_Options;
1740 procedure Check_Steps is
1742 -- If either -c, -b or -l has been specified, we will not necessarily
1743 -- execute all steps.
1746 Do_Compile_Step := Do_Compile_Step and Compile_Only;
1747 Do_Bind_Step := Do_Bind_Step and Bind_Only;
1748 Do_Link_Step := Do_Link_Step and Link_Only;
1750 -- If -c has been specified, but not -b, ignore any potential -l
1752 if Do_Compile_Step and then not Do_Bind_Step then
1753 Do_Link_Step := False;
1758 -----------------------
1759 -- Collect_Arguments --
1760 -----------------------
1762 procedure Collect_Arguments
1763 (Source_File : File_Name_Type;
1764 Args : Argument_List)
1767 Arguments_Collected := True;
1768 Arguments_Project := No_Project;
1770 Add_Arguments (Args);
1772 if Main_Project /= No_Project then
1774 Source_File_Name : constant String :=
1775 Get_Name_String (Source_File);
1776 Compiler_Package : Prj.Package_Id;
1777 Switches : Prj.Variable_Value;
1778 Data : Project_Data;
1783 (Source_File_Name => Source_File_Name,
1784 Project => Arguments_Project,
1785 Path => Arguments_Path_Name);
1787 -- If the source is not a source of a project file,
1788 -- we simply add the saved gcc switches.
1790 if Arguments_Project = No_Project then
1792 Add_Arguments (The_Saved_Gcc_Switches.all);
1795 -- We get the project directory for the relative path
1796 -- switches and arguments.
1798 Data := Projects.Table (Arguments_Project);
1800 -- If the source is in an extended project, we go to
1801 -- the ultimate extending project.
1803 while Data.Extended_By /= No_Project loop
1804 Arguments_Project := Data.Extended_By;
1805 Data := Projects.Table (Arguments_Project);
1808 -- If building a dynamic or relocatable library, compile with
1809 -- PIC option, if it exists.
1811 if Data.Library and then Data.Library_Kind /= Static then
1813 PIC : constant String := MLib.Tgt.PIC_Option;
1817 Add_Arguments ((1 => new String'(PIC)));
1822 if Data.Dir_Path = null then
1824 new String'(Get_Name_String (Data.Display_Directory));
1825 Projects.Table (Arguments_Project) := Data;
1828 -- We now look for package Compiler
1829 -- and get the switches from this package.
1833 (Name => Name_Compiler,
1834 In_Packages => Data.Decl.Packages);
1836 if Compiler_Package /= No_Package then
1838 -- If package Gnatmake.Compiler exists, we get
1839 -- the specific switches for the current source,
1840 -- or the global switches, if any.
1842 Switches := Switches_Of
1843 (Source_File => Source_File,
1844 Source_File_Name => Source_File_Name,
1845 Naming => Data.Naming,
1846 In_Package => Compiler_Package,
1847 Allow_ALI => False);
1851 case Switches.Kind is
1853 -- We have a list of switches. We add these switches,
1854 -- plus the saved gcc switches.
1859 Current : String_List_Id := Switches.Values;
1860 Element : String_Element;
1861 Number : Natural := 0;
1864 while Current /= Nil_String loop
1865 Element := String_Elements.Table (Current);
1866 Number := Number + 1;
1867 Current := Element.Next;
1871 New_Args : Argument_List (1 .. Number);
1874 Current := Switches.Values;
1876 for Index in New_Args'Range loop
1877 Element := String_Elements.Table (Current);
1878 Get_Name_String (Element.Value);
1880 new String'(Name_Buffer (1 .. Name_Len));
1881 Test_If_Relative_Path
1882 (New_Args (Index), Parent => Data.Dir_Path);
1883 Current := Element.Next;
1887 (Configuration_Pragmas_Switch
1888 (Arguments_Project) &
1889 New_Args & The_Saved_Gcc_Switches.all);
1893 -- We have a single switch. We add this switch,
1894 -- plus the saved gcc switches.
1897 Get_Name_String (Switches.Value);
1900 New_Args : Argument_List :=
1902 (Name_Buffer (1 .. Name_Len)));
1905 Test_If_Relative_Path
1906 (New_Args (1), Parent => Data.Dir_Path);
1908 (Configuration_Pragmas_Switch (Arguments_Project) &
1909 New_Args & The_Saved_Gcc_Switches.all);
1912 -- We have no switches from Gnatmake.Compiler.
1913 -- We add the saved gcc switches.
1917 (Configuration_Pragmas_Switch (Arguments_Project) &
1918 The_Saved_Gcc_Switches.all);
1924 -- Set Output_Is_Object, depending if there is a -S switch.
1925 -- If the bind step is not performed, and there is a -S switch,
1926 -- then we will not check for a valid object file.
1929 end Collect_Arguments;
1931 ---------------------
1932 -- Compile_Sources --
1933 ---------------------
1935 procedure Compile_Sources
1936 (Main_Source : File_Name_Type;
1937 Args : Argument_List;
1938 First_Compiled_File : out Name_Id;
1939 Most_Recent_Obj_File : out Name_Id;
1940 Most_Recent_Obj_Stamp : out Time_Stamp_Type;
1941 Main_Unit : out Boolean;
1942 Compilation_Failures : out Natural;
1943 Check_Readonly_Files : Boolean := False;
1944 Do_Not_Execute : Boolean := False;
1945 Force_Compilations : Boolean := False;
1946 Keep_Going : Boolean := False;
1947 In_Place_Mode : Boolean := False;
1948 Initialize_ALI_Data : Boolean := True;
1949 Max_Process : Positive := 1)
1954 Args : Argument_List) return Process_Id;
1955 -- Compiles S using Args. If S is a GNAT predefined source
1956 -- "-gnatpg" is added to Args. Non blocking call. L corresponds to the
1957 -- expected library file name. Process_Id of the process spawned to
1958 -- execute the compile.
1960 No_Mapping_File : constant Natural := 0;
1962 type Compilation_Data is record
1964 Full_Source_File : File_Name_Type;
1965 Lib_File : File_Name_Type;
1966 Source_Unit : Unit_Name_Type;
1967 Mapping_File : Natural := No_Mapping_File;
1968 Project : Project_Id := No_Project;
1969 Syntax_Only : Boolean := False;
1970 Output_Is_Object : Boolean := True;
1973 Running_Compile : array (1 .. Max_Process) of Compilation_Data;
1974 -- Used to save information about outstanding compilations.
1976 Outstanding_Compiles : Natural := 0;
1977 -- Current number of outstanding compiles
1979 Source_Unit : Unit_Name_Type;
1980 -- Current source unit
1982 Source_File : File_Name_Type;
1983 -- Current source file
1985 Full_Source_File : File_Name_Type;
1986 -- Full name of the current source file
1988 Lib_File : File_Name_Type;
1989 -- Current library file
1991 Full_Lib_File : File_Name_Type;
1992 -- Full name of the current library file
1994 Obj_File : File_Name_Type;
1995 -- Full name of the object file corresponding to Lib_File.
1997 Obj_Stamp : Time_Stamp_Type;
1998 -- Time stamp of the current object file.
2000 Sfile : File_Name_Type;
2001 -- Contains the source file of the units withed by Source_File
2004 -- ALI Id of the current ALI file
2006 Read_Only : Boolean := False;
2008 Compilation_OK : Boolean;
2009 Need_To_Compile : Boolean;
2012 Text : Text_Buffer_Ptr;
2014 Mfile : Natural := No_Mapping_File;
2016 Need_To_Check_Standard_Library : Boolean :=
2017 Check_Readonly_Files and not Unique_Compile;
2019 Mapping_File_Arg : String_Access;
2021 procedure Add_Process
2023 Sfile : File_Name_Type;
2024 Afile : File_Name_Type;
2025 Uname : Unit_Name_Type;
2026 Mfile : Natural := No_Mapping_File);
2027 -- Adds process Pid to the current list of outstanding compilation
2028 -- processes and record the full name of the source file Sfile that
2029 -- we are compiling, the name of its library file Afile and the
2030 -- name of its unit Uname. If Mfile is not equal to No_Mapping_File,
2031 -- it is the index of the mapping file used during compilation in the
2032 -- array The_Mapping_File_Names.
2034 procedure Await_Compile
2035 (Sfile : out File_Name_Type;
2036 Afile : out File_Name_Type;
2037 Uname : out Unit_Name_Type;
2039 -- Awaits that an outstanding compilation process terminates. When
2040 -- it does set Sfile to the name of the source file that was compiled
2041 -- Afile to the name of its library file and Uname to the name of its
2042 -- unit. Note that this time stamp can be used to check whether the
2043 -- compilation did generate an object file. OK is set to True if the
2044 -- compilation succeeded. Note that Sfile, Afile and Uname could be
2045 -- resp. No_File, No_File and No_Name if there were no compilations
2048 procedure Collect_Arguments_And_Compile (Source_File : File_Name_Type);
2049 -- Collect arguments from project file (if any) and compile
2051 package Good_ALI is new Table.Table (
2052 Table_Component_Type => ALI_Id,
2053 Table_Index_Type => Natural,
2054 Table_Low_Bound => 1,
2055 Table_Initial => 50,
2056 Table_Increment => 100,
2057 Table_Name => "Make.Good_ALI");
2058 -- Contains the set of valid ALI files that have not yet been scanned.
2060 procedure Record_Good_ALI (A : ALI_Id);
2061 -- Records in the previous set the Id of an ALI file.
2063 function Good_ALI_Present return Boolean;
2064 -- Returns True if any ALI file was recorded in the previous set.
2066 function Get_Next_Good_ALI return ALI_Id;
2067 -- Returns the next good ALI_Id record;
2069 procedure Record_Failure
2070 (File : File_Name_Type;
2071 Unit : Unit_Name_Type;
2072 Found : Boolean := True);
2073 -- Records in the previous table that the compilation for File failed.
2074 -- If Found is False then the compilation of File failed because we
2075 -- could not find it. Records also Unit when possible.
2077 function Bad_Compilation_Count return Natural;
2078 -- Returns the number of compilation failures.
2080 procedure Get_Mapping_File (Project : Project_Id);
2081 -- Get a mapping file name. If there is one to be reused, reuse it.
2082 -- Otherwise, create a new mapping file.
2088 procedure Add_Process
2090 Sfile : File_Name_Type;
2091 Afile : File_Name_Type;
2092 Uname : Unit_Name_Type;
2093 Mfile : Natural := No_Mapping_File)
2095 OC1 : constant Positive := Outstanding_Compiles + 1;
2098 pragma Assert (OC1 <= Max_Process);
2099 pragma Assert (Pid /= Invalid_Pid);
2101 Running_Compile (OC1).Pid := Pid;
2102 Running_Compile (OC1).Full_Source_File := Sfile;
2103 Running_Compile (OC1).Lib_File := Afile;
2104 Running_Compile (OC1).Source_Unit := Uname;
2105 Running_Compile (OC1).Mapping_File := Mfile;
2106 Running_Compile (OC1).Project := Arguments_Project;
2107 Running_Compile (OC1).Syntax_Only := Syntax_Only;
2108 Running_Compile (OC1).Output_Is_Object := Output_Is_Object;
2110 Outstanding_Compiles := OC1;
2113 --------------------
2117 procedure Await_Compile
2118 (Sfile : out File_Name_Type;
2119 Afile : out File_Name_Type;
2120 Uname : out File_Name_Type;
2124 Project : Project_Id;
2127 pragma Assert (Outstanding_Compiles > 0);
2134 -- The loop here is a work-around for a problem on VMS; in some
2135 -- circumstances (shared library and several executables, for
2136 -- example), there are child processes other than compilation
2137 -- processes that are received. Until this problem is resolved,
2138 -- we will ignore such processes.
2141 Wait_Process (Pid, OK);
2143 if Pid = Invalid_Pid then
2147 for J in Running_Compile'First .. Outstanding_Compiles loop
2148 if Pid = Running_Compile (J).Pid then
2149 Sfile := Running_Compile (J).Full_Source_File;
2150 Afile := Running_Compile (J).Lib_File;
2151 Uname := Running_Compile (J).Source_Unit;
2152 Syntax_Only := Running_Compile (J).Syntax_Only;
2153 Output_Is_Object := Running_Compile (J).Output_Is_Object;
2154 Project := Running_Compile (J).Project;
2156 -- If a mapping file was used by this compilation,
2157 -- get its file name for reuse by a subsequent compilation
2159 if Running_Compile (J).Mapping_File /= No_Mapping_File then
2160 Last_Free_Indices (Project) :=
2161 Last_Free_Indices (Project) + 1;
2162 The_Free_Mapping_File_Indices
2163 (Project, Last_Free_Indices (Project)) :=
2164 Running_Compile (J).Mapping_File;
2167 -- To actually remove this Pid and related info from
2168 -- Running_Compile replace its entry with the last valid
2169 -- entry in Running_Compile.
2171 if J = Outstanding_Compiles then
2175 Running_Compile (J) :=
2176 Running_Compile (Outstanding_Compiles);
2179 Outstanding_Compiles := Outstanding_Compiles - 1;
2184 -- This child process was not one of our compilation processes;
2185 -- just ignore it for now.
2187 -- raise Program_Error;
2191 ---------------------------
2192 -- Bad_Compilation_Count --
2193 ---------------------------
2195 function Bad_Compilation_Count return Natural is
2197 return Bad_Compilation.Last - Bad_Compilation.First + 1;
2198 end Bad_Compilation_Count;
2200 -----------------------------------
2201 -- Collect_Arguments_And_Compile --
2202 -----------------------------------
2204 procedure Collect_Arguments_And_Compile (Source_File : File_Name_Type) is
2207 -- If arguments have not yet been collected (in Check), collect them
2210 if not Arguments_Collected then
2211 Collect_Arguments (Source_File, Args);
2214 -- If we use mapping file (-P or -C switches), then get one
2216 if Create_Mapping_File then
2217 Get_Mapping_File (Arguments_Project);
2220 -- If the source is part of a project file, we set the ADA_*_PATHs,
2221 -- check for an eventual library project, and use the full path.
2223 if Arguments_Project /= No_Project then
2224 Prj.Env.Set_Ada_Paths (Arguments_Project, True);
2226 if MLib.Tgt.Support_For_Libraries /= MLib.Tgt.None then
2228 The_Data : Project_Data :=
2229 Projects.Table (Arguments_Project);
2230 Prj : Project_Id := Arguments_Project;
2233 while The_Data.Extended_By /= No_Project loop
2234 Prj := The_Data.Extended_By;
2235 The_Data := Projects.Table (Prj);
2238 if The_Data.Library and then not The_Data.Flag1 then
2239 -- Add to the Q all sources of the project that
2240 -- have not been marked
2242 Insert_Project_Sources
2243 (The_Project => Prj,
2244 All_Projects => False,
2247 -- Now mark the project as processed
2249 Projects.Table (Prj).Flag1 := True;
2254 -- Change to the object directory of the project file,
2257 Change_To_Object_Directory (Arguments_Project);
2259 Pid := Compile (Arguments_Path_Name, Lib_File,
2260 Arguments (1 .. Last_Argument));
2263 -- If this is a source outside of any project file, make sure
2264 -- it will be compiled in the object directory of the main project
2267 if Main_Project /= No_Project then
2268 Change_To_Object_Directory (Arguments_Project);
2271 Pid := Compile (Full_Source_File, Lib_File,
2272 Arguments (1 .. Last_Argument));
2274 end Collect_Arguments_And_Compile;
2283 Args : Argument_List) return Process_Id
2285 Comp_Args : Argument_List (Args'First .. Args'Last + 8);
2286 Comp_Next : Integer := Args'First;
2287 Comp_Last : Integer;
2289 function Ada_File_Name (Name : Name_Id) return Boolean;
2290 -- Returns True if Name is the name of an ada source file
2291 -- (i.e. suffix is .ads or .adb)
2297 function Ada_File_Name (Name : Name_Id) return Boolean is
2299 Get_Name_String (Name);
2302 and then Name_Buffer (Name_Len - 3 .. Name_Len - 1) = ".ad"
2303 and then (Name_Buffer (Name_Len) = 'b'
2305 Name_Buffer (Name_Len) = 's');
2308 -- Start of processing for Compile
2311 Enter_Into_Obsoleted (S);
2313 -- By default, Syntax_Only is False
2315 Syntax_Only := False;
2317 for J in Args'Range loop
2318 if Args (J).all = "-gnats" then
2320 -- If we compile with -gnats, the bind step and the link step
2321 -- are inhibited. Also, we set Syntax_Only to True, so that
2322 -- we don't fail when we don't find the ALI file, after
2325 Do_Bind_Step := False;
2326 Do_Link_Step := False;
2327 Syntax_Only := True;
2329 elsif Args (J).all = "-gnatc" then
2331 -- If we compile with -gnatc, the bind step and the link step
2332 -- are inhibited. We set Syntax_Only to False for the case when
2333 -- -gnats was previously specified.
2335 Do_Bind_Step := False;
2336 Do_Link_Step := False;
2337 Syntax_Only := False;
2341 Comp_Args (Comp_Next) := Comp_Flag;
2342 Comp_Next := Comp_Next + 1;
2344 -- Optimize the simple case where the gcc command line looks like
2345 -- gcc -c -I. ... -I- file.adb --into-> gcc -c ... file.adb
2347 if Args (Args'First).all = "-I" & Normalized_CWD
2348 and then Args (Args'Last).all = "-I-"
2349 and then S = Strip_Directory (S)
2351 Comp_Last := Comp_Next + Args'Length - 3;
2352 Comp_Args (Comp_Next .. Comp_Last) :=
2353 Args (Args'First + 1 .. Args'Last - 1);
2356 Comp_Last := Comp_Next + Args'Length - 1;
2357 Comp_Args (Comp_Next .. Comp_Last) := Args;
2360 -- Set -gnatpg for predefined files (for this purpose the renamings
2361 -- such as Text_IO do not count as predefined). Note that we strip
2362 -- the directory name from the source file name becase the call to
2363 -- Fname.Is_Predefined_File_Name cannot deal with directory prefixes.
2366 Fname : constant File_Name_Type := Strip_Directory (S);
2369 if Is_Predefined_File_Name (Fname, False) then
2370 if Check_Readonly_Files then
2371 Comp_Last := Comp_Last + 1;
2372 Comp_Args (Comp_Last) := GNAT_Flag;
2376 ("not allowed to compile """ &
2377 Get_Name_String (Fname) &
2378 """; use -a switch, or compile file with " &
2379 """-gnatg"" switch");
2384 -- Now check if the file name has one of the suffixes familiar to
2385 -- the gcc driver. If this is not the case then add the ada flag
2388 if not Ada_File_Name (S) and then not Targparm.AAMP_On_Target then
2389 Comp_Last := Comp_Last + 1;
2390 Comp_Args (Comp_Last) := Ada_Flag_1;
2391 Comp_Last := Comp_Last + 1;
2392 Comp_Args (Comp_Last) := Ada_Flag_2;
2395 if L /= Strip_Directory (L) or else Object_Directory_Path /= null then
2397 -- Build -o argument.
2399 Get_Name_String (L);
2401 for J in reverse 1 .. Name_Len loop
2402 if Name_Buffer (J) = '.' then
2403 Name_Len := J + Object_Suffix'Length - 1;
2404 Name_Buffer (J .. Name_Len) := Object_Suffix;
2409 Comp_Last := Comp_Last + 1;
2410 Comp_Args (Comp_Last) := Output_Flag;
2411 Comp_Last := Comp_Last + 1;
2413 -- If an object directory was specified, prepend the object file
2414 -- name with this object directory.
2416 if Object_Directory_Path /= null then
2417 Comp_Args (Comp_Last) :=
2418 new String'(Object_Directory_Path.all &
2419 Name_Buffer (1 .. Name_Len));
2422 Comp_Args (Comp_Last) :=
2423 new String'(Name_Buffer (1 .. Name_Len));
2427 if Create_Mapping_File then
2428 Comp_Last := Comp_Last + 1;
2429 Comp_Args (Comp_Last) := Mapping_File_Arg;
2432 Get_Name_String (S);
2434 Comp_Last := Comp_Last + 1;
2435 Comp_Args (Comp_Last) := new String'(Name_Buffer (1 .. Name_Len));
2437 GNAT.OS_Lib.Normalize_Arguments (Comp_Args (Args'First .. Comp_Last));
2439 Display (Gcc.all, Comp_Args (Args'First .. Comp_Last));
2441 if Gcc_Path = null then
2442 Make_Failed ("error, unable to locate ", Gcc.all);
2446 GNAT.OS_Lib.Non_Blocking_Spawn
2447 (Gcc_Path.all, Comp_Args (Args'First .. Comp_Last));
2450 ----------------------
2451 -- Get_Mapping_File --
2452 ----------------------
2454 procedure Get_Mapping_File (Project : Project_Id) is
2456 -- If there is a mapping file ready to be reused, reuse it
2458 if Last_Free_Indices (Project) > 0 then
2459 Mfile := The_Free_Mapping_File_Indices
2460 (Project, Last_Free_Indices (Project));
2461 Last_Free_Indices (Project) := Last_Free_Indices (Project) - 1;
2463 -- Otherwise, create and initialize a new one
2466 Init_Mapping_File (Project => Project, File_Index => Mfile);
2469 -- Put the name in the mapping file argument for the invocation
2472 Free (Mapping_File_Arg);
2474 new String'("-gnatem=" &
2476 (The_Mapping_File_Names (Project, Mfile)));
2478 end Get_Mapping_File;
2480 -----------------------
2481 -- Get_Next_Good_ALI --
2482 -----------------------
2484 function Get_Next_Good_ALI return ALI_Id is
2488 pragma Assert (Good_ALI_Present);
2489 ALI := Good_ALI.Table (Good_ALI.Last);
2490 Good_ALI.Decrement_Last;
2492 end Get_Next_Good_ALI;
2494 ----------------------
2495 -- Good_ALI_Present --
2496 ----------------------
2498 function Good_ALI_Present return Boolean is
2500 return Good_ALI.First <= Good_ALI.Last;
2501 end Good_ALI_Present;
2503 --------------------
2504 -- Record_Failure --
2505 --------------------
2507 procedure Record_Failure
2508 (File : File_Name_Type;
2509 Unit : Unit_Name_Type;
2510 Found : Boolean := True)
2513 Bad_Compilation.Increment_Last;
2514 Bad_Compilation.Table (Bad_Compilation.Last) := (File, Unit, Found);
2517 ---------------------
2518 -- Record_Good_ALI --
2519 ---------------------
2521 procedure Record_Good_ALI (A : ALI_Id) is
2523 Good_ALI.Increment_Last;
2524 Good_ALI.Table (Good_ALI.Last) := A;
2525 end Record_Good_ALI;
2527 -- Start of processing for Compile_Sources
2530 pragma Assert (Args'First = 1);
2532 -- Package and Queue initializations.
2535 Output.Set_Standard_Error;
2537 if First_Q_Initialization then
2541 if Initialize_ALI_Data then
2543 Initialize_ALI_Source;
2546 -- The following two flags affect the behavior of ALI.Set_Source_Table.
2547 -- We set Check_Source_Files to True to ensure that source file
2548 -- time stamps are checked, and we set All_Sources to False to
2549 -- avoid checking the presence of the source files listed in the
2550 -- source dependency section of an ali file (which would be a mistake
2551 -- since the ali file may be obsolete).
2553 Check_Source_Files := True;
2554 All_Sources := False;
2556 Insert_Q (Main_Source);
2559 First_Compiled_File := No_File;
2560 Most_Recent_Obj_File := No_File;
2561 Most_Recent_Obj_Stamp := Empty_Time_Stamp;
2564 -- Keep looping until there is no more work to do (the Q is empty)
2565 -- and all the outstanding compilations have terminated
2567 Make_Loop : while not Empty_Q or else Outstanding_Compiles > 0 loop
2569 -- If the user does not want to keep going in case of errors then
2570 -- wait for the remaining outstanding compiles and then exit.
2572 if Bad_Compilation_Count > 0 and then not Keep_Going then
2573 while Outstanding_Compiles > 0 loop
2575 (Full_Source_File, Lib_File, Source_Unit, Compilation_OK);
2577 if not Compilation_OK then
2578 Record_Failure (Full_Source_File, Source_Unit);
2585 -- PHASE 1: Check if there is more work that we can do (ie the Q
2586 -- is non empty). If there is, do it only if we have not yet used
2587 -- up all the available processes.
2589 if not Empty_Q and then Outstanding_Compiles < Max_Process then
2590 Extract_From_Q (Source_File, Source_Unit);
2591 Full_Source_File := Osint.Full_Source_Name (Source_File);
2592 Lib_File := Osint.Lib_File_Name (Source_File);
2593 Full_Lib_File := Osint.Full_Lib_File_Name (Lib_File);
2595 -- If this source has already been compiled, the executable is
2598 if Is_In_Obsoleted (Source_File) then
2599 Executable_Obsolete := True;
2602 -- If the library file is an Ada library skip it
2604 if Full_Lib_File /= No_File
2605 and then In_Ada_Lib_Dir (Full_Lib_File)
2607 Verbose_Msg (Lib_File, "is in an Ada library", Prefix => " ");
2609 -- If the library file is a read-only library skip it, but only
2610 -- if, when using project files, this library file is in the
2611 -- right object directory (a read-only ALI file in the object
2612 -- directory of a project being extended should not be skipped).
2614 elsif Full_Lib_File /= No_File
2615 and then not Check_Readonly_Files
2616 and then Is_Readonly_Library (Full_Lib_File)
2617 and then Is_In_Object_Directory (Source_File, Full_Lib_File)
2620 (Lib_File, "is a read-only library", Prefix => " ");
2622 -- The source file that we are checking cannot be located
2624 elsif Full_Source_File = No_File then
2625 Record_Failure (Source_File, Source_Unit, False);
2627 -- Source and library files can be located but are internal
2630 elsif not Check_Readonly_Files
2631 and then Full_Lib_File /= No_File
2632 and then Is_Internal_File_Name (Source_File)
2635 if Force_Compilations then
2637 ("not allowed to compile """ &
2638 Get_Name_String (Source_File) &
2639 """; use -a switch, or compile file with " &
2640 """-gnatg"" switch");
2644 (Lib_File, "is an internal library", Prefix => " ");
2646 -- The source file that we are checking can be located
2649 Arguments_Collected := False;
2651 -- Don't waste any time if we have to recompile anyway
2653 Obj_Stamp := Empty_Time_Stamp;
2654 Need_To_Compile := Force_Compilations;
2656 if not Force_Compilations then
2658 Full_Lib_File /= No_File
2659 and then not Check_Readonly_Files
2660 and then Is_Readonly_Library (Full_Lib_File);
2661 Check (Source_File, Args, Lib_File, Read_Only,
2662 ALI, Obj_File, Obj_Stamp);
2663 Need_To_Compile := (ALI = No_ALI_Id);
2666 if not Need_To_Compile then
2668 -- The ALI file is up-to-date. Record its Id.
2670 Record_Good_ALI (ALI);
2672 -- Record the time stamp of the most recent object file
2673 -- as long as no (re)compilations are needed.
2675 if First_Compiled_File = No_File
2676 and then (Most_Recent_Obj_File = No_File
2677 or else Obj_Stamp > Most_Recent_Obj_Stamp)
2679 Most_Recent_Obj_File := Obj_File;
2680 Most_Recent_Obj_Stamp := Obj_Stamp;
2684 -- Is this the first file we have to compile?
2686 if First_Compiled_File = No_File then
2687 First_Compiled_File := Full_Source_File;
2688 Most_Recent_Obj_File := No_File;
2690 if Do_Not_Execute then
2695 if In_Place_Mode then
2697 -- If the library file was not found, then save the
2698 -- library file near the source file.
2700 if Full_Lib_File = No_File then
2701 Get_Name_String (Full_Source_File);
2703 for J in reverse 1 .. Name_Len loop
2704 if Name_Buffer (J) = '.' then
2705 Name_Buffer (J + 1 .. J + 3) := "ali";
2711 Lib_File := Name_Find;
2713 -- If the library file was found, then save the
2714 -- library file in the same place.
2717 Lib_File := Full_Lib_File;
2722 -- Start the compilation and record it. We can do this
2723 -- because there is at least one free process.
2725 Collect_Arguments_And_Compile (Source_File);
2727 -- Make sure we could successfully start the compilation
2729 if Pid = Invalid_Pid then
2730 Record_Failure (Full_Source_File, Source_Unit);
2743 -- PHASE 2: Now check if we should wait for a compilation to
2744 -- finish. This is the case if all the available processes are
2745 -- busy compiling sources or there is nothing else to do
2746 -- (that is the Q is empty and there are no good ALIs to process).
2748 if Outstanding_Compiles = Max_Process
2750 and then not Good_ALI_Present
2751 and then Outstanding_Compiles > 0)
2754 (Full_Source_File, Lib_File, Source_Unit, Compilation_OK);
2756 if not Compilation_OK then
2757 Record_Failure (Full_Source_File, Source_Unit);
2760 if Compilation_OK or else Keep_Going then
2762 -- Re-read the updated library file
2765 Saved_Object_Consistency : constant Boolean :=
2766 Check_Object_Consistency;
2769 -- If compilation was not OK, or if output is not an
2770 -- object file and we don't do the bind step, don't check
2771 -- for object consistency.
2773 Check_Object_Consistency :=
2774 Check_Object_Consistency
2776 and (Output_Is_Object or Do_Bind_Step);
2777 Text := Read_Library_Info (Lib_File);
2779 -- Restore Check_Object_Consistency to its initial value
2781 Check_Object_Consistency := Saved_Object_Consistency;
2784 -- If an ALI file was generated by this compilation, scan
2785 -- the ALI file and record it.
2786 -- If the scan fails, a previous ali file is inconsistent with
2787 -- the unit just compiled.
2789 if Text /= null then
2791 Scan_ALI (Lib_File, Text, Ignore_ED => False, Err => True);
2793 if ALI = No_ALI_Id then
2795 -- Record a failure only if not already done
2797 if Compilation_OK then
2800 "incompatible ALI file, please recompile");
2801 Record_Failure (Full_Source_File, Source_Unit);
2805 Record_Good_ALI (ALI);
2808 -- If we could not read the ALI file that was just generated
2809 -- then there could be a problem reading either the ALI or the
2810 -- corresponding object file (if Check_Object_Consistency
2811 -- is set Read_Library_Info checks that the time stamp of the
2812 -- object file is more recent than that of the ALI). For an
2813 -- example of problems caught by this test see [6625-009].
2814 -- However, we record a failure only if not already done.
2817 if Compilation_OK and not Syntax_Only then
2820 "WARNING: ALI or object file not found after compile");
2821 Record_Failure (Full_Source_File, Source_Unit);
2827 -- PHASE 3: Check if we recorded good ALI files. If yes process
2828 -- them now in the order in which they have been recorded. There
2829 -- are two occasions in which we record good ali files. The first is
2830 -- in phase 1 when, after scanning an existing ALI file we realize
2831 -- it is up-to-date, the second instance is after a successful
2834 while Good_ALI_Present loop
2835 ALI := Get_Next_Good_ALI;
2837 -- If we are processing the library file corresponding to the
2838 -- main source file check if this source can be a main unit.
2840 if ALIs.Table (ALI).Sfile = Main_Source then
2841 Main_Unit := ALIs.Table (ALI).Main_Program /= None;
2844 -- The following adds the standard library (s-stalib) to the
2845 -- list of files to be handled by gnatmake: this file and any
2846 -- files it depends on are always included in every bind,
2847 -- even if they are not in the explicit dependency list.
2848 -- Of course, it is not added if Suppress_Standard_Library
2851 -- However, to avoid annoying output about s-stalib.ali being
2852 -- read only, when "-v" is used, we add the standard library
2853 -- only when "-a" is used.
2855 if Need_To_Check_Standard_Library then
2856 Need_To_Check_Standard_Library := False;
2858 if not Targparm.Suppress_Standard_Library_On_Target then
2861 Add_It : Boolean := True;
2864 Name_Len := Standard_Library_Package_Body_Name'Length;
2865 Name_Buffer (1 .. Name_Len) :=
2866 Standard_Library_Package_Body_Name;
2867 Sfile := Name_Enter;
2869 -- If we have a special runtime, we add the standard
2870 -- library only if we can find it.
2873 Add_It := Find_File (Sfile, Osint.Source) /= No_File;
2877 if Is_Marked (Sfile) then
2878 if Is_In_Obsoleted (Sfile) then
2879 Executable_Obsolete := True;
2891 -- Now insert in the Q the unmarked source files (i.e. those
2892 -- which have never been inserted in the Q and hence never
2893 -- considered). Only do that if Unique_Compile is False.
2895 if not Unique_Compile then
2897 ALIs.Table (ALI).First_Unit .. ALIs.Table (ALI).Last_Unit
2900 Units.Table (J).First_With .. Units.Table (J).Last_With
2902 Sfile := Withs.Table (K).Sfile;
2903 Add_Dependency (ALIs.Table (ALI).Sfile, Sfile);
2905 if Is_In_Obsoleted (Sfile) then
2906 Executable_Obsolete := True;
2909 if Sfile = No_File then
2910 Debug_Msg ("Skipping generic:", Withs.Table (K).Uname);
2912 elsif Is_Marked (Sfile) then
2913 Debug_Msg ("Skipping marked file:", Sfile);
2915 elsif not Check_Readonly_Files
2916 and then Is_Internal_File_Name (Sfile)
2918 Debug_Msg ("Skipping internal file:", Sfile);
2921 Insert_Q (Sfile, Withs.Table (K).Uname);
2929 if Display_Compilation_Progress then
2930 Write_Str ("completed ");
2931 Write_Int (Int (Q_Front));
2932 Write_Str (" out of ");
2933 Write_Int (Int (Q.Last));
2935 Write_Int (Int ((Q_Front * 100) / (Q.Last - Q.First)));
2936 Write_Str ("%)...");
2941 Compilation_Failures := Bad_Compilation_Count;
2943 -- Compilation is finished
2945 -- Delete any temporary configuration pragma file
2947 Delete_Temp_Config_Files;
2949 end Compile_Sources;
2951 ----------------------------------
2952 -- Configuration_Pragmas_Switch --
2953 ----------------------------------
2955 function Configuration_Pragmas_Switch
2956 (For_Project : Project_Id) return Argument_List
2958 The_Packages : Package_Id;
2959 Gnatmake : Package_Id;
2960 Compiler : Package_Id;
2962 Global_Attribute : Variable_Value := Nil_Variable_Value;
2963 Local_Attribute : Variable_Value := Nil_Variable_Value;
2965 Global_Attribute_Present : Boolean := False;
2966 Local_Attribute_Present : Boolean := False;
2968 Result : Argument_List (1 .. 3);
2969 Last : Natural := 0;
2971 function Absolute_Path
2973 Project : Project_Id) return String;
2974 -- Returns an absolute path for a configuration pragmas file.
2980 function Absolute_Path
2982 Project : Project_Id) return String
2985 Get_Name_String (Path);
2988 Path_Name : constant String := Name_Buffer (1 .. Name_Len);
2991 if Is_Absolute_Path (Path_Name) then
2996 Parent_Directory : constant String :=
2997 Get_Name_String (Projects.Table (Project).Directory);
3000 if Parent_Directory (Parent_Directory'Last) =
3003 return Parent_Directory & Path_Name;
3006 return Parent_Directory & Directory_Separator & Path_Name;
3013 -- Start of processing for Configuration_Pragmas_Switch
3016 Prj.Env.Create_Config_Pragmas_File (For_Project, Main_Project);
3018 if Projects.Table (For_Project).Config_File_Name /= No_Name then
3019 Temporary_Config_File :=
3020 Projects.Table (For_Project).Config_File_Temp;
3026 (Projects.Table (For_Project).Config_File_Name));
3029 Temporary_Config_File := False;
3032 -- Check for attribute Builder'Global_Configuration_Pragmas
3034 The_Packages := Projects.Table (Main_Project).Decl.Packages;
3037 (Name => Name_Builder,
3038 In_Packages => The_Packages);
3040 if Gnatmake /= No_Package then
3041 Global_Attribute := Prj.Util.Value_Of
3042 (Variable_Name => Name_Global_Configuration_Pragmas,
3043 In_Variables => Packages.Table (Gnatmake).Decl.Attributes);
3044 Global_Attribute_Present :=
3045 Global_Attribute /= Nil_Variable_Value
3046 and then Get_Name_String (Global_Attribute.Value) /= "";
3048 if Global_Attribute_Present then
3050 Path : constant String :=
3052 (Global_Attribute.Value, Global_Attribute.Project);
3054 if not Is_Regular_File (Path) then
3056 ("cannot find configuration pragmas file ", Path);
3060 Result (Last) := new String'("-gnatec=" & Path);
3065 -- Check for attribute Compiler'Local_Configuration_Pragmas
3067 The_Packages := Projects.Table (For_Project).Decl.Packages;
3070 (Name => Name_Compiler,
3071 In_Packages => The_Packages);
3073 if Compiler /= No_Package then
3074 Local_Attribute := Prj.Util.Value_Of
3075 (Variable_Name => Name_Local_Configuration_Pragmas,
3076 In_Variables => Packages.Table (Compiler).Decl.Attributes);
3077 Local_Attribute_Present :=
3078 Local_Attribute /= Nil_Variable_Value
3079 and then Get_Name_String (Local_Attribute.Value) /= "";
3081 if Local_Attribute_Present then
3083 Path : constant String :=
3085 (Local_Attribute.Value, Local_Attribute.Project);
3087 if not Is_Regular_File (Path) then
3089 ("cannot find configuration pragmas file ", Path);
3093 Result (Last) := new String'("-gnatec=" & Path);
3098 return Result (1 .. Last);
3099 end Configuration_Pragmas_Switch;
3105 procedure Debug_Msg (S : String; N : Name_Id) is
3107 if Debug.Debug_Flag_W then
3108 Write_Str (" ... ");
3116 ---------------------------
3117 -- Delete_All_Temp_Files --
3118 ---------------------------
3120 procedure Delete_All_Temp_Files is
3122 if Gnatmake_Called and not Debug.Debug_Flag_N then
3123 Delete_Mapping_Files;
3124 Delete_Temp_Config_Files;
3125 Prj.Env.Delete_All_Path_Files;
3127 end Delete_All_Temp_Files;
3129 --------------------------
3130 -- Delete_Mapping_Files --
3131 --------------------------
3133 procedure Delete_Mapping_Files is
3136 if not Debug.Debug_Flag_N then
3137 if The_Mapping_File_Names /= null then
3138 for Project in The_Mapping_File_Names'Range (1) loop
3139 for Index in 1 .. Last_Mapping_File_Names (Project) loop
3141 (Name => Get_Name_String
3142 (The_Mapping_File_Names (Project, Index)),
3143 Success => Success);
3148 end Delete_Mapping_Files;
3150 ------------------------------
3151 -- Delete_Temp_Config_Files --
3152 ------------------------------
3154 procedure Delete_Temp_Config_Files is
3157 if (not Debug.Debug_Flag_N) and Main_Project /= No_Project then
3158 for Project in 1 .. Projects.Last loop
3159 if Projects.Table (Project).Config_File_Temp then
3160 if Verbose_Mode then
3161 Write_Str ("Deleting temp configuration file """);
3162 Write_Str (Get_Name_String
3163 (Projects.Table (Project).Config_File_Name));
3168 (Name => Get_Name_String
3169 (Projects.Table (Project).Config_File_Name),
3170 Success => Success);
3172 -- Make sure that we don't have a config file for this
3173 -- project, in case when there are several mains.
3174 -- In this case, we will recreate another config file:
3175 -- we cannot reuse the one that we just deleted!
3177 Projects.Table (Project).Config_Checked := False;
3178 Projects.Table (Project).Config_File_Name := No_Name;
3179 Projects.Table (Project).Config_File_Temp := False;
3183 end Delete_Temp_Config_Files;
3189 procedure Display (Program : String; Args : Argument_List) is
3191 pragma Assert (Args'First = 1);
3193 if Display_Executed_Programs then
3194 Write_Str (Program);
3196 for J in Args'Range loop
3198 -- Do not display the mapping file argument automatically
3199 -- created when using a project file.
3201 if Main_Project = No_Project
3202 or else Debug.Debug_Flag_N
3203 or else Args (J)'Length < 8
3205 Args (J)(Args (J)'First .. Args (J)'First + 6) /= "-gnatem"
3207 -- When -dn is not specified, do not display the config
3208 -- pragmas switch (-gnatec) for the temporary file created
3209 -- by the project manager (always the first -gnatec switch).
3210 -- Reset Temporary_Config_File to False so that the eventual
3211 -- other -gnatec switches will be displayed.
3213 if (not Debug.Debug_Flag_N)
3214 and then Temporary_Config_File
3215 and then Args (J)'Length > 7
3216 and then Args (J)(Args (J)'First .. Args (J)'First + 6)
3219 Temporary_Config_File := False;
3221 -- Do not display the -F=mapping_file switch for gnatbind,
3222 -- if -dn is not specified.
3224 elsif Debug.Debug_Flag_N
3225 or else Args (J)'Length < 4
3226 or else Args (J)(Args (J)'First .. Args (J)'First + 2) /=
3230 Write_Str (Args (J).all);
3239 ----------------------
3240 -- Display_Commands --
3241 ----------------------
3243 procedure Display_Commands (Display : Boolean := True) is
3245 Display_Executed_Programs := Display;
3246 end Display_Commands;
3252 function Empty_Q return Boolean is
3254 if Debug.Debug_Flag_P then
3255 Write_Str (" Q := [");
3257 for J in Q_Front .. Q.Last - 1 loop
3259 Write_Name (Q.Table (J).File);
3268 return Q_Front >= Q.Last;
3271 --------------------------
3272 -- Enter_Into_Obsoleted --
3273 --------------------------
3275 procedure Enter_Into_Obsoleted (F : Name_Id) is
3276 Name : constant String := Get_Name_String (F);
3277 First : Natural := Name'Last;
3281 while First > Name'First
3282 and then Name (First - 1) /= Directory_Separator
3283 and then Name (First - 1) /= '/'
3288 if First /= Name'First then
3290 Add_Str_To_Name_Buffer (Name (First .. Name'Last));
3294 Debug_Msg ("New entry in Obsoleted table:", F2);
3295 Obsoleted.Set (F2, True);
3296 end Enter_Into_Obsoleted;
3298 ---------------------
3299 -- Extract_Failure --
3300 ---------------------
3302 procedure Extract_Failure
3303 (File : out File_Name_Type;
3304 Unit : out Unit_Name_Type;
3305 Found : out Boolean)
3308 File := Bad_Compilation.Table (Bad_Compilation.Last).File;
3309 Unit := Bad_Compilation.Table (Bad_Compilation.Last).Unit;
3310 Found := Bad_Compilation.Table (Bad_Compilation.Last).Found;
3311 Bad_Compilation.Decrement_Last;
3312 end Extract_Failure;
3314 --------------------
3315 -- Extract_From_Q --
3316 --------------------
3318 procedure Extract_From_Q
3319 (Source_File : out File_Name_Type;
3320 Source_Unit : out Unit_Name_Type)
3322 File : constant File_Name_Type := Q.Table (Q_Front).File;
3323 Unit : constant Unit_Name_Type := Q.Table (Q_Front).Unit;
3326 if Debug.Debug_Flag_Q then
3327 Write_Str (" Q := Q - [ ");
3333 Q_Front := Q_Front + 1;
3334 Source_File := File;
3335 Source_Unit := Unit;
3342 procedure Make_Failed (S1 : String; S2 : String := ""; S3 : String := "") is
3344 Delete_All_Temp_Files;
3345 Osint.Fail (S1, S2, S3);
3352 procedure Gnatmake is
3353 Main_Source_File : File_Name_Type;
3354 -- The source file containing the main compilation unit
3356 Compilation_Failures : Natural;
3358 Total_Compilation_Failures : Natural := 0;
3360 Is_Main_Unit : Boolean;
3361 -- Set to True by Compile_Sources if the Main_Source_File can be a
3364 Main_ALI_File : File_Name_Type;
3365 -- The ali file corresponding to Main_Source_File
3367 Executable : File_Name_Type := No_File;
3368 -- The file name of an executable
3370 Non_Std_Executable : Boolean := False;
3371 -- Non_Std_Executable is set to True when there is a possibility
3372 -- that the linker will not choose the correct executable file name.
3374 Current_Work_Dir : constant String_Access :=
3375 new String'(Get_Current_Dir);
3376 -- The current working directory, used to modify some relative path
3377 -- switches on the command line when a project file is used.
3380 Gnatmake_Called := True;
3382 Install_Int_Handler (Sigint_Intercepted'Access);
3384 Do_Compile_Step := True;
3385 Do_Bind_Step := True;
3386 Do_Link_Step := True;
3392 Bind_Shared := No_Shared_Switch'Access;
3393 Link_With_Shared_Libgcc := No_Shared_Libgcc_Switch'Access;
3394 Bind_Shared_Known := False;
3396 Failed_Links.Set_Last (0);
3397 Successful_Links.Set_Last (0);
3399 if Hostparm.Java_VM then
3400 Gcc := new String'("jgnat");
3401 Gnatbind := new String'("jgnatbind");
3402 Gnatlink := new String'("jgnatlink");
3404 -- Do not check for an object file (".o") when compiling to
3405 -- Java bytecode since ".class" files are generated instead.
3407 Check_Object_Consistency := False;
3410 -- Special case when switch -B was specified
3412 if Build_Bind_And_Link_Full_Project then
3414 -- When switch -B is specified, there must be a project file
3416 if Main_Project = No_Project then
3417 Make_Failed ("-B cannot be used without a project file");
3419 -- No main program may be specified on the command line
3421 elsif Osint.Number_Of_Files /= 0 then
3422 Make_Failed ("-B cannot be used with a main specified on " &
3423 "the command line");
3425 -- And the project file cannot be a library project file
3427 elsif Projects.Table (Main_Project).Library then
3428 Make_Failed ("-B cannot be used for a library project file");
3431 Insert_Project_Sources
3432 (The_Project => Main_Project,
3433 All_Projects => Unique_Compile_All_Projects,
3436 -- If there are no sources to compile, we fail
3438 if Osint.Number_Of_Files = 0 then
3439 Make_Failed ("no sources to compile");
3442 -- Specify -n for gnatbind and add the ALI files of all the
3443 -- sources, except the one which is a fake main subprogram:
3444 -- this is the one for the binder generated file and it will be
3445 -- transmitted to gnatlink. These sources are those that are
3448 Add_Switch ("-n", Binder, And_Save => True);
3450 for J in Q.First .. Q.Last - 1 loop
3453 (Lib_File_Name (Q.Table (J).File)),
3454 Binder, And_Save => True);
3458 elsif Main_Project /= No_Project then
3460 -- If the main project file is a library project file, main(s)
3461 -- cannot be specified on the command line.
3463 if Osint.Number_Of_Files /= 0 then
3464 if Projects.Table (Main_Project).Library
3465 and then not Unique_Compile
3466 and then ((not Make_Steps) or else Bind_Only or else Link_Only)
3468 Make_Failed ("cannot specify a main program " &
3469 "on the command line for a library project file");
3472 -- Check that each main on the command line is a source of a
3473 -- project file and, if there are several mains, each of them
3474 -- is a source of the same project file.
3479 Real_Main_Project : Project_Id := No_Project;
3480 -- The project of the first main
3482 Proj : Project_Id := No_Project;
3483 -- The project of the current main
3490 Main : constant String := Mains.Next_Main;
3491 -- The name specified on the command line may include
3492 -- directory information.
3494 File_Name : constant String := Base_Name (Main);
3495 -- The simple file name of the current main main
3498 exit when Main = "";
3500 -- Get the project of the current main
3502 Proj := Prj.Env.Project_Of (File_Name, Main_Project);
3504 -- Fail if the current main is not a source of a
3507 if Proj = No_Project then
3510 """ is not a source of any project");
3513 -- If there is directory information, check that
3514 -- the source exists and, if it does, that the path
3515 -- is the actual path of a source of a project.
3517 if Main /= File_Name then
3519 Data : constant Project_Data :=
3520 Projects.Table (Main_Project);
3522 Project_Path : constant String :=
3523 Prj.Env.File_Name_Of_Library_Unit_Body
3525 Project => Main_Project,
3526 Main_Project_Only => False,
3528 Real_Path : String_Access :=
3532 (Data.Naming.Current_Body_Suffix),
3535 if Real_Path = null then
3540 (Data.Naming.Current_Spec_Suffix),
3544 if Real_Path = null then
3546 Locate_Regular_File (Main, "");
3549 -- Fail if the file cannot be found
3551 if Real_Path = null then
3553 ("file """ & Main & """ does not exist");
3557 Normed_Path : constant String :=
3560 Case_Sensitive => False);
3564 -- Fail if it is not the correct path
3566 if Normed_Path /= Project_Path then
3567 if Verbose_Mode then
3568 Write_Str (Normed_Path);
3570 Write_Line (Project_Path);
3575 """ is not a source of any project");
3581 if not Unique_Compile then
3583 -- Record the project, if it is the first main
3585 if Real_Main_Project = No_Project then
3586 Real_Main_Project := Proj;
3588 elsif Proj /= Real_Main_Project then
3590 -- Fail, as the current main is not a source
3591 -- of the same project as the first main.
3595 """ is not a source of project " &
3598 (Real_Main_Project).Name));
3603 -- If -u and -U are not used, we may have mains that
3604 -- are sources of a project that is not the one
3605 -- specified with switch -P.
3607 if not Unique_Compile then
3608 Main_Project := Real_Main_Project;
3615 -- If no mains have been specified on the command line,
3616 -- and we are using a project file, we either find the main(s)
3617 -- in the attribute Main of the main project, or we put all
3618 -- the sources of the project file as mains.
3622 Value : String_List_Id := Projects.Table (Main_Project).Mains;
3625 -- The attribute Main is an empty list or not specified,
3626 -- or else gnatmake was invoked with the switch "-u".
3628 if Value = Prj.Nil_String or else Unique_Compile then
3630 if (not Make_Steps) or else Compile_Only
3631 or else not Projects.Table (Main_Project).Library
3633 -- First make sure that the binder and the linker
3634 -- will not be invoked.
3636 Do_Bind_Step := False;
3637 Do_Link_Step := False;
3639 -- Put all the sources in the queue
3641 Insert_Project_Sources
3642 (The_Project => Main_Project,
3643 All_Projects => Unique_Compile_All_Projects,
3646 -- If there are no sources to compile, we fail
3648 if Osint.Number_Of_Files = 0 then
3649 Make_Failed ("no sources to compile");
3654 -- The attribute Main is not an empty list.
3655 -- Put all the main subprograms in the list as if there
3656 -- were specified on the command line. However, if attribute
3657 -- Languages includes a language other than Ada, only
3658 -- include the Ada mains; if there is no Ada main, compile
3659 -- all the sources of the project.
3662 Data : constant Project_Data :=
3663 Projects.Table (Main_Project);
3665 Languages : constant Variable_Value :=
3667 (Name_Languages, Data.Decl.Attributes);
3669 Current : String_List_Id;
3670 Element : String_Element;
3672 Foreign_Language : Boolean := False;
3673 At_Least_One_Main : Boolean := False;
3676 -- First, determine if there is a foreign language in
3677 -- attribute Languages.
3679 if not Languages.Default then
3680 Current := Languages.Values;
3683 while Current /= Nil_String loop
3684 Element := String_Elements.Table (Current);
3685 Get_Name_String (Element.Value);
3686 To_Lower (Name_Buffer (1 .. Name_Len));
3688 if Name_Buffer (1 .. Name_Len) /= "ada" then
3689 Foreign_Language := True;
3690 exit Look_For_Foreign;
3693 Current := Element.Next;
3694 end loop Look_For_Foreign;
3697 -- Then, find all mains, or if there is a foreign
3698 -- language, all the Ada mains.
3700 while Value /= Prj.Nil_String loop
3701 Get_Name_String (String_Elements.Table (Value).Value);
3703 -- To know if a main is an Ada main, get its project.
3704 -- It should be the project specified on the command
3707 if (not Foreign_Language) or else
3709 (Name_Buffer (1 .. Name_Len), Main_Project) =
3712 At_Least_One_Main := True;
3715 (String_Elements.Table (Value).Value));
3718 Value := String_Elements.Table (Value).Next;
3721 -- If we did not get any main, it means that all mains
3722 -- in attribute Mains are in a foreign language and -B
3723 -- was not specified to gnatmake; so, we fail.
3725 if not At_Least_One_Main then
3727 ("no Ada mains; use -B to build foreign main");
3736 if Verbose_Mode then
3738 Write_Str ("GNATMAKE ");
3739 Write_Str (Gnatvsn.Gnat_Version_String);
3740 Write_Str (" Copyright 1995-2004 Free Software Foundation, Inc.");
3744 if Osint.Number_Of_Files = 0 then
3745 if Main_Project /= No_Project
3746 and then Projects.Table (Main_Project).Library
3749 and then not Projects.Table (Main_Project).Standalone_Library
3751 Make_Failed ("only stand-alone libraries may be bound");
3754 -- Add the default search directories to be able to find libgnat
3756 Osint.Add_Default_Search_Dirs;
3758 -- And bind and or link the library
3760 MLib.Prj.Build_Library
3761 (For_Project => Main_Project,
3762 Gnatbind => Gnatbind.all,
3763 Gnatbind_Path => Gnatbind_Path,
3765 Gcc_Path => Gcc_Path,
3768 Exit_Program (E_Success);
3771 -- Output usage information if no files to compile
3774 Exit_Program (E_Fatal);
3778 -- If -M was specified, behave as if -n was specified
3780 if List_Dependencies then
3781 Do_Not_Execute := True;
3784 -- Note that Osint.Next_Main_Source will always return the (possibly
3785 -- abbreviated file) without any directory information.
3787 Main_Source_File := Next_Main_Source;
3789 Add_Switch ("-I-", Binder, And_Save => True);
3790 Add_Switch ("-I-", Compiler, And_Save => True);
3792 if Main_Project = No_Project then
3793 if Look_In_Primary_Dir then
3797 Normalize_Directory_Name
3798 (Get_Primary_Src_Search_Directory.all).all,
3799 Compiler, Append_Switch => False,
3802 Add_Switch ("-aO" & Normalized_CWD,
3804 Append_Switch => False,
3809 -- If we use a project file, we have already checked that a main
3810 -- specified on the command line with directory information has the
3811 -- path name corresponding to a correct source in the project tree.
3812 -- So, we don't need the directory information to be taken into
3813 -- account by Find_File, and in fact it may lead to take the wrong
3814 -- sources for other compilation units, when there are extending
3817 Look_In_Primary_Dir := False;
3820 -- If the user wants a program without a main subprogram, add the
3821 -- appropriate switch to the binder.
3823 if No_Main_Subprogram then
3824 Add_Switch ("-z", Binder, And_Save => True);
3827 if Main_Project /= No_Project then
3829 if Projects.Table (Main_Project).Object_Directory = No_Name then
3830 Make_Failed ("no sources to compile");
3833 -- Change the current directory to the object directory of the main
3837 Project_Object_Directory := No_Project;
3838 Change_To_Object_Directory (Main_Project);
3841 when Directory_Error =>
3843 -- This should never happen. But, if it does, display the
3844 -- content of the parent directory of the obj dir.
3847 Parent : constant Dir_Name_Str :=
3850 (Projects.Table (Main_Project).Object_Directory));
3852 Str : String (1 .. 200);
3856 Write_Str ("Contents of directory """);
3863 Read (Dir, Str, Last);
3866 Write_Line (Str (1 .. Last));
3873 Write_Line ("(unexpected exception)");
3874 Write_Line (Exception_Information (X));
3876 if Is_Open (Dir) then
3881 Make_Failed ("unable to change working directory to """,
3883 (Projects.Table (Main_Project).Object_Directory),
3887 -- Source file lookups should be cached for efficiency.
3888 -- Source files are not supposed to change.
3890 Osint.Source_File_Data (Cache => True);
3892 -- Find the file name of the (first) main unit
3895 Main_Source_File_Name : constant String :=
3896 Get_Name_String (Main_Source_File);
3897 Main_Unit_File_Name : constant String :=
3898 Prj.Env.File_Name_Of_Library_Unit_Body
3899 (Name => Main_Source_File_Name,
3900 Project => Main_Project,
3901 Main_Project_Only =>
3902 not Unique_Compile);
3904 The_Packages : constant Package_Id :=
3905 Projects.Table (Main_Project).Decl.Packages;
3907 Builder_Package : constant Prj.Package_Id :=
3909 (Name => Name_Builder,
3910 In_Packages => The_Packages);
3912 Binder_Package : constant Prj.Package_Id :=
3914 (Name => Name_Binder,
3915 In_Packages => The_Packages);
3917 Linker_Package : constant Prj.Package_Id :=
3919 (Name => Name_Linker,
3920 In_Packages => The_Packages);
3923 -- We fail if we cannot find the main source file
3925 if Main_Unit_File_Name = "" then
3926 Make_Failed ('"' & Main_Source_File_Name,
3927 """ is not a unit of project ",
3928 Project_File_Name.all & ".");
3930 -- Remove any directory information from the main
3931 -- source file name.
3934 Pos : Natural := Main_Unit_File_Name'Last;
3938 exit when Pos < Main_Unit_File_Name'First or else
3939 Main_Unit_File_Name (Pos) = Directory_Separator;
3943 Name_Len := Main_Unit_File_Name'Last - Pos;
3945 Name_Buffer (1 .. Name_Len) :=
3947 (Pos + 1 .. Main_Unit_File_Name'Last);
3949 Main_Source_File := Name_Find;
3951 -- We only output the main source file if there is only one
3953 if Verbose_Mode and then Osint.Number_Of_Files = 1 then
3954 Write_Str ("Main source file: """);
3955 Write_Str (Main_Unit_File_Name
3956 (Pos + 1 .. Main_Unit_File_Name'Last));
3962 -- If there is a package Builder in the main project file, add
3963 -- the switches from it.
3965 if Builder_Package /= No_Package then
3967 -- If there is only one main, we attempt to get the gnatmake
3968 -- switches for this main (if any). If there are no specific
3969 -- switch for this particular main, get the general gnatmake
3970 -- switches (if any).
3972 if Osint.Number_Of_Files = 1 then
3973 if Verbose_Mode then
3974 Write_Str ("Adding gnatmake switches for """);
3975 Write_Str (Main_Unit_File_Name);
3980 (File_Name => Main_Unit_File_Name,
3981 The_Package => Builder_Package,
3985 -- If there are several mains, we always get the general
3986 -- gnatmake switches (if any).
3988 -- Warn the user, if necessary, so that he is not surprized
3989 -- that specific switches are not taken into account.
3992 Defaults : constant Variable_Value :=
3995 Attribute_Or_Array_Name => Name_Default_Switches,
3996 In_Package => Builder_Package);
3998 Switches : constant Array_Element_Id :=
4000 (Name => Name_Switches,
4002 Packages.Table (Builder_Package).Decl.Arrays);
4005 if Defaults /= Nil_Variable_Value then
4006 if (not Quiet_Output)
4007 and then Switches /= No_Array_Element
4010 ("Warning: using Builder'Default_Switches" &
4011 "(""Ada""), as there are several mains");
4014 -- As there is never a source with name " ", we are
4015 -- guaranteed to always get the general switches.
4019 The_Package => Builder_Package,
4022 elsif (not Quiet_Output)
4023 and then Switches /= No_Array_Element
4026 ("Warning: using no switches from package Builder," &
4027 " as there are several mains");
4033 Osint.Add_Default_Search_Dirs;
4035 -- Record the current last switch index for table Binder_Switches
4036 -- and Linker_Switches, so that these tables may be reset before
4037 -- for each main, before adding swiches from the project file
4038 -- and from the command line.
4040 Last_Binder_Switch := Binder_Switches.Last;
4041 Last_Linker_Switch := Linker_Switches.Last;
4045 -- Add binder switches from the project file for the first main
4047 if Do_Bind_Step and Binder_Package /= No_Package then
4048 if Verbose_Mode then
4049 Write_Str ("Adding binder switches for """);
4050 Write_Str (Main_Unit_File_Name);
4055 (File_Name => Main_Unit_File_Name,
4056 The_Package => Binder_Package,
4060 -- Add linker switches from the project file for the first main
4062 if Do_Link_Step and Linker_Package /= No_Package then
4063 if Verbose_Mode then
4064 Write_Str ("Adding linker switches for""");
4065 Write_Str (Main_Unit_File_Name);
4070 (File_Name => Main_Unit_File_Name,
4071 The_Package => Linker_Package,
4077 -- Get the target parameters, which are only needed for a couple of
4078 -- cases in gnatmake. Protect against an exception, such as the case
4079 -- of system.ads missing from the library, and fail gracefully.
4082 Targparm.Get_Target_Parameters;
4085 when Unrecoverable_Error =>
4086 Make_Failed ("*** make failed.");
4089 Display_Commands (not Quiet_Output);
4093 if Main_Project /= No_Project then
4095 -- For all library project, if the library file does not exist
4096 -- put all the project sources in the queue, and flag the project
4097 -- so that the library is generated.
4099 if MLib.Tgt.Support_For_Libraries /= MLib.Tgt.None then
4100 for Proj in Projects.First .. Projects.Last loop
4101 if Projects.Table (Proj).Library then
4102 Projects.Table (Proj).Flag1 :=
4103 not MLib.Tgt.Library_Exists_For (Proj);
4105 if Projects.Table (Proj).Flag1 then
4106 if Verbose_Mode then
4108 ("Library file does not exist for project """);
4110 (Get_Name_String (Projects.Table (Proj).Name));
4114 Insert_Project_Sources
4115 (The_Project => Proj,
4116 All_Projects => False,
4123 -- If a relative path output file has been specified, we add
4124 -- the exec directory.
4126 for J in reverse 1 .. Saved_Linker_Switches.Last - 1 loop
4127 if Saved_Linker_Switches.Table (J).all = Output_Flag.all then
4129 Exec_File_Name : constant String :=
4130 Saved_Linker_Switches.Table (J + 1).all;
4133 if not Is_Absolute_Path (Exec_File_Name) then
4134 for Index in Exec_File_Name'Range loop
4135 if Exec_File_Name (Index) = Directory_Separator then
4136 Make_Failed ("relative executable (""",
4138 """) with directory part not " &
4139 "allowed when using project files");
4143 Get_Name_String (Projects.Table
4144 (Main_Project).Exec_Directory);
4146 if Name_Buffer (Name_Len) /= Directory_Separator then
4147 Name_Len := Name_Len + 1;
4148 Name_Buffer (Name_Len) := Directory_Separator;
4151 Name_Buffer (Name_Len + 1 ..
4152 Name_Len + Exec_File_Name'Length) :=
4154 Name_Len := Name_Len + Exec_File_Name'Length;
4155 Saved_Linker_Switches.Table (J + 1) :=
4156 new String'(Name_Buffer (1 .. Name_Len));
4164 -- If we are using a project file, for relative paths we add the
4165 -- current working directory for any relative path on the command
4166 -- line and the project directory, for any relative path in the
4170 Dir_Path : constant String_Access :=
4171 new String'(Get_Name_String
4172 (Projects.Table (Main_Project).Directory));
4174 for J in 1 .. Binder_Switches.Last loop
4175 Test_If_Relative_Path
4176 (Binder_Switches.Table (J),
4177 Parent => Dir_Path, Including_L_Switch => False);
4180 for J in 1 .. Saved_Binder_Switches.Last loop
4181 Test_If_Relative_Path
4182 (Saved_Binder_Switches.Table (J),
4183 Parent => Current_Work_Dir, Including_L_Switch => False);
4186 for J in 1 .. Linker_Switches.Last loop
4187 Test_If_Relative_Path
4188 (Linker_Switches.Table (J), Parent => Dir_Path);
4191 for J in 1 .. Saved_Linker_Switches.Last loop
4192 Test_If_Relative_Path
4193 (Saved_Linker_Switches.Table (J), Parent => Current_Work_Dir);
4196 for J in 1 .. Gcc_Switches.Last loop
4197 Test_If_Relative_Path
4198 (Gcc_Switches.Table (J), Parent => Dir_Path);
4201 for J in 1 .. Saved_Gcc_Switches.Last loop
4202 Test_If_Relative_Path
4203 (Saved_Gcc_Switches.Table (J), Parent => Current_Work_Dir);
4208 -- We now put in the Binder_Switches and Linker_Switches tables,
4209 -- the binder and linker switches of the command line that have been
4210 -- put in the Saved_ tables. If a project file was used, then the
4211 -- command line switches will follow the project file switches.
4213 for J in 1 .. Saved_Binder_Switches.Last loop
4215 (Saved_Binder_Switches.Table (J),
4220 for J in 1 .. Saved_Linker_Switches.Last loop
4222 (Saved_Linker_Switches.Table (J),
4227 -- If no project file is used, we just put the gcc switches
4228 -- from the command line in the Gcc_Switches table.
4230 if Main_Project = No_Project then
4231 for J in 1 .. Saved_Gcc_Switches.Last loop
4233 (Saved_Gcc_Switches.Table (J),
4239 -- And we put the command line gcc switches in the variable
4240 -- The_Saved_Gcc_Switches. They are going to be used later
4241 -- in procedure Compile_Sources.
4243 The_Saved_Gcc_Switches :=
4244 new Argument_List (1 .. Saved_Gcc_Switches.Last + 1);
4246 for J in 1 .. Saved_Gcc_Switches.Last loop
4247 The_Saved_Gcc_Switches (J) := Saved_Gcc_Switches.Table (J);
4250 -- We never use gnat.adc when a project file is used
4252 The_Saved_Gcc_Switches (The_Saved_Gcc_Switches'Last) :=
4257 -- If there was a --GCC, --GNATBIND or --GNATLINK switch on
4258 -- the command line, then we have to use it, even if there was
4259 -- another switch in the project file.
4261 if Saved_Gcc /= null then
4265 if Saved_Gnatbind /= null then
4266 Gnatbind := Saved_Gnatbind;
4269 if Saved_Gnatlink /= null then
4270 Gnatlink := Saved_Gnatlink;
4273 Gcc_Path := GNAT.OS_Lib.Locate_Exec_On_Path (Gcc.all);
4274 Gnatbind_Path := GNAT.OS_Lib.Locate_Exec_On_Path (Gnatbind.all);
4275 Gnatlink_Path := GNAT.OS_Lib.Locate_Exec_On_Path (Gnatlink.all);
4277 -- If we have specified -j switch both from the project file
4278 -- and on the command line, the one from the command line takes
4281 if Saved_Maximum_Processes = 0 then
4282 Saved_Maximum_Processes := Maximum_Processes;
4285 -- Allocate as many temporary mapping file names as the maximum
4286 -- number of compilation processed, for each possible project.
4288 The_Mapping_File_Names :=
4290 (No_Project .. Projects.Last, 1 .. Saved_Maximum_Processes);
4291 Last_Mapping_File_Names :=
4292 new Indices'(No_Project .. Projects.Last => 0);
4294 The_Free_Mapping_File_Indices :=
4295 new Free_File_Indices
4296 (No_Project .. Projects.Last, 1 .. Saved_Maximum_Processes);
4297 Last_Free_Indices :=
4298 new Indices'(No_Project .. Projects.Last => 0);
4300 Bad_Compilation.Init;
4302 -- Here is where the make process is started
4304 -- We do the same process for each main
4306 Multiple_Main_Loop : for N_File in 1 .. Osint.Number_Of_Files loop
4308 -- Increase the marking label to be sure to check sources
4309 -- for all executables.
4311 Marking_Label := Marking_Label + 1;
4313 -- Make sure it is not 0, which is the default value for
4314 -- a file that has never been marked.
4316 if Marking_Label = 0 then
4320 -- First, find the executable name and path
4322 Executable := No_File;
4323 Executable_Obsolete := False;
4324 Non_Std_Executable := False;
4326 -- Look inside the linker switches to see if the name
4327 -- of the final executable program was specified.
4330 J in reverse Linker_Switches.First .. Linker_Switches.Last
4332 if Linker_Switches.Table (J).all = Output_Flag.all then
4333 pragma Assert (J < Linker_Switches.Last);
4335 -- We cannot specify a single executable for several
4336 -- main subprograms!
4338 if Osint.Number_Of_Files > 1 then
4340 ("cannot specify a single executable " &
4341 "for several mains");
4344 Name_Len := Linker_Switches.Table (J + 1)'Length;
4345 Name_Buffer (1 .. Name_Len) :=
4346 Linker_Switches.Table (J + 1).all;
4347 Executable := Name_Enter;
4349 Verbose_Msg (Executable, "final executable");
4353 -- If the name of the final executable program was not
4354 -- specified then construct it from the main input file.
4356 if Executable = No_File then
4357 if Main_Project = No_Project then
4359 Executable_Name (Strip_Suffix (Main_Source_File));
4362 -- If we are using a project file, we attempt to
4363 -- remove the body (or spec) termination of the main
4364 -- subprogram. We find it the the naming scheme of the
4365 -- project file. This will avoid to generate an
4366 -- executable "main.2" for a main subprogram
4367 -- "main.2.ada", when the body termination is ".2.ada".
4369 Executable := Prj.Util.Executable_Of
4370 (Main_Project, Main_Source_File);
4374 if Main_Project /= No_Project then
4376 Exec_File_Name : constant String :=
4377 Get_Name_String (Executable);
4380 if not Is_Absolute_Path (Exec_File_Name) then
4381 for Index in Exec_File_Name'Range loop
4382 if Exec_File_Name (Index) = Directory_Separator then
4383 Make_Failed ("relative executable (""",
4385 """) with directory part not " &
4386 "allowed when using project files");
4390 Get_Name_String (Projects.Table
4391 (Main_Project).Exec_Directory);
4394 Name_Buffer (Name_Len) /= Directory_Separator
4396 Name_Len := Name_Len + 1;
4397 Name_Buffer (Name_Len) := Directory_Separator;
4400 Name_Buffer (Name_Len + 1 ..
4401 Name_Len + Exec_File_Name'Length) :=
4403 Name_Len := Name_Len + Exec_File_Name'Length;
4404 Executable := Name_Find;
4405 Non_Std_Executable := True;
4411 if Do_Compile_Step then
4412 Recursive_Compilation_Step : declare
4413 Args : Argument_List (1 .. Gcc_Switches.Last);
4415 First_Compiled_File : Name_Id;
4416 Youngest_Obj_File : Name_Id;
4417 Youngest_Obj_Stamp : Time_Stamp_Type;
4419 Executable_Stamp : Time_Stamp_Type;
4420 -- Executable is the final executable program.
4422 Library_Rebuilt : Boolean := False;
4425 for J in 1 .. Gcc_Switches.Last loop
4426 Args (J) := Gcc_Switches.Table (J);
4429 -- Now we invoke Compile_Sources for the current main
4432 (Main_Source => Main_Source_File,
4434 First_Compiled_File => First_Compiled_File,
4435 Most_Recent_Obj_File => Youngest_Obj_File,
4436 Most_Recent_Obj_Stamp => Youngest_Obj_Stamp,
4437 Main_Unit => Is_Main_Unit,
4438 Compilation_Failures => Compilation_Failures,
4439 Check_Readonly_Files => Check_Readonly_Files,
4440 Do_Not_Execute => Do_Not_Execute,
4441 Force_Compilations => Force_Compilations,
4442 In_Place_Mode => In_Place_Mode,
4443 Keep_Going => Keep_Going,
4444 Initialize_ALI_Data => True,
4445 Max_Process => Saved_Maximum_Processes);
4447 if Verbose_Mode then
4448 Write_Str ("End of compilation");
4452 -- Make sure the queue will be reinitialized for the next round
4454 First_Q_Initialization := True;
4456 Total_Compilation_Failures :=
4457 Total_Compilation_Failures + Compilation_Failures;
4459 if Total_Compilation_Failures /= 0 then
4464 List_Bad_Compilations;
4465 raise Compilation_Failed;
4469 -- Regenerate libraries, if any, and if object files
4470 -- have been regenerated.
4472 if Main_Project /= No_Project
4473 and then MLib.Tgt.Support_For_Libraries /= MLib.Tgt.None
4474 and then (Do_Bind_Step or Unique_Compile_All_Projects
4475 or not Compile_Only)
4476 and then (Do_Link_Step or N_File = Osint.Number_Of_Files)
4486 -- Put in Library_Projs table all library project
4487 -- file ids when the library need to be rebuilt.
4489 for Proj1 in Projects.First .. Projects.Last loop
4491 if Projects.Table (Proj1).Library
4492 and then not Projects.Table (Proj1).Flag1
4494 MLib.Prj.Check_Library (Proj1);
4497 if Projects.Table (Proj1).Flag1 then
4498 Library_Projs.Increment_Last;
4499 Current := Library_Projs.Last;
4500 Depth := Projects.Table (Proj1).Depth;
4502 -- Put the projects in decreasing depth order,
4503 -- so that if libA depends on libB, libB is first
4506 while Current > 1 loop
4507 Proj2 := Library_Projs.Table (Current - 1);
4508 exit when Projects.Table (Proj2).Depth >= Depth;
4509 Library_Projs.Table (Current) := Proj2;
4510 Current := Current - 1;
4513 Library_Projs.Table (Current) := Proj1;
4514 Projects.Table (Proj1).Flag1 := False;
4519 -- Build the libraries, if any need to be built
4521 for J in 1 .. Library_Projs.Last loop
4522 Library_Rebuilt := True;
4523 MLib.Prj.Build_Library
4524 (For_Project => Library_Projs.Table (J),
4525 Gnatbind => Gnatbind.all,
4526 Gnatbind_Path => Gnatbind_Path,
4528 Gcc_Path => Gcc_Path);
4532 if List_Dependencies then
4533 if First_Compiled_File /= No_File then
4535 (First_Compiled_File,
4536 "must be recompiled. Can't generate dependence list.");
4541 elsif First_Compiled_File = No_File
4542 and then not Do_Bind_Step
4543 and then not Quiet_Output
4544 and then not Library_Rebuilt
4545 and then Osint.Number_Of_Files = 1
4547 Inform (Msg => "objects up to date.");
4549 elsif Do_Not_Execute
4550 and then First_Compiled_File /= No_File
4552 Write_Name (First_Compiled_File);
4556 -- Stop after compile step if any of:
4558 -- 1) -n (Do_Not_Execute) specified
4560 -- 2) -M (List_Dependencies) specified (also sets
4561 -- Do_Not_Execute above, so this is probably superfluous).
4563 -- 3) -c (Compile_Only) specified, but not -b (Bind_Only)
4565 -- 4) Made unit cannot be a main unit
4568 or List_Dependencies
4570 or not Is_Main_Unit)
4571 and then not No_Main_Subprogram
4572 and then not Build_Bind_And_Link_Full_Project
4574 if Osint.Number_Of_Files = 1 then
4575 exit Multiple_Main_Loop;
4582 -- If the objects were up-to-date check if the executable file
4583 -- is also up-to-date. For now always bind and link on the JVM
4584 -- since there is currently no simple way to check the
4585 -- up-to-date status of objects
4587 if not Hostparm.Java_VM
4588 and then First_Compiled_File = No_File
4590 Executable_Stamp := File_Stamp (Executable);
4592 if not Executable_Obsolete then
4593 Executable_Obsolete :=
4594 Youngest_Obj_Stamp > Executable_Stamp;
4597 if not Executable_Obsolete then
4598 for Index in reverse 1 .. Dependencies.Last loop
4600 (Dependencies.Table (Index).Depends_On)
4602 Enter_Into_Obsoleted
4603 (Dependencies.Table (Index).This);
4607 Executable_Obsolete := Is_In_Obsoleted (Main_Source_File);
4611 if not Executable_Obsolete then
4613 -- If no Ada object files obsolete the executable, check
4614 -- for younger or missing linker files.
4616 Check_Linker_Options
4619 Youngest_Obj_Stamp);
4621 Executable_Obsolete := Youngest_Obj_File /= No_File;
4624 -- Return if the executable is up to date
4625 -- and otherwise motivate the relink/rebind.
4627 if not Executable_Obsolete then
4628 if not Quiet_Output then
4629 Inform (Executable, "up to date.");
4632 if Osint.Number_Of_Files = 1 then
4633 exit Multiple_Main_Loop;
4640 if Executable_Stamp (1) = ' ' then
4641 Verbose_Msg (Executable, "missing.", Prefix => " ");
4643 elsif Youngest_Obj_Stamp (1) = ' ' then
4649 elsif Youngest_Obj_Stamp > Executable_Stamp then
4652 "(" & String (Youngest_Obj_Stamp) & ") newer than",
4654 "(" & String (Executable_Stamp) & ")");
4658 (Executable, "needs to be rebuild.",
4663 end Recursive_Compilation_Step;
4666 -- For binding and linking, we need to be in the object directory of
4667 -- the main project.
4669 if Main_Project /= No_Project then
4670 Change_To_Object_Directory (Main_Project);
4673 -- If we are here, it means that we need to rebuilt the current
4674 -- main. So we set Executable_Obsolete to True to make sure that
4675 -- the subsequent mains will be rebuilt.
4677 Main_ALI_In_Place_Mode_Step : declare
4678 ALI_File : File_Name_Type;
4679 Src_File : File_Name_Type;
4682 Src_File := Strip_Directory (Main_Source_File);
4683 ALI_File := Lib_File_Name (Src_File);
4684 Main_ALI_File := Full_Lib_File_Name (ALI_File);
4686 -- When In_Place_Mode, the library file can be located in the
4687 -- Main_Source_File directory which may not be present in the
4688 -- library path. In this case, use the corresponding library file
4691 if Main_ALI_File = No_File and then In_Place_Mode then
4692 Get_Name_String (Get_Directory (Full_Source_Name (Src_File)));
4693 Get_Name_String_And_Append (ALI_File);
4694 Main_ALI_File := Name_Find;
4695 Main_ALI_File := Full_Lib_File_Name (Main_ALI_File);
4698 if Main_ALI_File = No_File then
4699 Make_Failed ("could not find the main ALI file");
4701 end Main_ALI_In_Place_Mode_Step;
4703 if Do_Bind_Step then
4705 Args : Argument_List
4706 (Binder_Switches.First .. Binder_Switches.Last + 1);
4707 -- The arguments for the invocation of gnatbind
4709 Last_Arg : Natural := Binder_Switches.Last;
4710 -- Index of the last argument in Args
4712 Mapping_FD : File_Descriptor := Invalid_FD;
4713 -- A File Descriptor for an eventual mapping file
4715 Mapping_Path : Name_Id := No_Name;
4716 -- The path name of the mapping file
4718 ALI_Unit : Name_Id := No_Name;
4719 -- The unit name of an ALI file
4721 ALI_Name : Name_Id := No_Name;
4722 -- The file name of the ALI file
4724 ALI_Project : Project_Id := No_Project;
4725 -- The project of the ALI file
4728 OK : Boolean := True;
4731 -- For call to Close
4734 -- If it is the first time the bind step is performed,
4735 -- check if there are shared libraries, so that gnatbind is
4736 -- called with -shared.
4738 if not Bind_Shared_Known then
4739 if Main_Project /= No_Project
4740 and then MLib.Tgt.Support_For_Libraries /= MLib.Tgt.None
4742 for Proj in Projects.First .. Projects.Last loop
4743 if Projects.Table (Proj).Library and then
4744 Projects.Table (Proj).Library_Kind /= Static
4746 Bind_Shared := Shared_Switch'Access;
4748 if GCC_Version >= 3 then
4749 Link_With_Shared_Libgcc :=
4750 Shared_Libgcc_Switch'Access;
4758 Bind_Shared_Known := True;
4761 -- Get all the binder switches
4763 for J in Binder_Switches.First .. Last_Arg loop
4764 Args (J) := Binder_Switches.Table (J);
4767 if Main_Project /= No_Project then
4769 -- Put all the source directories in ADA_INCLUDE_PATH,
4770 -- and all the object directories in ADA_OBJECTS_PATH
4772 Prj.Env.Set_Ada_Paths (Main_Project, False);
4774 -- If switch -C was specified, create a binder mapping file
4776 if Create_Mapping_File then
4777 Tempdir.Create_Temp_File (Mapping_FD, Mapping_Path);
4779 if Mapping_FD /= Invalid_FD then
4781 -- Traverse all units
4783 for J in Prj.Com.Units.First .. Prj.Com.Units.Last loop
4785 Unit : constant Prj.Com.Unit_Data :=
4786 Prj.Com.Units.Table (J);
4790 if Unit.Name /= No_Name then
4792 -- If there is a body, put it in the mapping
4794 if Unit.File_Names (Body_Part).Name /= No_Name
4795 and then Unit.File_Names (Body_Part).Project
4798 Get_Name_String (Unit.Name);
4800 (Name_Len + 1 .. Name_Len + 2) := "%b";
4801 Name_Len := Name_Len + 2;
4802 ALI_Unit := Name_Find;
4805 (Unit.File_Names (Body_Part).Name);
4807 Unit.File_Names (Body_Part).Project;
4809 -- Otherwise, if there is a spec, put it
4812 elsif Unit.File_Names (Specification).Name
4814 and then Unit.File_Names
4815 (Specification).Project
4818 Get_Name_String (Unit.Name);
4820 (Name_Len + 1 .. Name_Len + 2) := "%s";
4821 Name_Len := Name_Len + 2;
4822 ALI_Unit := Name_Find;
4823 ALI_Name := Lib_File_Name
4824 (Unit.File_Names (Specification).Name);
4826 Unit.File_Names (Specification).Project;
4829 ALI_Name := No_Name;
4832 -- If we have something to put in the mapping
4833 -- then we do it now. However, if the project
4834 -- is extended, we don't put anything in the
4835 -- mapping file, because we do not know where
4836 -- the ALI file is: it might be in the ext-
4837 -- ended project obj dir as well as in the
4838 -- extending project obj dir.
4840 if ALI_Name /= No_Name
4841 and then Projects.Table
4842 (ALI_Project).Extended_By
4844 and then Projects.Table
4845 (ALI_Project).Extends
4848 -- First line is the unit name
4850 Get_Name_String (ALI_Unit);
4851 Name_Len := Name_Len + 1;
4852 Name_Buffer (Name_Len) := ASCII.LF;
4856 Name_Buffer (1)'Address,
4858 OK := Bytes = Name_Len;
4862 -- Second line it the ALI file name
4864 Get_Name_String (ALI_Name);
4865 Name_Len := Name_Len + 1;
4866 Name_Buffer (Name_Len) := ASCII.LF;
4870 Name_Buffer (1)'Address,
4872 OK := Bytes = Name_Len;
4877 -- Third line it the ALI path name,
4878 -- concatenation of the project
4879 -- directory with the ALI file name.
4882 ALI : constant String :=
4883 Get_Name_String (ALI_Name);
4886 (Projects.Table (ALI_Project).
4889 if Name_Buffer (Name_Len) /=
4892 Name_Len := Name_Len + 1;
4893 Name_Buffer (Name_Len) :=
4894 Directory_Separator;
4899 Name_Len + ALI'Length) := ALI;
4901 Name_Len + ALI'Length + 1;
4902 Name_Buffer (Name_Len) := ASCII.LF;
4906 Name_Buffer (1)'Address,
4908 OK := Bytes = Name_Len;
4912 -- If OK is False, it means we were unable
4913 -- to write a line. No point in continuing
4914 -- with the other units.
4922 Close (Mapping_FD, Status);
4924 OK := OK and Status;
4926 -- If the creation of the mapping file was successful,
4927 -- we add the switch to the arguments of gnatbind.
4930 Last_Arg := Last_Arg + 1;
4931 Args (Last_Arg) := new String'
4932 ("-F=" & Get_Name_String (Mapping_Path));
4940 Bind (Main_ALI_File,
4941 Bind_Shared.all & Args (Args'First .. Last_Arg));
4946 -- If -dn was not specified, delete the temporary mapping
4947 -- file, if one was created.
4949 if not Debug.Debug_Flag_N
4950 and then Mapping_Path /= No_Name
4952 Delete_File (Get_Name_String (Mapping_Path), OK);
4955 -- And reraise the exception
4960 -- If -dn was not specified, delete the temporary mapping file,
4961 -- if one was created.
4963 if not Debug.Debug_Flag_N and then Mapping_Path /= No_Name then
4964 Delete_File (Get_Name_String (Mapping_Path), OK);
4969 if Do_Link_Step then
4971 There_Are_Libraries : Boolean := False;
4972 Linker_Switches_Last : constant Integer := Linker_Switches.Last;
4973 Path_Option : constant String_Access :=
4974 MLib.Tgt.Linker_Library_Path_Option;
4980 if not Run_Path_Option then
4981 Linker_Switches.Increment_Last;
4982 Linker_Switches.Table (Linker_Switches.Last) :=
4986 if Main_Project /= No_Project then
4987 Library_Paths.Set_Last (0);
4990 if MLib.Tgt.Support_For_Libraries /= MLib.Tgt.None then
4991 -- Check for library projects
4993 for Proj1 in 1 .. Projects.Last loop
4994 if Proj1 /= Main_Project
4995 and then Projects.Table (Proj1).Library
4997 -- Add this project to table Library_Projs
4999 There_Are_Libraries := True;
5000 Depth := Projects.Table (Proj1).Depth;
5001 Library_Projs.Increment_Last;
5002 Current := Library_Projs.Last;
5004 -- Any project with a greater depth should be
5005 -- after this project in the list.
5007 while Current > 1 loop
5008 Proj2 := Library_Projs.Table (Current - 1);
5009 exit when Projects.Table (Proj2).Depth <= Depth;
5010 Library_Projs.Table (Current) := Proj2;
5011 Current := Current - 1;
5014 Library_Projs.Table (Current) := Proj1;
5016 -- If it is not a static library and path option
5017 -- is set, add it to the Library_Paths table.
5019 if Projects.Table (Proj1).Library_Kind /= Static
5020 and then Path_Option /= null
5022 Library_Paths.Increment_Last;
5023 Library_Paths.Table (Library_Paths.Last) :=
5026 (Projects.Table (Proj1).Library_Dir));
5031 for Index in 1 .. Library_Projs.Last loop
5032 -- Add the -L switch
5034 Linker_Switches.Increment_Last;
5035 Linker_Switches.Table (Linker_Switches.Last) :=
5039 (Library_Projs.Table (Index)).
5042 -- Add the -l switch
5044 Linker_Switches.Increment_Last;
5045 Linker_Switches.Table (Linker_Switches.Last) :=
5049 (Library_Projs.Table (Index)).
5054 if There_Are_Libraries then
5056 -- If Path_Option is not null, create the switch
5057 -- ("-Wl,-rpath," or equivalent) with all the non static
5058 -- library dirs plus the standard GNAT library dir.
5059 -- We do that only if Run_Path_Option is True
5060 -- (not disabled by -R switch).
5062 if Run_Path_Option and Path_Option /= null then
5064 Option : String_Access;
5065 Length : Natural := Path_Option'Length;
5070 Library_Paths.First .. Library_Paths.Last
5072 -- Add the length of the library dir plus one
5073 -- for the directory separator.
5077 Library_Paths.Table (Index)'Length + 1;
5080 -- Finally, add the length of the standard GNAT
5083 Length := Length + MLib.Utl.Lib_Directory'Length;
5084 Option := new String (1 .. Length);
5085 Option (1 .. Path_Option'Length) := Path_Option.all;
5086 Current := Path_Option'Length;
5088 -- Put each library dir followed by a dir separator
5091 Library_Paths.First .. Library_Paths.Last
5096 Library_Paths.Table (Index)'Length) :=
5097 Library_Paths.Table (Index).all;
5100 Library_Paths.Table (Index)'Length + 1;
5101 Option (Current) := Path_Separator;
5104 -- Finally put the standard GNAT library dir
5108 Current + MLib.Utl.Lib_Directory'Length) :=
5109 MLib.Utl.Lib_Directory;
5111 -- And add the switch to the linker switches
5113 Linker_Switches.Increment_Last;
5114 Linker_Switches.Table (Linker_Switches.Last) :=
5121 -- Put the object directories in ADA_OBJECTS_PATH
5123 Prj.Env.Set_Ada_Paths (Main_Project, False);
5125 -- Check for attributes Linker'Linker_Options in projects
5126 -- other than the main project
5129 Linker_Package : Package_Id;
5130 Options : Variable_Value;
5135 for Index in 1 .. Projects.Last loop
5136 if Index /= Main_Project then
5139 (Name => Name_Linker,
5141 Projects.Table (Index).Decl.Packages);
5145 Attribute_Or_Array_Name => Name_Linker_Options,
5146 In_Package => Linker_Package);
5148 -- If attribute is present, add the project with
5149 -- the attribute to table Linker_Opts.
5151 if Options /= Nil_Variable_Value then
5152 Linker_Opts.Increment_Last;
5153 Linker_Opts.Table (Linker_Opts.Last) :=
5154 (Project => Index, Options => Options.Values);
5161 Opt1 : Linker_Options_Data;
5162 Opt2 : Linker_Options_Data;
5164 Options : String_List_Id;
5167 -- Sort the project by increasing depths
5169 for Index in 1 .. Linker_Opts.Last loop
5170 Opt1 := Linker_Opts.Table (Index);
5171 Depth := Projects.Table (Opt1.Project).Depth;
5173 for J in Index + 1 .. Linker_Opts.Last loop
5174 Opt2 := Linker_Opts.Table (J);
5177 Projects.Table (Opt2.Project).Depth < Depth
5179 Linker_Opts.Table (Index) := Opt2;
5180 Linker_Opts.Table (J) := Opt1;
5183 Projects.Table (Opt1.Project).Depth;
5187 -- If Dir_Path has not been computed for this project,
5190 if Projects.Table (Opt1.Project).Dir_Path = null then
5191 Projects.Table (Opt1.Project).Dir_Path :=
5194 (Projects.Table (Opt1.Project). Directory));
5197 Options := Opt1.Options;
5199 -- Add each of the options to the linker switches
5201 while Options /= Nil_String loop
5202 Option := String_Elements.Table (Options).Value;
5203 Options := String_Elements.Table (Options).Next;
5204 Linker_Switches.Increment_Last;
5205 Linker_Switches.Table (Linker_Switches.Last) :=
5206 new String'(Get_Name_String (Option));
5208 -- Object files and -L switches specified with
5209 -- relative paths and must be converted to
5212 Test_If_Relative_Path
5214 Linker_Switches.Table (Linker_Switches.Last),
5215 Parent => Projects.Table (Opt1.Project).Dir_Path,
5216 Including_L_Switch => True);
5223 Args : Argument_List
5224 (Linker_Switches.First .. Linker_Switches.Last + 2);
5226 Last_Arg : Integer := Linker_Switches.First - 1;
5227 Skip : Boolean := False;
5230 -- Get all the linker switches
5232 for J in Linker_Switches.First .. Linker_Switches.Last loop
5236 elsif Non_Std_Executable
5237 and then Linker_Switches.Table (J).all = "-o"
5242 Last_Arg := Last_Arg + 1;
5243 Args (Last_Arg) := Linker_Switches.Table (J);
5247 -- If need be, add the -o switch
5249 if Non_Std_Executable then
5250 Last_Arg := Last_Arg + 1;
5251 Args (Last_Arg) := new String'("-o");
5252 Last_Arg := Last_Arg + 1;
5254 new String'(Get_Name_String (Executable));
5257 -- And invoke the linker
5260 Link (Main_ALI_File,
5261 Link_With_Shared_Libgcc.all &
5262 Args (Args'First .. Last_Arg));
5263 Successful_Links.Increment_Last;
5264 Successful_Links.Table (Successful_Links.Last) :=
5269 if Osint.Number_Of_Files = 1 or not Keep_Going then
5273 Write_Line ("*** link failed");
5274 Failed_Links.Increment_Last;
5275 Failed_Links.Table (Failed_Links.Last) :=
5281 Linker_Switches.Set_Last (Linker_Switches_Last);
5285 -- We go to here when we skip the bind and link steps.
5289 -- We go to the next main, if we did not process the last one
5291 if N_File < Osint.Number_Of_Files then
5292 Main_Source_File := Next_Main_Source;
5294 if Main_Project /= No_Project then
5296 -- Find the file name of the main unit
5299 Main_Source_File_Name : constant String :=
5300 Get_Name_String (Main_Source_File);
5302 Main_Unit_File_Name : constant String :=
5304 File_Name_Of_Library_Unit_Body
5305 (Name => Main_Source_File_Name,
5306 Project => Main_Project,
5307 Main_Project_Only =>
5308 not Unique_Compile);
5310 The_Packages : constant Package_Id :=
5311 Projects.Table (Main_Project).Decl.Packages;
5313 Binder_Package : constant Prj.Package_Id :=
5315 (Name => Name_Binder,
5316 In_Packages => The_Packages);
5318 Linker_Package : constant Prj.Package_Id :=
5320 (Name => Name_Linker,
5321 In_Packages => The_Packages);
5324 -- We fail if we cannot find the main source file
5325 -- as an immediate source of the main project file.
5327 if Main_Unit_File_Name = "" then
5328 Make_Failed ('"' & Main_Source_File_Name,
5329 """ is not a unit of project ",
5330 Project_File_Name.all & ".");
5333 -- Remove any directory information from the main
5334 -- source file name.
5337 Pos : Natural := Main_Unit_File_Name'Last;
5341 exit when Pos < Main_Unit_File_Name'First
5343 Main_Unit_File_Name (Pos) = Directory_Separator;
5347 Name_Len := Main_Unit_File_Name'Last - Pos;
5349 Name_Buffer (1 .. Name_Len) :=
5351 (Pos + 1 .. Main_Unit_File_Name'Last);
5353 Main_Source_File := Name_Find;
5357 -- We now deal with the binder and linker switches.
5358 -- If no project file is used, there is nothing to do
5359 -- because the binder and linker switches are the same
5362 -- Reset the tables Binder_Switches and Linker_Switches
5364 Binder_Switches.Set_Last (Last_Binder_Switch);
5365 Linker_Switches.Set_Last (Last_Linker_Switch);
5367 -- Add binder switches from the project file for this main,
5370 if Do_Bind_Step and Binder_Package /= No_Package then
5371 if Verbose_Mode then
5372 Write_Str ("Adding binder switches for """);
5373 Write_Str (Main_Unit_File_Name);
5378 (File_Name => Main_Unit_File_Name,
5379 The_Package => Binder_Package,
5383 -- Add linker switches from the project file for this main,
5386 if Do_Link_Step and Linker_Package /= No_Package then
5387 if Verbose_Mode then
5388 Write_Str ("Adding linker switches for""");
5389 Write_Str (Main_Unit_File_Name);
5394 (File_Name => Main_Unit_File_Name,
5395 The_Package => Linker_Package,
5399 -- As we are using a project file, for relative paths we add
5400 -- the current working directory for any relative path on
5401 -- the command line and the project directory, for any
5402 -- relative path in the project file.
5405 Dir_Path : constant String_Access :=
5406 new String'(Get_Name_String
5407 (Projects.Table (Main_Project).Directory));
5410 J in Last_Binder_Switch + 1 .. Binder_Switches.Last
5412 Test_If_Relative_Path
5413 (Binder_Switches.Table (J),
5414 Parent => Dir_Path, Including_L_Switch => False);
5418 J in Last_Linker_Switch + 1 .. Linker_Switches.Last
5420 Test_If_Relative_Path
5421 (Linker_Switches.Table (J), Parent => Dir_Path);
5425 -- We now put in the Binder_Switches and Linker_Switches
5426 -- tables, the binder and linker switches of the command
5427 -- line that have been put in the Saved_ tables.
5428 -- These switches will follow the project file switches.
5430 for J in 1 .. Saved_Binder_Switches.Last loop
5432 (Saved_Binder_Switches.Table (J),
5437 for J in 1 .. Saved_Linker_Switches.Last loop
5439 (Saved_Linker_Switches.Table (J),
5446 end loop Multiple_Main_Loop;
5448 if Failed_Links.Last > 0 then
5449 for Index in 1 .. Successful_Links.Last loop
5450 Write_Str ("Linking of """);
5451 Write_Str (Get_Name_String (Successful_Links.Table (Index)));
5452 Write_Line (""" succeeded.");
5455 for Index in 1 .. Failed_Links.Last loop
5456 Write_Str ("Linking of """);
5457 Write_Str (Get_Name_String (Failed_Links.Table (Index)));
5458 Write_Line (""" failed.");
5461 if Total_Compilation_Failures = 0 then
5462 raise Compilation_Failed;
5466 if Total_Compilation_Failures /= 0 then
5467 List_Bad_Compilations;
5468 raise Compilation_Failed;
5471 -- Delete the temporary mapping file that was created if we are
5472 -- using project files.
5474 if not Debug.Debug_Flag_N then
5475 Delete_Mapping_Files;
5476 Prj.Env.Delete_All_Path_Files;
5479 Exit_Program (E_Success);
5483 Make_Failed ("*** bind failed.");
5485 when Compilation_Failed =>
5486 if not Debug.Debug_Flag_N then
5487 Delete_Mapping_Files;
5488 Prj.Env.Delete_All_Path_Files;
5491 Exit_Program (E_Fatal);
5494 Make_Failed ("*** link failed.");
5497 Write_Line (Exception_Information (X));
5498 Make_Failed ("INTERNAL ERROR. Please report.");
5506 function Hash (F : Name_Id) return Header_Num is
5508 return Header_Num (1 + F mod Max_Header);
5511 --------------------
5512 -- In_Ada_Lib_Dir --
5513 --------------------
5515 function In_Ada_Lib_Dir (File : File_Name_Type) return Boolean is
5516 D : constant Name_Id := Get_Directory (File);
5517 B : constant Byte := Get_Name_Table_Byte (D);
5520 return (B and Ada_Lib_Dir) /= 0;
5527 procedure Inform (N : Name_Id := No_Name; Msg : String) is
5529 Osint.Write_Program_Name;
5533 if N /= No_Name then
5543 -----------------------
5544 -- Init_Mapping_File --
5545 -----------------------
5547 procedure Init_Mapping_File
5548 (Project : Project_Id;
5549 File_Index : in out Natural)
5551 FD : File_Descriptor;
5554 -- For call to Close
5557 -- Increase the index of the last mapping file for this project
5559 Last_Mapping_File_Names (Project) :=
5560 Last_Mapping_File_Names (Project) + 1;
5562 -- If there is a project file, call Create_Mapping_File with
5565 if Project /= No_Project then
5566 Prj.Env.Create_Mapping_File
5568 The_Mapping_File_Names
5569 (Project, Last_Mapping_File_Names (Project)));
5571 -- Otherwise, just create an empty file
5574 Tempdir.Create_Temp_File
5576 The_Mapping_File_Names
5577 (No_Project, Last_Mapping_File_Names (No_Project)));
5578 if FD = Invalid_FD then
5579 Make_Failed ("disk full");
5585 Make_Failed ("disk full");
5589 -- And return the index of the newly created file
5591 File_Index := Last_Mapping_File_Names (Project);
5592 end Init_Mapping_File;
5600 First_Q_Initialization := False;
5602 Q.Set_Last (Q.First);
5609 procedure Initialize is
5610 Next_Arg : Positive;
5613 -- Override default initialization of Check_Object_Consistency
5614 -- since this is normally False for GNATBIND, but is True for
5615 -- GNATMAKE since we do not need to check source consistency
5616 -- again once GNATMAKE has looked at the sources to check.
5618 Check_Object_Consistency := True;
5620 -- Package initializations. The order of calls is important here.
5622 Output.Set_Standard_Error;
5625 Binder_Switches.Init;
5626 Linker_Switches.Init;
5637 RTS_Specified := null;
5642 Scan_Args : while Next_Arg <= Argument_Count loop
5643 Scan_Make_Arg (Argument (Next_Arg), And_Save => True);
5644 Next_Arg := Next_Arg + 1;
5647 if Usage_Requested then
5651 -- Test for trailing -P switch
5653 if Project_File_Name_Present and then Project_File_Name = null then
5654 Make_Failed ("project file name missing after -P");
5656 -- Test for trailing -o switch
5658 elsif Output_File_Name_Present
5659 and then not Output_File_Name_Seen
5661 Make_Failed ("output file name missing after -o");
5663 -- Test for trailing -D switch
5665 elsif Object_Directory_Present
5666 and then not Object_Directory_Seen then
5667 Make_Failed ("object directory missing after -D");
5670 -- Test for simultaneity of -i and -D
5672 if Object_Directory_Path /= null and then In_Place_Mode then
5673 Make_Failed ("-i and -D cannot be used simutaneously");
5676 -- Deal with -C= switch
5678 if Gnatmake_Mapping_File /= null then
5679 -- First, check compatibility with other switches
5681 if Project_File_Name /= null then
5682 Make_Failed ("-C= switch is not compatible with -P switch");
5684 elsif Saved_Maximum_Processes > 1 then
5685 Make_Failed ("-C= switch is not compatible with -jnnn switch");
5688 Fmap.Initialize (Gnatmake_Mapping_File.all);
5690 ("-gnatem=" & Gnatmake_Mapping_File.all,
5695 if Project_File_Name /= null then
5697 -- A project file was specified by a -P switch
5699 if Verbose_Mode then
5701 Write_Str ("Parsing Project File """);
5702 Write_Str (Project_File_Name.all);
5707 -- Avoid looking in the current directory for ALI files
5709 -- Look_In_Primary_Dir := False;
5711 -- Set the project parsing verbosity to whatever was specified
5712 -- by a possible -vP switch.
5714 Prj.Pars.Set_Verbosity (To => Current_Verbosity);
5716 -- Parse the project file.
5717 -- If there is an error, Main_Project will still be No_Project.
5720 (Project => Main_Project,
5721 Project_File_Name => Project_File_Name.all,
5722 Packages_To_Check => Packages_To_Check_By_Gnatmake);
5724 if Main_Project = No_Project then
5725 Make_Failed ("""", Project_File_Name.all, """ processing failed");
5728 if Verbose_Mode then
5730 Write_Str ("Parsing of Project File """);
5731 Write_Str (Project_File_Name.all);
5732 Write_Str (""" is finished.");
5736 -- We add the source directories and the object directories
5737 -- to the search paths.
5739 Add_Source_Directories (Main_Project);
5740 Add_Object_Directories (Main_Project);
5742 -- Compute depth of each project
5744 Recursive_Compute_Depth
5745 (Main_Project, Visited => No_Projects, Depth => 0);
5749 Osint.Add_Default_Search_Dirs;
5751 -- Source file lookups should be cached for efficiency.
5752 -- Source files are not supposed to change. However, we do that now
5753 -- only if no project file is used; if a project file is used, we
5754 -- do it just after changing the directory to the object directory.
5756 Osint.Source_File_Data (Cache => True);
5758 -- Read gnat.adc file to initialize Fname.UF
5760 Fname.UF.Initialize;
5763 Fname.SF.Read_Source_File_Name_Pragmas;
5766 when Err : SFN_Scan.Syntax_Error_In_GNAT_ADC =>
5767 Make_Failed (Exception_Message (Err));
5771 -- Make sure no project object directory is recorded
5773 Project_Object_Directory := No_Project;
5775 -- Set the marking label to a value that is not zero
5780 -----------------------------------
5781 -- Insert_Project_Sources_Into_Q --
5782 -----------------------------------
5784 procedure Insert_Project_Sources
5785 (The_Project : Project_Id;
5786 All_Projects : Boolean;
5789 Put_In_Q : Boolean := Into_Q;
5790 Unit : Com.Unit_Data;
5793 Extending : constant Boolean :=
5794 Projects.Table (The_Project).Extends /= No_Project;
5796 function Check_Project (P : Project_Id) return Boolean;
5797 -- Returns True if P is The_Project or a project extended by
5804 function Check_Project (P : Project_Id) return Boolean is
5806 if All_Projects or P = The_Project then
5808 elsif Extending then
5810 Data : Project_Data := Projects.Table (The_Project);
5814 if P = Data.Extends then
5818 Data := Projects.Table (Data.Extends);
5819 exit when Data.Extends = No_Project;
5827 -- Start of processing of Insert_Project_Sources
5830 -- For all the sources in the project files,
5832 for Id in Com.Units.First .. Com.Units.Last loop
5833 Unit := Com.Units.Table (Id);
5836 -- If there is a source for the body, and the body has not been
5839 if Unit.File_Names (Com.Body_Part).Name /= No_Name
5840 and then Unit.File_Names (Com.Body_Part).Path /= Slash
5843 -- And it is a source for the specified project
5845 if Check_Project (Unit.File_Names (Com.Body_Part).Project) then
5847 -- If we don't have a spec, we cannot consider the source
5848 -- if it is a subunit
5850 if Unit.File_Names (Com.Specification).Name = No_Name then
5852 Src_Ind : Source_File_Index;
5854 -- Here we are cheating a little bit: we don't want to
5855 -- use Sinput.L, because it depends on the GNAT tree
5856 -- (Atree, Sinfo, ...). So, we pretend that it is
5857 -- a project file, and we use Sinput.P.
5858 -- Source_File_Is_Subunit is just scanning through
5859 -- the file until it finds one of the reserved words
5860 -- separate, procedure, function, generic or package.
5861 -- Fortunately, these Ada reserved words are also
5862 -- reserved for project files.
5865 Src_Ind := Sinput.P.Load_Project_File
5867 (Unit.File_Names (Com.Body_Part).Path));
5869 -- If it is a subunit, discard it
5871 if Sinput.P.Source_File_Is_Subunit (Src_Ind) then
5875 Sfile := Unit.File_Names (Com.Body_Part).Name;
5880 Sfile := Unit.File_Names (Com.Body_Part).Name;
5884 elsif Unit.File_Names (Com.Specification).Name /= No_Name
5885 and then Unit.File_Names (Com.Specification).Path /= Slash
5886 and then Check_Project (Unit.File_Names (Com.Specification).Project)
5888 -- If there is no source for the body, but there is a source
5889 -- for the spec which has not been locally removed, then we take
5892 Sfile := Unit.File_Names (Com.Specification).Name;
5895 -- If Put_In_Q is True, we insert into the Q
5899 -- For the first source inserted into the Q, we need
5900 -- to initialize the Q, but not for the subsequent sources.
5902 if First_Q_Initialization then
5906 -- And of course, we only insert in the Q if the source
5909 if Sfile /= No_Name and then not Is_Marked (Sfile) then
5910 if Verbose_Mode then
5911 Write_Str ("Adding """);
5912 Write_Str (Get_Name_String (Sfile));
5913 Write_Line (""" to the queue");
5920 elsif Sfile /= No_Name then
5922 -- If Put_In_Q is False, we add the source as it it were
5923 -- specified on the command line, and we set Put_In_Q to True,
5924 -- so that the following sources will be put directly in the
5925 -- queue. This will allow parallel compilation processes if -jx
5928 if Verbose_Mode then
5929 Write_Str ("Adding """);
5930 Write_Str (Get_Name_String (Sfile));
5931 Write_Line (""" as if on the command line");
5934 Osint.Add_File (Get_Name_String (Sfile));
5938 end Insert_Project_Sources;
5945 (Source_File : File_Name_Type;
5946 Source_Unit : Unit_Name_Type := No_Name)
5949 if Debug.Debug_Flag_Q then
5950 Write_Str (" Q := Q + [ ");
5951 Write_Name (Source_File);
5956 Q.Table (Q.Last).File := Source_File;
5957 Q.Table (Q.Last).Unit := Source_Unit;
5961 ----------------------------
5962 -- Is_External_Assignment --
5963 ----------------------------
5965 function Is_External_Assignment (Argv : String) return Boolean is
5966 Start : Positive := 3;
5967 Finish : Natural := Argv'Last;
5968 Equal_Pos : Natural;
5971 if Argv'Last < 5 then
5974 elsif Argv (3) = '"' then
5975 if Argv (Argv'Last) /= '"' or else Argv'Last < 7 then
5979 Finish := Argv'Last - 1;
5985 while Equal_Pos <= Finish and then Argv (Equal_Pos) /= '=' loop
5986 Equal_Pos := Equal_Pos + 1;
5989 if Equal_Pos = Start
5990 or else Equal_Pos >= Finish
5996 (External_Name => Argv (Start .. Equal_Pos - 1),
5997 Value => Argv (Equal_Pos + 1 .. Finish));
6000 end Is_External_Assignment;
6002 ---------------------
6003 -- Is_In_Obsoleted --
6004 ---------------------
6006 function Is_In_Obsoleted (F : Name_Id) return Boolean is
6013 Name : constant String := Get_Name_String (F);
6014 First : Natural := Name'Last;
6018 while First > Name'First
6019 and then Name (First - 1) /= Directory_Separator
6020 and then Name (First - 1) /= '/'
6025 if First /= Name'First then
6027 Add_Str_To_Name_Buffer (Name (First .. Name'Last));
6031 return Obsoleted.Get (F2);
6034 end Is_In_Obsoleted;
6036 ----------------------------
6037 -- Is_In_Object_Directory --
6038 ----------------------------
6040 function Is_In_Object_Directory
6041 (Source_File : File_Name_Type;
6042 Full_Lib_File : File_Name_Type) return Boolean
6045 -- There is something to check only when using project files.
6046 -- Otherwise, this function returns True (last line of the function).
6048 if Main_Project /= No_Project then
6050 Source_File_Name : constant String :=
6051 Get_Name_String (Source_File);
6052 Saved_Verbosity : constant Verbosity := Prj.Com.Current_Verbosity;
6053 Project : Project_Id := No_Project;
6054 Path_Name : Name_Id := No_Name;
6055 Data : Project_Data;
6058 -- Call Get_Reference to know the ultimate extending project of
6059 -- the source. Call it with verbosity default to avoid verbose
6062 Prj.Com.Current_Verbosity := Default;
6065 (Source_File_Name => Source_File_Name,
6068 Prj.Com.Current_Verbosity := Saved_Verbosity;
6070 -- If this source is in a project, check that the ALI file is
6071 -- in its object directory. If it is not, return False, so that
6072 -- the ALI file will not be skipped.
6074 -- If the source is not in an extending project, we fall back to
6075 -- the general case and return True at the end of the function.
6077 if Project /= No_Project
6078 and then Projects.Table (Project).Extends /= No_Project
6080 Data := Projects.Table (Project);
6083 Object_Directory : constant String :=
6086 (Data.Object_Directory));
6088 Olast : Natural := Object_Directory'Last;
6090 Lib_File_Directory : constant String :=
6091 Normalize_Pathname (Dir_Name
6092 (Get_Name_String (Full_Lib_File)));
6094 Llast : Natural := Lib_File_Directory'Last;
6097 -- For directories, Normalize_Pathname may or may not put
6098 -- a directory separator at the end, depending on its input.
6099 -- Remove any last directory separator before comparaison.
6100 -- Returns True only if the two directories are the same.
6102 if Object_Directory (Olast) = Directory_Separator then
6106 if Lib_File_Directory (Llast) = Directory_Separator then
6110 return Object_Directory (Object_Directory'First .. Olast) =
6111 Lib_File_Directory (Lib_File_Directory'First .. Llast);
6117 -- When the source is not in a project file, always return True
6120 end Is_In_Object_Directory;
6126 function Is_Marked (Source_File : File_Name_Type) return Boolean is
6128 return Get_Name_Table_Byte (Source_File) = Marking_Label;
6135 procedure Link (ALI_File : File_Name_Type; Args : Argument_List) is
6136 Link_Args : Argument_List (1 .. Args'Length + 1);
6140 Get_Name_String (ALI_File);
6141 Link_Args (1) := new String'(Name_Buffer (1 .. Name_Len));
6143 Link_Args (2 .. Args'Length + 1) := Args;
6145 GNAT.OS_Lib.Normalize_Arguments (Link_Args);
6147 Display (Gnatlink.all, Link_Args);
6149 if Gnatlink_Path = null then
6150 Make_Failed ("error, unable to locate ", Gnatlink.all);
6153 GNAT.OS_Lib.Spawn (Gnatlink_Path.all, Link_Args, Success);
6160 ---------------------------
6161 -- List_Bad_Compilations --
6162 ---------------------------
6164 procedure List_Bad_Compilations is
6166 for J in Bad_Compilation.First .. Bad_Compilation.Last loop
6167 if Bad_Compilation.Table (J).File = No_File then
6169 elsif not Bad_Compilation.Table (J).Found then
6170 Inform (Bad_Compilation.Table (J).File, "not found");
6172 Inform (Bad_Compilation.Table (J).File, "compilation error");
6175 end List_Bad_Compilations;
6181 procedure List_Depend is
6188 Line_Size : constant := 77;
6191 Set_Standard_Output;
6193 for A in ALIs.First .. ALIs.Last loop
6194 Lib_Name := ALIs.Table (A).Afile;
6196 -- We have to provide the full library file name in In_Place_Mode
6198 if In_Place_Mode then
6199 Lib_Name := Full_Lib_File_Name (Lib_Name);
6202 Obj_Name := Object_File_Name (Lib_Name);
6203 Write_Name (Obj_Name);
6206 Get_Name_String (Obj_Name);
6208 Line_Pos := Len + 2;
6210 for D in ALIs.Table (A).First_Sdep .. ALIs.Table (A).Last_Sdep loop
6211 Src_Name := Sdep.Table (D).Sfile;
6213 if Is_Internal_File_Name (Src_Name)
6214 and then not Check_Readonly_Files
6218 if not Quiet_Output then
6219 Src_Name := Full_Source_Name (Src_Name);
6222 Get_Name_String (Src_Name);
6225 if Line_Pos + Len + 1 > Line_Size then
6231 Line_Pos := Line_Pos + Len + 1;
6234 Write_Name (Src_Name);
6248 package body Mains is
6250 package Names is new Table.Table
6251 (Table_Component_Type => File_Name_Type,
6252 Table_Index_Type => Integer,
6253 Table_Low_Bound => 1,
6254 Table_Initial => 10,
6255 Table_Increment => 100,
6256 Table_Name => "Make.Mains.Names");
6257 -- The table that stores the main
6259 Current : Natural := 0;
6260 -- The index of the last main retrieved from the table
6266 procedure Add_Main (Name : String) is
6269 Add_Str_To_Name_Buffer (Name);
6270 Names.Increment_Last;
6271 Names.Table (Names.Last) := Name_Find;
6288 function Next_Main return String is
6290 if Current >= Names.Last then
6294 Current := Current + 1;
6295 return Get_Name_String (Names.Table (Current));
6310 procedure Mark (Source_File : File_Name_Type) is
6312 Set_Name_Table_Byte (Source_File, Marking_Label);
6315 --------------------
6316 -- Mark_Directory --
6317 --------------------
6319 procedure Mark_Directory
6321 Mark : Lib_Mark_Type)
6327 -- Dir last character is supposed to be a directory separator.
6329 Name_Len := Dir'Length;
6330 Name_Buffer (1 .. Name_Len) := Dir;
6332 if not Is_Directory_Separator (Name_Buffer (Name_Len)) then
6333 Name_Len := Name_Len + 1;
6334 Name_Buffer (Name_Len) := Directory_Separator;
6337 -- Add flags to the already existing flags
6340 B := Get_Name_Table_Byte (N);
6341 Set_Name_Table_Byte (N, B or Mark);
6344 -----------------------------
6345 -- Recursive_Compute_Depth --
6346 -----------------------------
6348 procedure Recursive_Compute_Depth
6349 (Project : Project_Id;
6350 Visited : Project_Array;
6353 List : Project_List;
6356 New_Visited : constant Project_Array := Visited & Project;
6359 -- Nothing to do if there is no project
6361 if Project = No_Project then
6365 -- If current depth of project is lower than Depth, adjust it
6367 if Projects.Table (Project).Depth < Depth then
6368 Projects.Table (Project).Depth := Depth;
6371 List := Projects.Table (Project).Imported_Projects;
6373 -- Visit each imported project
6375 while List /= Empty_Project_List loop
6376 Proj := Project_Lists.Table (List).Project;
6377 List := Project_Lists.Table (List).Next;
6381 -- To avoid endless loops due to cycles with limited widts,
6382 -- do not revisit a project that is already in the chain of imports
6383 -- that brought us here.
6385 for J in Visited'Range loop
6386 if Visited (J) = Proj then
6393 Recursive_Compute_Depth
6395 Visited => New_Visited,
6396 Depth => Depth + 1);
6400 -- Visit a project being extended, if any
6402 Recursive_Compute_Depth
6403 (Project => Projects.Table (Project).Extends,
6404 Visited => New_Visited,
6405 Depth => Depth + 1);
6406 end Recursive_Compute_Depth;
6408 -----------------------
6409 -- Sigint_Intercpted --
6410 -----------------------
6412 procedure Sigint_Intercepted is
6414 Write_Line ("*** Interrupted ***");
6415 Delete_All_Temp_Files;
6417 end Sigint_Intercepted;
6423 procedure Scan_Make_Arg (Argv : String; And_Save : Boolean) is
6425 pragma Assert (Argv'First = 1);
6427 if Argv'Length = 0 then
6431 -- If the previous switch has set the Project_File_Name_Present
6432 -- flag (that is we have seen a -P alone), then the next argument is
6433 -- the name of the project file.
6435 if Project_File_Name_Present and then Project_File_Name = null then
6436 if Argv (1) = '-' then
6437 Make_Failed ("project file name missing after -P");
6440 Project_File_Name_Present := False;
6441 Project_File_Name := new String'(Argv);
6444 -- If the previous switch has set the Output_File_Name_Present
6445 -- flag (that is we have seen a -o), then the next argument is
6446 -- the name of the output executable.
6448 elsif Output_File_Name_Present
6449 and then not Output_File_Name_Seen
6451 Output_File_Name_Seen := True;
6453 if Argv (1) = '-' then
6454 Make_Failed ("output file name missing after -o");
6457 Add_Switch ("-o", Linker, And_Save => And_Save);
6459 -- Automatically add the executable suffix if it has not been
6460 -- specified explicitly.
6463 Canonical_Argv : String := Argv;
6465 -- Get the file name in canonical case to accept as is
6466 -- names ending with ".EXE" on VMS and Windows.
6468 Canonical_Case_File_Name (Canonical_Argv);
6470 if Executable_Suffix'Length /= 0
6471 and then (Canonical_Argv'Length <= Executable_Suffix'Length
6472 or else Canonical_Argv
6473 (Canonical_Argv'Last -
6474 Executable_Suffix'Length + 1
6475 .. Canonical_Argv'Last)
6476 /= Executable_Suffix)
6479 (Argv & Executable_Suffix,
6481 And_Save => And_Save);
6483 Add_Switch (Argv, Linker, And_Save => And_Save);
6488 -- If the previous switch has set the Object_Directory_Present flag
6489 -- (that is we have seen a -D), then the next argument is
6490 -- the path name of the object directory..
6492 elsif Object_Directory_Present
6493 and then not Object_Directory_Seen
6495 Object_Directory_Seen := True;
6497 if Argv (1) = '-' then
6498 Make_Failed ("object directory path name missing after -D");
6500 elsif not Is_Directory (Argv) then
6501 Make_Failed ("cannot find object directory """, Argv, """");
6504 Add_Lib_Search_Dir (Argv);
6506 -- Specify the object directory to the binder
6508 Add_Switch ("-aO" & Argv, Binder, And_Save => And_Save);
6510 -- Record the object directory. Make sure it ends with a directory
6513 if Argv (Argv'Last) = Directory_Separator then
6514 Object_Directory_Path := new String'(Argv);
6517 Object_Directory_Path :=
6518 new String'(Argv & Directory_Separator);
6522 -- Then check if we are dealing with -cargs/-bargs/-largs/-margs
6524 elsif Argv = "-bargs"
6533 when 'c' => Program_Args := Compiler;
6534 when 'b' => Program_Args := Binder;
6535 when 'l' => Program_Args := Linker;
6536 when 'm' => Program_Args := None;
6539 raise Program_Error;
6542 -- A special test is needed for the -o switch within a -largs
6543 -- since that is another way to specify the name of the final
6546 elsif Program_Args = Linker
6547 and then Argv = "-o"
6549 Make_Failed ("switch -o not allowed within a -largs. " &
6550 "Use -o directly.");
6552 -- Check to see if we are reading switches after a -cargs,
6553 -- -bargs or -largs switch. If yes save it.
6555 elsif Program_Args /= None then
6557 -- Check to see if we are reading -I switches in order
6558 -- to take into account in the src & lib search directories.
6560 if Argv'Length > 2 and then Argv (1 .. 2) = "-I" then
6561 if Argv (3 .. Argv'Last) = "-" then
6562 Look_In_Primary_Dir := False;
6564 elsif Program_Args = Compiler then
6565 if Argv (3 .. Argv'Last) /= "-" then
6566 Add_Src_Search_Dir (Argv (3 .. Argv'Last));
6569 elsif Program_Args = Binder then
6570 Add_Lib_Search_Dir (Argv (3 .. Argv'Last));
6574 Add_Switch (Argv, Program_Args, And_Save => And_Save);
6576 -- Handle non-default compiler, binder, linker, and handle --RTS switch
6578 elsif Argv'Length > 2 and then Argv (1 .. 2) = "--" then
6580 and then Argv (1 .. 6) = "--GCC="
6583 Program_Args : constant Argument_List_Access :=
6584 Argument_String_To_List
6585 (Argv (7 .. Argv'Last));
6589 Saved_Gcc := new String'(Program_Args.all (1).all);
6591 Gcc := new String'(Program_Args.all (1).all);
6594 for J in 2 .. Program_Args.all'Last loop
6596 (Program_Args.all (J).all,
6598 And_Save => And_Save);
6602 elsif Argv'Length > 11
6603 and then Argv (1 .. 11) = "--GNATBIND="
6606 Program_Args : constant Argument_List_Access :=
6607 Argument_String_To_List
6608 (Argv (12 .. Argv'Last));
6612 Saved_Gnatbind := new String'(Program_Args.all (1).all);
6614 Gnatbind := new String'(Program_Args.all (1).all);
6617 for J in 2 .. Program_Args.all'Last loop
6619 (Program_Args.all (J).all, Binder, And_Save => And_Save);
6623 elsif Argv'Length > 11
6624 and then Argv (1 .. 11) = "--GNATLINK="
6627 Program_Args : constant Argument_List_Access :=
6628 Argument_String_To_List
6629 (Argv (12 .. Argv'Last));
6632 Saved_Gnatlink := new String'(Program_Args.all (1).all);
6634 Gnatlink := new String'(Program_Args.all (1).all);
6637 for J in 2 .. Program_Args.all'Last loop
6638 Add_Switch (Program_Args.all (J).all, Linker);
6642 elsif Argv'Length >= 5 and then
6643 Argv (1 .. 5) = "--RTS"
6645 Add_Switch (Argv, Compiler, And_Save => And_Save);
6646 Add_Switch (Argv, Binder, And_Save => And_Save);
6648 if Argv'Length <= 6 or else Argv (6) /= '=' then
6649 Make_Failed ("missing path for --RTS");
6652 -- Check that this is the first time we see this switch or
6653 -- if it is not the first time, the same path is specified.
6655 if RTS_Specified = null then
6656 RTS_Specified := new String'(Argv (7 .. Argv'Last));
6658 elsif RTS_Specified.all /= Argv (7 .. Argv'Last) then
6659 Make_Failed ("--RTS cannot be specified multiple times");
6662 -- Valid --RTS switch
6669 Src_Path_Name : constant String_Ptr :=
6671 (Argv (7 .. Argv'Last), Include);
6673 Lib_Path_Name : constant String_Ptr :=
6675 (Argv (7 .. Argv'Last), Objects);
6678 if Src_Path_Name /= null and then
6679 Lib_Path_Name /= null
6681 -- Set the RTS_*_Path_Name variables, so that the correct
6682 -- directories will be set when
6683 -- Osint.Add_Default_Search_Dirs will be called later.
6685 RTS_Src_Path_Name := Src_Path_Name;
6686 RTS_Lib_Path_Name := Lib_Path_Name;
6688 elsif Src_Path_Name = null
6689 and Lib_Path_Name = null then
6690 Make_Failed ("RTS path not valid: missing " &
6691 "adainclude and adalib directories");
6693 elsif Src_Path_Name = null then
6694 Make_Failed ("RTS path not valid: missing adainclude " &
6697 elsif Lib_Path_Name = null then
6698 Make_Failed ("RTS path not valid: missing adalib " &
6705 Make_Failed ("unknown switch: ", Argv);
6708 -- If we have seen a regular switch process it
6710 elsif Argv (1) = '-' then
6712 if Argv'Length = 1 then
6713 Make_Failed ("switch character cannot be followed by a blank");
6717 elsif Argv (2 .. Argv'Last) = "I-" then
6718 Look_In_Primary_Dir := False;
6720 -- Forbid -?- or -??- where ? is any character
6722 elsif (Argv'Length = 3 and then Argv (3) = '-')
6723 or else (Argv'Length = 4 and then Argv (4) = '-')
6725 Make_Failed ("trailing ""-"" at the end of ", Argv, " forbidden.");
6729 elsif Argv (2) = 'I' then
6730 Add_Src_Search_Dir (Argv (3 .. Argv'Last));
6731 Add_Lib_Search_Dir (Argv (3 .. Argv'Last));
6732 Add_Switch (Argv, Compiler, And_Save => And_Save);
6733 Add_Switch (Argv, Binder, And_Save => And_Save);
6735 -- -aIdir (to gcc this is like a -I switch)
6737 elsif Argv'Length >= 3 and then Argv (2 .. 3) = "aI" then
6738 Add_Src_Search_Dir (Argv (4 .. Argv'Last));
6739 Add_Switch ("-I" & Argv (4 .. Argv'Last),
6741 And_Save => And_Save);
6742 Add_Switch (Argv, Binder, And_Save => And_Save);
6746 elsif Argv'Length >= 3 and then Argv (2 .. 3) = "aO" then
6747 Add_Lib_Search_Dir (Argv (4 .. Argv'Last));
6748 Add_Switch (Argv, Binder, And_Save => And_Save);
6750 -- -aLdir (to gnatbind this is like a -aO switch)
6752 elsif Argv'Length >= 3 and then Argv (2 .. 3) = "aL" then
6753 Mark_Directory (Argv (4 .. Argv'Last), Ada_Lib_Dir);
6754 Add_Lib_Search_Dir (Argv (4 .. Argv'Last));
6755 Add_Switch ("-aO" & Argv (4 .. Argv'Last),
6757 And_Save => And_Save);
6759 -- -Adir (to gnatbind this is like a -aO switch, to gcc like a -I)
6761 elsif Argv (2) = 'A' then
6762 Mark_Directory (Argv (3 .. Argv'Last), Ada_Lib_Dir);
6763 Add_Src_Search_Dir (Argv (3 .. Argv'Last));
6764 Add_Lib_Search_Dir (Argv (3 .. Argv'Last));
6765 Add_Switch ("-I" & Argv (3 .. Argv'Last),
6767 And_Save => And_Save);
6768 Add_Switch ("-aO" & Argv (3 .. Argv'Last),
6770 And_Save => And_Save);
6774 elsif Argv (2) = 'L' then
6775 Add_Switch (Argv, Linker, And_Save => And_Save);
6777 -- For -gxxxxx,-pg,-mxxx: give the switch to both the compiler and
6778 -- the linker (except for -gnatxxx which is only for the compiler)
6781 (Argv (2) = 'g' and then (Argv'Last < 5
6782 or else Argv (2 .. 5) /= "gnat"))
6783 or else Argv (2 .. Argv'Last) = "pg"
6784 or else (Argv (2) = 'm' and then Argv'Last > 2)
6786 Add_Switch (Argv, Compiler, And_Save => And_Save);
6787 Add_Switch (Argv, Linker, And_Save => And_Save);
6789 -- -C=<mapping file>
6791 elsif Argv'Last > 2 and then Argv (2) = 'C' then
6793 if Argv (3) /= '=' or else Argv'Last <= 3 then
6794 Make_Failed ("illegal switch ", Argv);
6797 Gnatmake_Mapping_File := new String'(Argv (4 .. Argv'Last));
6802 elsif Argv'Last = 2 and then Argv (2) = 'D' then
6803 if Project_File_Name /= null then
6804 Make_Failed ("-D cannot be used in conjunction with a " &
6808 Scan_Make_Switches (Argv);
6813 elsif Argv (2) = 'd'
6814 and then Argv'Last = 2
6816 Display_Compilation_Progress := True;
6820 elsif Argv'Last = 2 and then Argv (2) = 'i' then
6821 if Project_File_Name /= null then
6822 Make_Failed ("-i cannot be used in conjunction with a " &
6826 Scan_Make_Switches (Argv);
6829 -- -j (need to save the result)
6831 elsif Argv (2) = 'j' then
6832 Scan_Make_Switches (Argv);
6835 Saved_Maximum_Processes := Maximum_Processes;
6840 elsif Argv (2) = 'm'
6841 and then Argv'Last = 2
6843 Minimal_Recompilation := True;
6847 elsif Argv (2) = 'u'
6848 and then Argv'Last = 2
6850 Unique_Compile := True;
6851 Compile_Only := True;
6852 Do_Bind_Step := False;
6853 Do_Link_Step := False;
6857 elsif Argv (2) = 'U'
6858 and then Argv'Last = 2
6860 Unique_Compile_All_Projects := True;
6861 Unique_Compile := True;
6862 Compile_Only := True;
6863 Do_Bind_Step := False;
6864 Do_Link_Step := False;
6866 -- -Pprj or -P prj (only once, and only on the command line)
6868 elsif Argv (2) = 'P' then
6869 if Project_File_Name /= null then
6870 Make_Failed ("cannot have several project files specified");
6872 elsif Object_Directory_Path /= null then
6873 Make_Failed ("-D cannot be used in conjunction with a " &
6876 elsif In_Place_Mode then
6877 Make_Failed ("-i cannot be used in conjunction with a " &
6880 elsif not And_Save then
6882 -- It could be a tool other than gnatmake (i.e, gnatdist)
6883 -- or a -P switch inside a project file.
6886 ("either the tool is not ""project-aware"" or " &
6887 "a project file is specified inside a project file");
6889 elsif Argv'Last = 2 then
6891 -- -P is used alone: the project file name is the next option
6893 Project_File_Name_Present := True;
6896 Project_File_Name := new String'(Argv (3 .. Argv'Last));
6899 -- -vPx (verbosity of the parsing of the project files)
6902 and then Argv (2 .. 3) = "vP"
6903 and then Argv (4) in '0' .. '2'
6908 Current_Verbosity := Prj.Default;
6910 Current_Verbosity := Prj.Medium;
6912 Current_Verbosity := Prj.High;
6918 -- -Xext=val (External assignment)
6920 elsif Argv (2) = 'X'
6921 and then Is_External_Assignment (Argv)
6923 -- Is_External_Assignment has side effects
6924 -- when it returns True;
6928 -- If -gnath is present, then generate the usage information
6929 -- right now and do not pass this option on to the compiler calls.
6931 elsif Argv = "-gnath" then
6934 -- If -gnatc is specified, make sure the bind step and the link
6935 -- step are not executed.
6937 elsif Argv'Length >= 6 and then Argv (2 .. 6) = "gnatc" then
6939 -- If -gnatc is specified, make sure the bind step and the link
6940 -- step are not executed.
6942 Add_Switch (Argv, Compiler, And_Save => And_Save);
6943 Operating_Mode := Check_Semantics;
6944 Check_Object_Consistency := False;
6945 Compile_Only := True;
6946 Do_Bind_Step := False;
6947 Do_Link_Step := False;
6949 elsif Argv (2 .. Argv'Last) = "nostdlib" then
6951 -- Don't pass -nostdlib to gnatlink, it will disable
6952 -- linking with all standard library files.
6956 Add_Switch (Argv, Compiler, And_Save => And_Save);
6957 Add_Switch (Argv, Binder, And_Save => And_Save);
6959 elsif Argv (2 .. Argv'Last) = "nostdinc" then
6961 -- Pass -nostdinc to the Compiler and to gnatbind
6964 Add_Switch (Argv, Compiler, And_Save => And_Save);
6965 Add_Switch (Argv, Binder, And_Save => And_Save);
6967 -- By default all switches with more than one character
6968 -- or one character switches which are not in 'a' .. 'z'
6969 -- (except 'C', 'F', 'M' and 'B') are passed to the compiler,
6970 -- unless we are dealing with a debug switch (starts with 'd')
6972 elsif Argv (2) /= 'd'
6973 and then Argv (2 .. Argv'Last) /= "C"
6974 and then Argv (2 .. Argv'Last) /= "F"
6975 and then Argv (2 .. Argv'Last) /= "M"
6976 and then Argv (2 .. Argv'Last) /= "B"
6977 and then (Argv'Length > 2 or else Argv (2) not in 'a' .. 'z')
6979 Add_Switch (Argv, Compiler, And_Save => And_Save);
6981 -- All other options are handled by Scan_Make_Switches
6984 Scan_Make_Switches (Argv);
6987 -- If not a switch it must be a file name
6991 Mains.Add_Main (Argv);
6999 function Switches_Of
7000 (Source_File : Name_Id;
7001 Source_File_Name : String;
7002 Naming : Naming_Data;
7003 In_Package : Package_Id;
7004 Allow_ALI : Boolean) return Variable_Value
7006 Switches : Variable_Value;
7008 Defaults : constant Array_Element_Id :=
7010 (Name => Name_Default_Switches,
7012 Packages.Table (In_Package).Decl.Arrays);
7014 Switches_Array : constant Array_Element_Id :=
7016 (Name => Name_Switches,
7018 Packages.Table (In_Package).Decl.Arrays);
7023 (Index => Source_File,
7024 In_Array => Switches_Array);
7026 if Switches = Nil_Variable_Value then
7028 Name : String (1 .. Source_File_Name'Length + 3);
7029 Last : Positive := Source_File_Name'Length;
7030 Spec_Suffix : constant String :=
7031 Get_Name_String (Naming.Current_Spec_Suffix);
7032 Body_Suffix : constant String :=
7033 Get_Name_String (Naming.Current_Body_Suffix);
7034 Truncated : Boolean := False;
7037 Name (1 .. Last) := Source_File_Name;
7039 if Last > Body_Suffix'Length
7040 and then Name (Last - Body_Suffix'Length + 1 .. Last) =
7044 Last := Last - Body_Suffix'Length;
7048 and then Last > Spec_Suffix'Length
7049 and then Name (Last - Spec_Suffix'Length + 1 .. Last) =
7053 Last := Last - Spec_Suffix'Length;
7058 Name_Buffer (1 .. Name_Len) := Name (1 .. Last);
7061 (Index => Name_Find,
7062 In_Array => Switches_Array);
7064 if Switches = Nil_Variable_Value
7067 Last := Source_File_Name'Length;
7069 while Name (Last) /= '.' loop
7073 Name (Last + 1 .. Last + 3) := "ali";
7074 Name_Len := Last + 3;
7075 Name_Buffer (1 .. Name_Len) := Name (1 .. Name_Len);
7078 (Index => Name_Find,
7079 In_Array => Switches_Array);
7085 if Switches = Nil_Variable_Value then
7086 Switches := Prj.Util.Value_Of
7087 (Index => Name_Ada, In_Array => Defaults);
7093 ---------------------------
7094 -- Test_If_Relative_Path --
7095 ---------------------------
7097 procedure Test_If_Relative_Path
7098 (Switch : in out String_Access;
7099 Parent : String_Access;
7100 Including_L_Switch : Boolean := True)
7103 if Switch /= null then
7106 Sw : String (1 .. Switch'Length);
7112 if Sw (1) = '-' then
7114 and then (Sw (2) = 'A'
7115 or else Sw (2) = 'I'
7116 or else (Including_L_Switch and then Sw (2) = 'L'))
7124 elsif Sw'Length >= 4
7125 and then (Sw (2 .. 3) = "aL"
7126 or else Sw (2 .. 3) = "aO"
7127 or else Sw (2 .. 3) = "aI")
7135 -- Because relative path arguments to --RTS= may be relative
7136 -- to the search directory prefix, those relative path
7137 -- arguments are not converted.
7139 if not Is_Absolute_Path (Sw (Start .. Sw'Last)) then
7140 if Parent = null or else Parent'Length = 0 then
7142 ("relative search path switches (""",
7144 """) are not allowed");
7149 (Sw (1 .. Start - 1) &
7151 Directory_Separator &
7152 Sw (Start .. Sw'Last));
7157 if not Is_Absolute_Path (Sw) then
7158 if Parent = null or else Parent'Length = 0 then
7160 ("relative paths (""", Sw, """) are not allowed");
7164 new String'(Parent.all & Directory_Separator & Sw);
7170 end Test_If_Relative_Path;
7178 if Usage_Needed then
7179 Usage_Needed := False;
7188 procedure Verbose_Msg
7191 N2 : Name_Id := No_Name;
7193 Prefix : String := " -> ")
7196 if not Verbose_Mode then
7206 if N2 /= No_Name then
7217 Prj.Com.Fail := Make_Failed'Access;
7218 MLib.Fail := Make_Failed'Access;
7219 -- Make sure that in case of failure, the temp files will be deleted
projects / platform / upstream / gcc.git / blob