1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 1992-2008, Free Software Foundation, Inc. --
11 -- GNAT is free software; you can redistribute it and/or modify it under --
12 -- terms of the GNU General Public License as published by the Free Soft- --
13 -- ware Foundation; either version 3, or (at your option) any later ver- --
14 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
15 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
16 -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
17 -- for more details. You should have received a copy of the GNU General --
18 -- Public License distributed with GNAT; see file COPYING3. If not, go to --
19 -- http://www.gnu.org/licenses for a complete copy of the license. --
21 -- GNAT was originally developed by the GNAT team at New York University. --
22 -- Extensive contributions were provided by Ada Core Technologies Inc. --
24 ------------------------------------------------------------------------------
27 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
;
38 with Makeutl
; use Makeutl
;
40 with MLib
.Tgt
; use MLib
.Tgt
;
42 with Namet
; use Namet
;
44 with Osint
.M
; use Osint
.M
;
45 with Osint
; use Osint
;
46 with Output
; use Output
;
54 with Snames
; use Snames
;
55 with Switch
; use Switch
;
56 with Switch
.M
; use Switch
.M
;
57 with Targparm
; use Targparm
;
60 with Types
; use Types
;
62 with Ada
.Exceptions
; use Ada
.Exceptions
;
63 with Ada
.Command_Line
; use Ada
.Command_Line
;
65 with GNAT
.Directory_Operations
; use GNAT
.Directory_Operations
;
66 with GNAT
.Case_Util
; use GNAT
.Case_Util
;
67 with GNAT
.OS_Lib
; use GNAT
.OS_Lib
;
74 -- Make control characters visible
76 Standard_Library_Package_Body_Name
: constant String := "s-stalib.adb";
77 -- Every program depends on this package, that must then be checked,
78 -- especially when -f and -a are used.
80 procedure Kill
(Pid
: Process_Id
; Sig_Num
: Integer; Close
: Integer);
81 pragma Import
(C
, Kill
, "__gnat_kill");
82 -- Called by Sigint_Intercepted to kill all spawned compilation processes
84 type Sigint_Handler
is access procedure;
85 pragma Convention
(C
, Sigint_Handler
);
87 procedure Install_Int_Handler
(Handler
: Sigint_Handler
);
88 pragma Import
(C
, Install_Int_Handler
, "__gnat_install_int_handler");
89 -- Called by Gnatmake to install the SIGINT handler below
91 procedure Sigint_Intercepted
;
92 pragma Convention
(C
, Sigint_Intercepted
);
93 -- Called when the program is interrupted by Ctrl-C to delete the
94 -- temporary mapping files and configuration pragmas files.
96 No_Mapping_File
: constant Natural := 0;
98 type Compilation_Data
is record
100 Full_Source_File
: File_Name_Type
;
101 Lib_File
: File_Name_Type
;
102 Source_Unit
: Unit_Name_Type
;
103 Mapping_File
: Natural := No_Mapping_File
;
104 Project
: Project_Id
:= No_Project
;
105 Syntax_Only
: Boolean := False;
106 Output_Is_Object
: Boolean := True;
108 -- Data recorded for each compilation process spawned
110 type Comp_Data_Arr
is array (Positive range <>) of Compilation_Data
;
111 type Comp_Data_Ptr
is access Comp_Data_Arr
;
112 Running_Compile
: Comp_Data_Ptr
;
113 -- Used to save information about outstanding compilations
115 Outstanding_Compiles
: Natural := 0;
116 -- Current number of outstanding compiles
118 -------------------------
119 -- Note on terminology --
120 -------------------------
122 -- In this program, we use the phrase "termination" of a file name to refer
123 -- to the suffix that appears after the unit name portion. Very often this
124 -- is simply the extension, but in some cases, the sequence may be more
125 -- complex, for example in main.1.ada, the termination in this name is
126 -- ".1.ada" and in main_.ada the termination is "_.ada".
128 -------------------------------------
129 -- Queue (Q) Manipulation Routines --
130 -------------------------------------
132 -- The Q is used in Compile_Sources below. Its implementation uses the GNAT
133 -- generic package Table (basically an extensible array). Q_Front points to
134 -- the first valid element in the Q, whereas Q.First is the first element
135 -- ever enqueued, while Q.Last - 1 is the last element in the Q.
137 -- +---+--------------+---+---+---+-----------+---+--------
138 -- Q | | ........ | | | | ....... | |
139 -- +---+--------------+---+---+---+-----------+---+--------
141 -- Q.First Q_Front Q.Last - 1
143 -- The elements comprised between Q.First and Q_Front - 1 are the elements
144 -- that have been enqueued and then dequeued, while the elements between
145 -- Q_Front and Q.Last - 1 are the elements currently in the Q. When the Q
146 -- is initialized Q_Front = Q.First = Q.Last. After Compile_Sources has
147 -- terminated its execution, Q_Front = Q.Last and the elements contained
148 -- between Q.Front and Q.Last-1 are those that were explored and thus
149 -- marked by Compile_Sources. Whenever the Q is reinitialized, the elements
150 -- between Q.First and Q.Last - 1 are unmarked.
153 -- Must be called to (re)initialize the Q
156 (Source_File
: File_Name_Type
;
157 Source_Unit
: Unit_Name_Type
:= No_Unit_Name
;
159 -- Inserts Source_File at the end of Q. Provide Source_Unit when possible
160 -- for external use (gnatdist). Provide index for multi-unit sources.
162 function Empty_Q
return Boolean;
163 -- Returns True if Q is empty
165 procedure Extract_From_Q
166 (Source_File
: out File_Name_Type
;
167 Source_Unit
: out Unit_Name_Type
;
168 Source_Index
: out Int
);
169 -- Extracts the first element from the Q
171 procedure Insert_Project_Sources
172 (The_Project
: Project_Id
;
173 All_Projects
: Boolean;
175 -- If Into_Q is True, insert all sources of the project file(s) that are
176 -- not already marked into the Q. If Into_Q is False, call Osint.Add_File
177 -- for the first source, then insert all other sources that are not already
178 -- marked into the Q. If All_Projects is True, all sources of all projects
179 -- are concerned; otherwise, only sources of The_Project are concerned,
180 -- including, if The_Project is an extending project, sources inherited
181 -- from projects being extended.
183 First_Q_Initialization
: Boolean := True;
184 -- Will be set to false after Init_Q has been called once
187 -- Points to the first valid element in the Q
189 Unique_Compile
: Boolean := False;
190 -- Set to True if -u or -U or a project file with no main is used
192 Unique_Compile_All_Projects
: Boolean := False;
193 -- Set to True if -U is used
195 RTS_Specified
: String_Access
:= null;
196 -- Used to detect multiple --RTS= switches
198 type Q_Record
is record
199 File
: File_Name_Type
;
200 Unit
: Unit_Name_Type
;
203 -- File is the name of the file to compile. Unit is for gnatdist
204 -- use in order to easily get the unit name of a file to compile
205 -- when its name is krunched or declared in gnat.adc. Index, when not 0,
206 -- is the index of the unit in a multi-unit source.
208 package Q
is new Table
.Table
(
209 Table_Component_Type
=> Q_Record
,
210 Table_Index_Type
=> Natural,
211 Table_Low_Bound
=> 0,
212 Table_Initial
=> 4000,
213 Table_Increment
=> 100,
214 Table_Name
=> "Make.Q");
215 -- This is the actual Q
217 -- The 3 following packages are used to store gcc, gnatbind and gnatlink
218 -- switches found in the project files.
220 package Gcc_Switches
is new Table
.Table
(
221 Table_Component_Type
=> String_Access
,
222 Table_Index_Type
=> Integer,
223 Table_Low_Bound
=> 1,
225 Table_Increment
=> 100,
226 Table_Name
=> "Make.Gcc_Switches");
228 package Binder_Switches
is new Table
.Table
(
229 Table_Component_Type
=> String_Access
,
230 Table_Index_Type
=> Integer,
231 Table_Low_Bound
=> 1,
233 Table_Increment
=> 100,
234 Table_Name
=> "Make.Binder_Switches");
236 package Linker_Switches
is new Table
.Table
(
237 Table_Component_Type
=> String_Access
,
238 Table_Index_Type
=> Integer,
239 Table_Low_Bound
=> 1,
241 Table_Increment
=> 100,
242 Table_Name
=> "Make.Linker_Switches");
244 -- The following instantiations and variables are necessary to save what
245 -- is found on the command line, in case there is a project file specified.
247 package Saved_Gcc_Switches
is new Table
.Table
(
248 Table_Component_Type
=> String_Access
,
249 Table_Index_Type
=> Integer,
250 Table_Low_Bound
=> 1,
252 Table_Increment
=> 100,
253 Table_Name
=> "Make.Saved_Gcc_Switches");
255 package Saved_Binder_Switches
is new Table
.Table
(
256 Table_Component_Type
=> String_Access
,
257 Table_Index_Type
=> Integer,
258 Table_Low_Bound
=> 1,
260 Table_Increment
=> 100,
261 Table_Name
=> "Make.Saved_Binder_Switches");
263 package Saved_Linker_Switches
is new Table
.Table
264 (Table_Component_Type
=> String_Access
,
265 Table_Index_Type
=> Integer,
266 Table_Low_Bound
=> 1,
268 Table_Increment
=> 100,
269 Table_Name
=> "Make.Saved_Linker_Switches");
271 package Switches_To_Check
is new Table
.Table
(
272 Table_Component_Type
=> String_Access
,
273 Table_Index_Type
=> Integer,
274 Table_Low_Bound
=> 1,
276 Table_Increment
=> 100,
277 Table_Name
=> "Make.Switches_To_Check");
279 package Library_Paths
is new Table
.Table
(
280 Table_Component_Type
=> String_Access
,
281 Table_Index_Type
=> Integer,
282 Table_Low_Bound
=> 1,
284 Table_Increment
=> 100,
285 Table_Name
=> "Make.Library_Paths");
287 package Failed_Links
is new Table
.Table
(
288 Table_Component_Type
=> File_Name_Type
,
289 Table_Index_Type
=> Integer,
290 Table_Low_Bound
=> 1,
292 Table_Increment
=> 100,
293 Table_Name
=> "Make.Failed_Links");
295 package Successful_Links
is new Table
.Table
(
296 Table_Component_Type
=> File_Name_Type
,
297 Table_Index_Type
=> Integer,
298 Table_Low_Bound
=> 1,
300 Table_Increment
=> 100,
301 Table_Name
=> "Make.Successful_Links");
303 package Library_Projs
is new Table
.Table
(
304 Table_Component_Type
=> Project_Id
,
305 Table_Index_Type
=> Integer,
306 Table_Low_Bound
=> 1,
308 Table_Increment
=> 100,
309 Table_Name
=> "Make.Library_Projs");
311 -- Two variables to keep the last binder and linker switch index in tables
312 -- Binder_Switches and Linker_Switches, before adding switches from the
313 -- project file (if any) and switches from the command line (if any).
315 Last_Binder_Switch
: Integer := 0;
316 Last_Linker_Switch
: Integer := 0;
318 Normalized_Switches
: Argument_List_Access
:= new Argument_List
(1 .. 10);
319 Last_Norm_Switch
: Natural := 0;
321 Saved_Maximum_Processes
: Natural := 0;
323 Gnatmake_Switch_Found
: Boolean;
324 -- Set by Scan_Make_Arg. True when the switch is a gnatmake switch.
325 -- Tested by Add_Switches when switches in package Builder must all be
326 -- gnatmake switches.
328 Switch_May_Be_Passed_To_The_Compiler
: Boolean;
329 -- Set by Add_Switches and Switches_Of. True when unrecognized switches
330 -- are passed to the Ada compiler.
332 type Arg_List_Ref
is access Argument_List
;
333 The_Saved_Gcc_Switches
: Arg_List_Ref
;
335 Project_File_Name
: String_Access
:= null;
336 -- The path name of the main project file, if any
338 Project_File_Name_Present
: Boolean := False;
339 -- True when -P is used with a space between -P and the project file name
341 Current_Verbosity
: Prj
.Verbosity
:= Prj
.Default
;
342 -- Verbosity to parse the project files
344 Project_Tree
: constant Project_Tree_Ref
:= new Project_Tree_Data
;
346 Main_Project
: Prj
.Project_Id
:= No_Project
;
347 -- The project id of the main project file, if any
349 Project_Of_Current_Object_Directory
: Project_Id
:= No_Project
;
350 -- The object directory of the project for the last compilation. Avoid
351 -- calling Change_Dir if the current working directory is already this
354 -- Packages of project files where unknown attributes are errors
356 Naming_String
: aliased String := "naming";
357 Builder_String
: aliased String := "builder";
358 Compiler_String
: aliased String := "compiler";
359 Binder_String
: aliased String := "binder";
360 Linker_String
: aliased String := "linker";
362 Gnatmake_Packages
: aliased String_List
:=
363 (Naming_String
'Access,
364 Builder_String 'Access,
365 Compiler_String
'Access,
366 Binder_String 'Access,
367 Linker_String
'Access);
369 Packages_To_Check_By_Gnatmake : constant String_List_Access :=
370 Gnatmake_Packages'Access;
372 procedure Add_Library_Search_Dir
374 On_Command_Line : Boolean);
375 -- Call Add_Lib_Search_Dir with an absolute directory path. If Path is
376 -- relative path, when On_Command_Line is True, it is relative to the
377 -- current working directory. When On_Command_Line is False, it is relative
378 -- to the project directory of the main project.
380 procedure Add_Source_Search_Dir
382 On_Command_Line : Boolean);
383 -- Call Add_Src_Search_Dir with an absolute directory path. If Path is a
384 -- relative path, when On_Command_Line is True, it is relative to the
385 -- current working directory. When On_Command_Line is False, it is relative
386 -- to the project directory of the main project.
388 procedure Add_Source_Dir (N : String);
389 -- Call Add_Src_Search_Dir (output one line when in verbose mode)
391 procedure Add_Source_Directories is
392 new Prj.Env.For_All_Source_Dirs (Action => Add_Source_Dir);
394 procedure Add_Object_Dir (N : String);
395 -- Call Add_Lib_Search_Dir (output one line when in verbose mode)
397 procedure Add_Object_Directories is
398 new Prj.Env.For_All_Object_Dirs (Action => Add_Object_Dir);
400 procedure Change_To_Object_Directory (Project : Project_Id);
401 -- Change to the object directory of project Project, if this is not
402 -- already the current working directory.
404 type Bad_Compilation_Info is record
405 File : File_Name_Type;
406 Unit : Unit_Name_Type;
409 -- File is the name of the file for which a compilation failed. Unit is for
410 -- gnatdist use in order to easily get the unit name of a file when its
411 -- name is krunched or declared in gnat.adc. Found is False if the
412 -- compilation failed because the file could not be found.
414 package Bad_Compilation is new Table.Table (
415 Table_Component_Type => Bad_Compilation_Info,
416 Table_Index_Type => Natural,
417 Table_Low_Bound => 1,
419 Table_Increment => 100,
420 Table_Name => "Make.Bad_Compilation");
421 -- Full name of all the source files for which compilation fails
423 Do_Compile_Step : Boolean := True;
424 Do_Bind_Step : Boolean := True;
425 Do_Link_Step : Boolean := True;
426 -- Flags to indicate what step should be executed. Can be set to False
427 -- with the switches -c, -b and -l. These flags are reset to True for
428 -- each invocation of procedure Gnatmake.
430 Shared_String : aliased String := "-shared";
431 Force_Elab_Flags_String : aliased String := "-F";
433 No_Shared_Switch : aliased Argument_List := (1 .. 0 => null);
434 Shared_Switch : aliased Argument_List := (1 => Shared_String'Access);
435 Bind_Shared : Argument_List_Access := No_Shared_Switch'Access;
436 -- Switch to added in front of gnatbind switches. By default no switch is
437 -- added. Switch "-shared" is added if there is a non-static Library
440 Shared_Libgcc : aliased String := "-shared-libgcc";
442 No_Shared_Libgcc_Switch : aliased Argument_List := (1 .. 0 => null);
443 Shared_Libgcc_Switch : aliased Argument_List :=
444 (1 => Shared_Libgcc'Access);
445 Link_With_Shared_Libgcc : Argument_List_Access :=
446 No_Shared_Libgcc_Switch'Access;
448 procedure Make_Failed (S1 : String; S2 : String := ""; S3 : String := "");
449 -- Delete all temp files created by Gnatmake and call Osint.Fail,
450 -- with the parameter S1, S2 and S3 (see osint.ads).
451 -- This is called from the Prj hierarchy and the MLib hierarchy.
453 --------------------------
454 -- Obsolete Executables --
455 --------------------------
457 Executable_Obsolete : Boolean := False;
458 -- Executable_Obsolete is initially set to False for each executable,
459 -- and is set to True whenever one of the source of the executable is
460 -- compiled, or has already been compiled for another executable.
462 Max_Header : constant := 200;
463 -- This needs a proper comment, it used to say "arbitrary"
464 -- that's not an adequate comment ???
466 type Header_Num is range 1 .. Max_Header;
467 -- Header_Num for the hash table Obsoleted below
469 function Hash (F : File_Name_Type) return Header_Num;
470 -- Hash function for the hash table Obsoleted below
472 package Obsoleted is new System.HTable.Simple_HTable
473 (Header_Num => Header_Num,
476 Key => File_Name_Type,
479 -- A hash table to keep all files that have been compiled, to detect
480 -- if an executable is up to date or not.
482 procedure Enter_Into_Obsoleted (F : File_Name_Type);
483 -- Enter a file name, without directory information, into the hash table
486 function Is_In_Obsoleted (F : File_Name_Type) return Boolean;
487 -- Check if a file name, without directory information, has already been
488 -- entered into the hash table Obsoleted.
490 type Dependency is record
491 This : File_Name_Type;
492 Depends_On : File_Name_Type;
494 -- Components of table Dependencies below
496 package Dependencies is new Table.Table (
497 Table_Component_Type => Dependency,
498 Table_Index_Type => Integer,
499 Table_Low_Bound => 1,
501 Table_Increment => 100,
502 Table_Name => "Make.Dependencies");
503 -- A table to keep dependencies, to be able to decide if an executable
504 -- is obsolete. More explanation needed ???
506 -- procedure Add_Dependency (S : File_Name_Type; On : File_Name_Type);
507 -- -- Add one entry in table Dependencies
509 ----------------------------
510 -- Arguments and Switches --
511 ----------------------------
513 Arguments : Argument_List_Access;
514 -- Used to gather the arguments for invocation of the compiler
516 Last_Argument : Natural := 0;
517 -- Last index of arguments in Arguments above
519 Arguments_Collected : Boolean := False;
520 -- Set to True when the arguments for the next invocation of the compiler
521 -- have been collected.
523 Arguments_Project : Project_Id;
524 -- Project id, if any, of the source to be compiled
526 Arguments_Path_Name : Path_Name_Type;
527 -- Full path of the source to be compiled, when Arguments_Project is not
530 Dummy_Switch : constant String_Access := new String'("- ");
531 -- Used to initialized Prev_Switch in procedure Check
533 procedure Add_Arguments
(Args
: Argument_List
);
534 -- Add arguments to global variable Arguments, increasing its size
535 -- if necessary and adjusting Last_Argument.
537 function Configuration_Pragmas_Switch
538 (For_Project
: Project_Id
) return Argument_List
;
539 -- Return an argument list of one element, if there is a configuration
540 -- pragmas file to be specified for For_Project,
541 -- otherwise return an empty argument list.
547 procedure List_Depend
;
548 -- Prints to standard output the list of object dependencies. This list
549 -- can be used directly in a Makefile. A call to Compile_Sources must
550 -- precede the call to List_Depend. Also because this routine uses the
551 -- ALI files that were originally loaded and scanned by Compile_Sources,
552 -- no additional ALI files should be scanned between the two calls (i.e.
553 -- between the call to Compile_Sources and List_Depend.)
555 procedure List_Bad_Compilations
;
556 -- Prints out the list of all files for which the compilation failed
558 procedure Verbose_Msg
561 N2
: Name_Id
:= No_Name
;
563 Prefix
: String := " -> ";
564 Minimum_Verbosity
: Verbosity_Level_Type
:= Opt
.Low
);
565 procedure Verbose_Msg
566 (N1
: File_Name_Type
;
568 N2
: File_Name_Type
:= No_File
;
570 Prefix
: String := " -> ";
571 Minimum_Verbosity
: Verbosity_Level_Type
:= Opt
.Low
);
572 -- If the verbose flag (Verbose_Mode) is set and the verbosity level is
573 -- at least equal to Minimum_Verbosity, then print Prefix to standard
574 -- output followed by N1 and S1. If N2 /= No_Name then N2 is printed after
575 -- S1. S2 is printed last. Both N1 and N2 are printed in quotation marks.
577 Usage_Needed
: Boolean := True;
578 -- Flag used to make sure Makeusg is call at most once
581 -- Call Makeusg, if Usage_Needed is True.
582 -- Set Usage_Needed to False.
584 procedure Debug_Msg
(S
: String; N
: Name_Id
);
585 procedure Debug_Msg
(S
: String; N
: File_Name_Type
);
586 procedure Debug_Msg
(S
: String; N
: Unit_Name_Type
);
587 -- If Debug.Debug_Flag_W is set outputs string S followed by name N
589 procedure Recursive_Compute_Depth
590 (Project
: Project_Id
;
592 -- Compute depth of Project and of the projects it depends on
594 procedure Compute_All_Imported_Projects
(Project
: Project_Id
);
595 -- Compute, the list of the projects imported directly or indirectly by
598 -----------------------
599 -- Gnatmake Routines --
600 -----------------------
602 subtype Lib_Mark_Type
is Byte
;
603 -- Used in Mark_Directory
605 Ada_Lib_Dir
: constant Lib_Mark_Type
:= 1;
606 -- Used to mark a directory as a GNAT lib dir
608 -- Note that the notion of GNAT lib dir is no longer used. The code related
609 -- to it has not been removed to give an idea on how to use the directory
610 -- prefix marking mechanism.
612 -- An Ada library directory is a directory containing ali and object files
613 -- but no source files for the bodies (the specs can be in the same or some
614 -- other directory). These directories are specified in the Gnatmake
615 -- command line with the switch "-Adir" (to specify the spec location -Idir
616 -- cab be used). Gnatmake skips the missing sources whose ali are in Ada
617 -- library directories. For an explanation of why Gnatmake behaves that
618 -- way, see the spec of Make.Compile_Sources. The directory lookup penalty
619 -- is incurred every single time this routine is called.
621 procedure Check_Steps
;
622 -- Check what steps (Compile, Bind, Link) must be executed.
623 -- Set the step flags accordingly.
625 function In_Ada_Lib_Dir
(File
: File_Name_Type
) return Boolean;
626 -- Get directory prefix of this file and get lib mark stored in name
627 -- table for this directory. Then check if an Ada lib mark has been set.
629 procedure Mark_Directory
631 Mark
: Lib_Mark_Type
;
632 On_Command_Line
: Boolean);
633 -- Store the absolute path from Dir in name table and set lib mark as name
634 -- info to identify Ada libraries.
636 -- If Dir is a relative path, when On_Command_Line is True, it is relative
637 -- to the current working directory; when On_Command_Line is False, it is
638 -- relative to the project directory of the main project.
640 Output_Is_Object
: Boolean := True;
641 -- Set to False when using a switch -S for the compiler
643 procedure Check_For_S_Switch
;
644 -- Set Output_Is_Object to False when the -S switch is used for the
648 (Source_File
: File_Name_Type
;
649 Source_File_Name
: String;
651 Naming
: Naming_Data
;
652 In_Package
: Package_Id
;
653 Allow_ALI
: Boolean) return Variable_Value
;
654 -- Return the switches for the source file in the specified package of a
655 -- project file. If the Source_File ends with a standard GNAT extension
656 -- (".ads" or ".adb"), try first the full name, then the name without the
657 -- extension, then, if Allow_ALI is True, the name with the extension
658 -- ".ali". If there is no switches for either names, try first Switches
659 -- (others) then the default switches for Ada. If all failed, return
660 -- No_Variable_Value.
662 function Is_In_Object_Directory
663 (Source_File
: File_Name_Type
;
664 Full_Lib_File
: File_Name_Type
) return Boolean;
665 -- Check if, when using a project file, the ALI file is in the project
666 -- directory of the ultimate extending project. If it is not, we ignore
667 -- the fact that this ALI file is read-only.
669 ----------------------------------------------------
670 -- Compiler, Binder & Linker Data and Subprograms --
671 ----------------------------------------------------
673 Gcc
: String_Access
:= Program_Name
("gcc", "gnatmake");
674 Gnatbind
: String_Access
:= Program_Name
("gnatbind", "gnatmake");
675 Gnatlink
: String_Access
:= Program_Name
("gnatlink", "gnatmake");
676 -- Default compiler, binder, linker programs
678 Saved_Gcc
: String_Access
:= null;
679 Saved_Gnatbind
: String_Access
:= null;
680 Saved_Gnatlink
: String_Access
:= null;
681 -- Given by the command line. Will be used, if non null
683 Gcc_Path
: String_Access
:=
684 GNAT
.OS_Lib
.Locate_Exec_On_Path
(Gcc
.all);
685 Gnatbind_Path
: String_Access
:=
686 GNAT
.OS_Lib
.Locate_Exec_On_Path
(Gnatbind
.all);
687 Gnatlink_Path
: String_Access
:=
688 GNAT
.OS_Lib
.Locate_Exec_On_Path
(Gnatlink
.all);
689 -- Path for compiler, binder, linker programs, defaulted now for gnatdist.
690 -- Changed later if overridden on command line.
692 Comp_Flag
: constant String_Access
:= new String'("-c");
693 Output_Flag : constant String_Access := new String'("-o");
694 Ada_Flag_1
: constant String_Access
:= new String'("-x");
695 Ada_Flag_2 : constant String_Access := new String'("ada");
696 No_gnat_adc
: constant String_Access
:= new String'("-gnatA");
697 GNAT_Flag : constant String_Access := new String'("-gnatpg");
698 Do_Not_Check_Flag
: constant String_Access
:= new String'("-x");
700 Object_Suffix : constant String := Get_Target_Object_Suffix.all;
702 Syntax_Only : Boolean := False;
703 -- Set to True when compiling with -gnats
705 Display_Executed_Programs : Boolean := True;
706 -- Set to True if name of commands should be output on stderr (or on stdout
707 -- if the Commands_To_Stdout flag was set by use of the -eS switch).
709 Output_File_Name_Seen : Boolean := False;
710 -- Set to True after having scanned the file_name for
711 -- switch "-o file_name"
713 Object_Directory_Seen : Boolean := False;
714 -- Set to True after having scanned the object directory for
715 -- switch "-D obj_dir".
717 Object_Directory_Path : String_Access := null;
718 -- The path name of the object directory, set with switch -D
720 type Make_Program_Type is (None, Compiler, Binder, Linker);
722 Program_Args : Make_Program_Type := None;
723 -- Used to indicate if we are scanning gnatmake, gcc, gnatbind, or gnatbind
724 -- options within the gnatmake command line. Used in Scan_Make_Arg only,
725 -- but must be global since value preserved from one call to another.
727 Temporary_Config_File : Boolean := False;
728 -- Set to True when there is a temporary config file used for a project
729 -- file, to avoid displaying the -gnatec switch for a temporary file.
731 procedure Add_Switches
732 (The_Package : Package_Id;
735 Program : Make_Program_Type;
736 Unknown_Switches_To_The_Compiler : Boolean := True);
739 Program : Make_Program_Type;
740 Append_Switch : Boolean := True;
741 And_Save : Boolean := True);
744 Program : Make_Program_Type;
745 Append_Switch : Boolean := True;
746 And_Save : Boolean := True);
747 -- Make invokes one of three programs (the compiler, the binder or the
748 -- linker). For the sake of convenience, some program specific switches
749 -- can be passed directly on the gnatmake command line. This procedure
750 -- records these switches so that gnatmake can pass them to the right
751 -- program. S is the switch to be added at the end of the command line
752 -- for Program if Append_Switch is True. If Append_Switch is False S is
753 -- added at the beginning of the command line.
756 (Source_File : File_Name_Type;
758 Is_Main_Source : Boolean;
759 The_Args : Argument_List;
760 Lib_File : File_Name_Type;
763 O_File : out File_Name_Type;
764 O_Stamp : out Time_Stamp_Type);
765 -- Determines whether the library file Lib_File is up-to-date or not. The
766 -- full name (with path information) of the object file corresponding to
767 -- Lib_File is returned in O_File. Its time stamp is saved in O_Stamp.
768 -- ALI is the ALI_Id corresponding to Lib_File. If Lib_File in not
769 -- up-to-date, then the corresponding source file needs to be recompiled.
770 -- In this case ALI = No_ALI_Id.
772 procedure Check_Linker_Options
773 (E_Stamp : Time_Stamp_Type;
774 O_File : out File_Name_Type;
775 O_Stamp : out Time_Stamp_Type);
776 -- Checks all linker options for linker files that are newer
777 -- than E_Stamp. If such objects are found, the youngest object
778 -- is returned in O_File and its stamp in O_Stamp.
780 -- If no obsolete linker files were found, the first missing
781 -- linker file is returned in O_File and O_Stamp is empty.
782 -- Otherwise O_File is No_File.
784 procedure Collect_Arguments
785 (Source_File : File_Name_Type;
787 Is_Main_Source : Boolean;
788 Args : Argument_List);
789 -- Collect all arguments for a source to be compiled, including those
790 -- that come from a project file.
792 procedure Display (Program : String; Args : Argument_List);
793 -- Displays Program followed by the arguments in Args if variable
794 -- Display_Executed_Programs is set. The lower bound of Args must be 1.
796 procedure Report_Compilation_Failed;
797 -- Delete all temporary files and fail graciously
803 type Temp_Path_Names is
804 array (Project_Id range <>, Positive range <>) of Path_Name_Type;
806 type Temp_Path_Ptr is access Temp_Path_Names;
808 type Indices is array (Project_Id range <>) of Natural;
810 type Indices_Ptr is access Indices;
812 type Free_File_Indices is array
813 (Project_Id range <>, Positive range <>) of Positive;
815 type Free_Indices_Ptr is access Free_File_Indices;
817 The_Mapping_File_Names : Temp_Path_Ptr;
818 -- For each project, the name ids of the temporary mapping files used
820 Last_Mapping_File_Names : Indices_Ptr;
821 -- For each project, the index of the last mapping file created
823 The_Free_Mapping_File_Indices : Free_Indices_Ptr;
824 -- For each project, the indices in The_Mapping_File_Names of the mapping
825 -- file names that can be reused for subsequent compilations.
827 Last_Free_Indices : Indices_Ptr;
828 -- For each project, the number of mapping files that can be reused
830 Gnatmake_Mapping_File : String_Access := null;
831 -- The path name of a mapping file specified by switch -C=
833 procedure Delete_Mapping_Files;
834 -- Delete all temporary mapping files. Called only in Delete_All_Temp_Files
835 -- which ensures that Debug_Flag_N is False.
837 procedure Init_Mapping_File
838 (Project : Project_Id;
839 File_Index : in out Natural);
840 -- Create a new temporary mapping file, and fill it with the project file
841 -- mappings, when using project file(s). The out parameter File_Index is
842 -- the index to the name of the file in the array The_Mapping_File_Names.
844 procedure Delete_Temp_Config_Files;
845 -- Delete all temporary config files. Must not be called if Debug_Flag_N
848 procedure Delete_All_Temp_Files;
849 -- Delete all temp files (config files, mapping files, path files), unless
850 -- Debug_Flag_N is True (in which case all temp files are left for user
853 -------------------------------------------------
854 -- Subprogram declarations moved from the spec --
855 -------------------------------------------------
857 procedure Bind (ALI_File : File_Name_Type; Args : Argument_List);
858 -- Binds ALI_File. Args are the arguments to pass to the binder.
859 -- Args must have a lower bound of 1.
861 procedure Display_Commands (Display : Boolean := True);
862 -- The default behavior of Make commands (Compile_Sources, Bind, Link)
863 -- is to display them on stderr. This behavior can be changed repeatedly
864 -- by invoking this procedure.
866 -- If a compilation, bind or link failed one of the following 3 exceptions
867 -- is raised. These need to be handled by the calling routines.
869 procedure Compile_Sources
870 (Main_Source : File_Name_Type;
871 Args : Argument_List;
872 First_Compiled_File : out File_Name_Type;
873 Most_Recent_Obj_File : out File_Name_Type;
874 Most_Recent_Obj_Stamp : out Time_Stamp_Type;
875 Main_Unit : out Boolean;
876 Compilation_Failures : out Natural;
877 Main_Index : Int := 0;
878 Check_Readonly_Files : Boolean := False;
879 Do_Not_Execute : Boolean := False;
880 Force_Compilations : Boolean := False;
881 Keep_Going : Boolean := False;
882 In_Place_Mode : Boolean := False;
883 Initialize_ALI_Data : Boolean := True;
884 Max_Process : Positive := 1);
885 -- Compile_Sources will recursively compile all the sources needed by
886 -- Main_Source. Before calling this routine make sure Namet has been
887 -- initialized. This routine can be called repeatedly with different
888 -- Main_Source file as long as all the source (-I flags), library
889 -- (-B flags) and ada library (-A flags) search paths between calls are
890 -- *exactly* the same. The default directory must also be the same.
892 -- Args contains the arguments to use during the compilations.
893 -- The lower bound of Args must be 1.
895 -- First_Compiled_File is set to the name of the first file that is
896 -- compiled or that needs to be compiled. This is set to No_Name if no
897 -- compilations were needed.
899 -- Most_Recent_Obj_File is set to the full name of the most recent
900 -- object file found when no compilations are needed, that is when
901 -- First_Compiled_File is set to No_Name. When First_Compiled_File
902 -- is set then Most_Recent_Obj_File is set to No_Name.
904 -- Most_Recent_Obj_Stamp is the time stamp of Most_Recent_Obj_File.
906 -- Main_Unit is set to True if Main_Source can be a main unit.
907 -- If Do_Not_Execute is False and First_Compiled_File /= No_Name
908 -- the value of Main_Unit is always False.
909 -- Is this used any more??? It is certainly not used by gnatmake???
911 -- Compilation_Failures is a count of compilation failures. This count
912 -- is used to extract compilation failure reports with Extract_Failure.
914 -- Main_Index, when not zero, is the index of the main unit in source
915 -- file Main_Source which is a multi-unit source.
916 -- Zero indicates that Main_Source is a single unit source file.
918 -- Check_Readonly_Files set it to True to compile source files
919 -- which library files are read-only. When compiling GNAT predefined
920 -- files the "-gnatg" flag is used.
922 -- Do_Not_Execute set it to True to find out the first source that
923 -- needs to be recompiled, but without recompiling it. This file is
924 -- saved in First_Compiled_File.
926 -- Force_Compilations forces all compilations no matter what but
927 -- recompiles read-only files only if Check_Readonly_Files
930 -- Keep_Going when True keep compiling even in the presence of
931 -- compilation errors.
933 -- In_Place_Mode when True save library/object files in their object
934 -- directory if they already exist; otherwise, in the source directory.
936 -- Initialize_ALI_Data set it to True when you want to initialize ALI
937 -- data-structures. This is what you should do most of the time.
938 -- (especially the first time around when you call this routine).
939 -- This parameter is set to False to preserve previously recorded
942 -- Max_Process is the maximum number of processes that should be spawned
943 -- to carry out compilations.
945 -- Flags in Package Opt Affecting Compile_Sources
946 -- -----------------------------------------------
948 -- Check_Object_Consistency set it to False to omit all consistency
949 -- checks between an .ali file and its corresponding object file.
950 -- When this flag is set to true, every time an .ali is read,
951 -- package Osint checks that the corresponding object file
952 -- exists and is more recent than the .ali.
954 -- Use of Name Table Info
955 -- ----------------------
957 -- All file names manipulated by Compile_Sources are entered into the
958 -- Names table. The Byte field of a source file is used to mark it.
960 -- Calling Compile_Sources Several Times
961 -- -------------------------------------
963 -- Upon return from Compile_Sources all the ALI data structures are left
964 -- intact for further browsing. HOWEVER upon entry to this routine ALI
965 -- data structures are re-initialized if parameter Initialize_ALI_Data
966 -- above is set to true. Typically this is what you want the first time
967 -- you call Compile_Sources. You should not load an ali file, call this
968 -- routine with flag Initialize_ALI_Data set to True and then expect
969 -- that ALI information to be around after the call. Note that the first
970 -- time you call Compile_Sources you better set Initialize_ALI_Data to
971 -- True unless you have called Initialize_ALI yourself.
973 -- Compile_Sources ALGORITHM : Compile_Sources (Main_Source)
974 -- -------------------------
976 -- 1. Insert Main_Source in a Queue (Q) and mark it.
978 -- 2. Let unit.adb be the file at the head of the Q. If unit.adb is
979 -- missing but its corresponding ali file is in an Ada library directory
980 -- (see below) then, remove unit.adb from the Q and goto step 4.
981 -- Otherwise, look at the files under the D (dependency) section of
982 -- unit.ali. If unit.ali does not exist or some of the time stamps do
983 -- not match, (re)compile unit.adb.
985 -- An Ada library directory is a directory containing Ada specs, ali
986 -- and object files but no source files for the bodies. An Ada library
987 -- directory is communicated to gnatmake by means of some switch so that
988 -- gnatmake can skip the sources whole ali are in that directory.
989 -- There are two reasons for skipping the sources in this case. Firstly,
990 -- Ada libraries typically come without full sources but binding and
991 -- linking against those libraries is still possible. Secondly, it would
992 -- be very wasteful for gnatmake to systematically check the consistency
993 -- of every external Ada library used in a program. The binder is
994 -- already in charge of catching any potential inconsistencies.
996 -- 3. Look into the W section of unit.ali and insert into the Q all
997 -- unmarked source files. Mark all files newly inserted in the Q.
998 -- Specifically, assuming that the W section looks like
1000 -- W types%s types.adb types.ali
1001 -- W unchecked_deallocation%s
1002 -- W xref_tab%s xref_tab.adb xref_tab.ali
1004 -- Then xref_tab.adb and types.adb are inserted in the Q if they are not
1006 -- Note that there is no file listed under W unchecked_deallocation%s
1007 -- so no generic body should ever be explicitly compiled (unless the
1008 -- Main_Source at the start was a generic body).
1010 -- 4. Repeat steps 2 and 3 above until the Q is empty
1012 -- Note that the above algorithm works because the units withed in
1013 -- subunits are transitively included in the W section (with section) of
1014 -- the main unit. Likewise the withed units in a generic body needed
1015 -- during a compilation are also transitively included in the W section
1016 -- of the originally compiled file.
1018 procedure Initialize;
1019 -- Performs default and package initialization. Therefore,
1020 -- Compile_Sources can be called by an external unit.
1023 (ALI_File : File_Name_Type;
1024 Args : Argument_List;
1025 Success : out Boolean);
1026 -- Links ALI_File. Args are the arguments to pass to the linker.
1027 -- Args must have a lower bound of 1. Success indicates if the link
1028 -- succeeded or not.
1030 procedure Scan_Make_Arg (Argv : String; And_Save : Boolean);
1031 -- Scan make arguments. Argv is a single argument to be processed
1037 procedure Add_Arguments (Args : Argument_List) is
1039 if Arguments = null then
1040 Arguments := new Argument_List (1 .. Args'Length + 10);
1043 while Last_Argument + Args'Length > Arguments'Last loop
1045 New_Arguments : constant Argument_List_Access :=
1046 new Argument_List (1 .. Arguments'Last * 2);
1048 New_Arguments (1 .. Last_Argument) :=
1049 Arguments (1 .. Last_Argument);
1050 Arguments := New_Arguments;
1055 Arguments (Last_Argument + 1 .. Last_Argument + Args'Length) := Args;
1056 Last_Argument := Last_Argument + Args'Length;
1059 -- --------------------
1060 -- -- Add_Dependency --
1061 -- --------------------
1063 -- procedure Add_Dependency (S : File_Name_Type; On : File_Name_Type) is
1065 -- Dependencies.Increment_Last;
1066 -- Dependencies.Table (Dependencies.Last) := (S, On);
1067 -- end Add_Dependency;
1069 ----------------------------
1070 -- Add_Library_Search_Dir --
1071 ----------------------------
1073 procedure Add_Library_Search_Dir
1075 On_Command_Line : Boolean)
1078 if On_Command_Line then
1079 Add_Lib_Search_Dir (Normalize_Pathname (Path));
1083 (Project_Tree.Projects.Table (Main_Project).Directory.Display_Name);
1085 (Normalize_Pathname (Path, Name_Buffer (1 .. Name_Len)));
1087 end Add_Library_Search_Dir;
1089 --------------------
1090 -- Add_Object_Dir --
1091 --------------------
1093 procedure Add_Object_Dir (N : String) is
1095 Add_Lib_Search_Dir (N);
1097 if Verbose_Mode then
1098 Write_Str ("Adding object directory """);
1105 --------------------
1106 -- Add_Source_Dir --
1107 --------------------
1109 procedure Add_Source_Dir (N : String) is
1111 Add_Src_Search_Dir (N);
1113 if Verbose_Mode then
1114 Write_Str ("Adding source directory """);
1121 ---------------------------
1122 -- Add_Source_Search_Dir --
1123 ---------------------------
1125 procedure Add_Source_Search_Dir
1127 On_Command_Line : Boolean)
1130 if On_Command_Line then
1131 Add_Src_Search_Dir (Normalize_Pathname (Path));
1135 (Project_Tree.Projects.Table (Main_Project).Directory.Display_Name);
1137 (Normalize_Pathname (Path, Name_Buffer (1 .. Name_Len)));
1139 end Add_Source_Search_Dir;
1145 procedure Add_Switch
1147 Program : Make_Program_Type;
1148 Append_Switch : Boolean := True;
1149 And_Save : Boolean := True)
1152 with package T is new Table.Table (<>);
1153 procedure Generic_Position (New_Position : out Integer);
1154 -- Generic procedure that chooses a position for S in T at the
1155 -- beginning or the end, depending on the boolean Append_Switch.
1156 -- Calling this procedure may expand the table.
1158 ----------------------
1159 -- Generic_Position --
1160 ----------------------
1162 procedure Generic_Position (New_Position : out Integer) is
1166 if Append_Switch then
1167 New_Position := Integer (T.Last);
1169 for J in reverse T.Table_Index_Type'Succ (T.First) .. T.Last loop
1170 T.Table (J) := T.Table (T.Table_Index_Type'Pred (J));
1173 New_Position := Integer (T.First);
1175 end Generic_Position;
1177 procedure Gcc_Switches_Pos is new Generic_Position (Gcc_Switches);
1178 procedure Binder_Switches_Pos is new Generic_Position (Binder_Switches);
1179 procedure Linker_Switches_Pos is new Generic_Position (Linker_Switches);
1181 procedure Saved_Gcc_Switches_Pos is new
1182 Generic_Position (Saved_Gcc_Switches);
1184 procedure Saved_Binder_Switches_Pos is new
1185 Generic_Position (Saved_Binder_Switches);
1187 procedure Saved_Linker_Switches_Pos is new
1188 Generic_Position (Saved_Linker_Switches);
1190 New_Position : Integer;
1192 -- Start of processing for Add_Switch
1198 Saved_Gcc_Switches_Pos (New_Position);
1199 Saved_Gcc_Switches.Table (New_Position) := S;
1202 Saved_Binder_Switches_Pos (New_Position);
1203 Saved_Binder_Switches.Table (New_Position) := S;
1206 Saved_Linker_Switches_Pos (New_Position);
1207 Saved_Linker_Switches.Table (New_Position) := S;
1210 raise Program_Error;
1216 Gcc_Switches_Pos (New_Position);
1217 Gcc_Switches.Table (New_Position) := S;
1220 Binder_Switches_Pos (New_Position);
1221 Binder_Switches.Table (New_Position) := S;
1224 Linker_Switches_Pos (New_Position);
1225 Linker_Switches.Table (New_Position) := S;
1228 raise Program_Error;
1233 procedure Add_Switch
1235 Program : Make_Program_Type;
1236 Append_Switch : Boolean := True;
1237 And_Save : Boolean := True)
1240 Add_Switch (S => new String'(S
),
1242 Append_Switch
=> Append_Switch
,
1243 And_Save
=> And_Save
);
1250 procedure Add_Switches
1251 (The_Package
: Package_Id
;
1254 Program
: Make_Program_Type
;
1255 Unknown_Switches_To_The_Compiler
: Boolean := True)
1257 Switches
: Variable_Value
;
1258 Switch_List
: String_List_Id
;
1259 Element
: String_Element
;
1262 Switch_May_Be_Passed_To_The_Compiler
:=
1263 Unknown_Switches_To_The_Compiler
;
1265 if File_Name
'Length > 0 then
1266 Name_Len
:= File_Name
'Length;
1267 Name_Buffer
(1 .. Name_Len
) := File_Name
;
1270 (Source_File
=> Name_Find
,
1271 Source_File_Name
=> File_Name
,
1272 Source_Index
=> Index
,
1273 Naming
=> Project_Tree
.Projects
.Table
1274 (Main_Project
).Naming
,
1275 In_Package
=> The_Package
,
1276 Allow_ALI
=> Program
= Binder
or else Program
= Linker
);
1278 if Switches
.Kind
= List
then
1279 Program_Args
:= Program
;
1281 Switch_List
:= Switches
.Values
;
1282 while Switch_List
/= Nil_String
loop
1283 Element
:= Project_Tree
.String_Elements
.Table
(Switch_List
);
1284 Get_Name_String
(Element
.Value
);
1286 if Name_Len
> 0 then
1288 Argv
: constant String := Name_Buffer
(1 .. Name_Len
);
1289 -- We need a copy, because Name_Buffer may be modified
1292 if Verbose_Mode
then
1293 Write_Str
(" Adding ");
1297 Scan_Make_Arg
(Argv
, And_Save
=> False);
1299 if not Gnatmake_Switch_Found
1300 and then not Switch_May_Be_Passed_To_The_Compiler
1304 """ is not a gnatmake switch. Consider moving " &
1305 "it to Global_Compilation_Switches.",
1309 ("*** illegal switch """, Argv
, """");
1314 Switch_List
:= Element
.Next
;
1324 procedure Bind
(ALI_File
: File_Name_Type
; Args
: Argument_List
) is
1325 Bind_Args
: Argument_List
(1 .. Args
'Last + 2);
1326 Bind_Last
: Integer;
1330 pragma Assert
(Args
'First = 1);
1332 -- Optimize the simple case where the gnatbind command line looks like
1333 -- gnatbind -aO. -I- file.ali --into-> gnatbind file.adb
1336 and then Args
(Args
'First).all = "-aO" & Normalized_CWD
1337 and then Args
(Args
'Last).all = "-I-"
1338 and then ALI_File
= Strip_Directory
(ALI_File
)
1340 Bind_Last
:= Args
'First - 1;
1343 Bind_Last
:= Args
'Last;
1344 Bind_Args
(Args
'Range) := Args
;
1347 -- It is completely pointless to re-check source file time stamps. This
1348 -- has been done already by gnatmake
1350 Bind_Last
:= Bind_Last
+ 1;
1351 Bind_Args
(Bind_Last
) := Do_Not_Check_Flag
;
1353 Get_Name_String
(ALI_File
);
1355 Bind_Last
:= Bind_Last
+ 1;
1356 Bind_Args
(Bind_Last
) := new String'(Name_Buffer (1 .. Name_Len));
1358 GNAT.OS_Lib.Normalize_Arguments (Bind_Args (Args'First .. Bind_Last));
1360 Display (Gnatbind.all, Bind_Args (Args'First .. Bind_Last));
1362 if Gnatbind_Path = null then
1363 Make_Failed ("error, unable to locate ", Gnatbind.all);
1367 (Gnatbind_Path.all, Bind_Args (Args'First .. Bind_Last), Success);
1370 Make_Failed ("*** bind failed.");
1374 --------------------------------
1375 -- Change_To_Object_Directory --
1376 --------------------------------
1378 procedure Change_To_Object_Directory (Project : Project_Id) is
1379 Actual_Project : Project_Id;
1380 Object_Directory : Path_Name_Type;
1383 -- For sources outside of any project, compilation occurs in the object
1384 -- directory of the main project, otherwise we use the project given.
1386 if Project = No_Project then
1387 Actual_Project := Main_Project;
1389 Actual_Project := Project;
1392 -- Nothing to do if the current working directory is already the correct
1393 -- object directory.
1395 if Project_Of_Current_Object_Directory /= Actual_Project then
1396 Project_Of_Current_Object_Directory := Actual_Project;
1398 Project_Tree.Projects.Table (Actual_Project).Object_Directory.Name;
1400 -- Set the working directory to the object directory of the actual
1403 if Verbose_Mode then
1404 Write_Str ("Changing to object directory of """);
1406 (Project_Tree.Projects.Table (Actual_Project).Display_Name);
1407 Write_Str (""": """);
1408 Write_Name (Object_Directory);
1412 Change_Dir (Get_Name_String (Object_Directory));
1416 -- Fail if unable to change to the object directory
1418 when Directory_Error =>
1419 Make_Failed ("unable to change to object directory """ &
1421 (Project_Tree.Projects.Table
1422 (Actual_Project).Object_Directory.Name) &
1424 Get_Name_String (Project_Tree.Projects.Table
1425 (Actual_Project).Display_Name));
1426 end Change_To_Object_Directory;
1433 (Source_File : File_Name_Type;
1435 Is_Main_Source : Boolean;
1436 The_Args : Argument_List;
1437 Lib_File : File_Name_Type;
1438 Read_Only : Boolean;
1440 O_File : out File_Name_Type;
1441 O_Stamp : out Time_Stamp_Type)
1443 function File_Not_A_Source_Of
1445 Sfile : File_Name_Type) return Boolean;
1447 function First_New_Spec (A : ALI_Id) return File_Name_Type;
1448 -- Looks in the with table entries of A and returns the spec file name
1449 -- of the first withed unit (subprogram) for which no spec existed when
1450 -- A was generated but for which there exists one now, implying that A
1451 -- is now obsolete. If no such unit is found No_File is returned.
1452 -- Otherwise the spec file name of the unit is returned.
1454 -- **WARNING** in the event of Uname format modifications, one *MUST*
1455 -- make sure this function is also updated.
1457 -- Note: This function should really be in ali.adb and use Uname
1458 -- services, but this causes the whole compiler to be dragged along
1459 -- for gnatbind and gnatmake.
1461 --------------------------
1462 -- File_Not_A_Source_Of --
1463 --------------------------
1465 function File_Not_A_Source_Of
1467 Sfile : File_Name_Type) return Boolean
1469 UID : Prj.Unit_Index;
1473 UID := Units_Htable.Get (Project_Tree.Units_HT, Uname);
1475 if UID /= Prj.No_Unit_Index then
1476 U_Data := Project_Tree.Units.Table (UID);
1478 if U_Data.File_Names (Body_Part).Name /= Sfile
1479 and then U_Data.File_Names (Specification).Name /= Sfile
1481 Verbose_Msg (Uname, "sources do not include ", Name_Id (Sfile));
1487 end File_Not_A_Source_Of;
1489 --------------------
1490 -- First_New_Spec --
1491 --------------------
1493 function First_New_Spec (A : ALI_Id) return File_Name_Type is
1494 Spec_File_Name : File_Name_Type := No_File;
1496 function New_Spec (Uname : Unit_Name_Type) return Boolean;
1497 -- Uname is the name of the spec or body of some ada unit. This
1498 -- function returns True if the Uname is the name of a body which has
1499 -- a spec not mentioned in ALI file A. If True is returned
1500 -- Spec_File_Name above is set to the name of this spec file.
1506 function New_Spec (Uname : Unit_Name_Type) return Boolean is
1507 Spec_Name : Unit_Name_Type;
1508 File_Name : File_Name_Type;
1511 -- Test whether Uname is the name of a body unit (i.e. ends
1514 Get_Name_String (Uname);
1516 Assert (Name_Len > 2 and then Name_Buffer (Name_Len - 1) = '%');
1518 if Name_Buffer (Name_Len) /= 'b
' then
1522 -- Convert unit name into spec name
1524 -- ??? this code seems dubious in presence of pragma
1525 -- Source_File_Name since there is no more direct relationship
1526 -- between unit name and file name.
1528 -- ??? Further, what about alternative subunit naming
1530 Name_Buffer (Name_Len) := 's
';
1531 Spec_Name := Name_Find;
1532 File_Name := Get_File_Name (Spec_Name, Subunit => False);
1534 -- Look if File_Name is mentioned in A's sdep list.
1535 -- If not look if the file exists. If it does return True.
1538 ALIs.Table (A).First_Sdep .. ALIs.Table (A).Last_Sdep
1540 if Sdep.Table (D).Sfile = File_Name then
1545 if Full_Source_Name (File_Name) /= No_File then
1546 Spec_File_Name := File_Name;
1553 -- Start of processing for First_New_Spec
1557 ALIs.Table (A).First_Unit .. ALIs.Table (A).Last_Unit
1559 exit U_Chk when Units.Table (U).Utype = Is_Body_Only
1560 and then New_Spec (Units.Table (U).Uname);
1562 for W in Units.Table (U).First_With
1564 Units.Table (U).Last_With
1567 Withs.Table (W).Afile /= No_File
1568 and then New_Spec (Withs.Table (W).Uname);
1572 return Spec_File_Name;
1575 ---------------------------------
1576 -- Data declarations for Check --
1577 ---------------------------------
1579 Full_Lib_File : File_Name_Type;
1580 -- Full name of current library file
1582 Full_Obj_File : File_Name_Type;
1583 -- Full name of the object file corresponding to Lib_File
1585 Lib_Stamp : Time_Stamp_Type;
1586 -- Time stamp of the current ada library file
1588 Obj_Stamp : Time_Stamp_Type;
1589 -- Time stamp of the current object file
1591 Modified_Source : File_Name_Type;
1592 -- The first source in Lib_File whose current time stamp differs
1593 -- from that stored in Lib_File.
1595 New_Spec : File_Name_Type;
1596 -- If Lib_File contains in its W (with) section a body (for a
1597 -- subprogram) for which there exists a spec and the spec did not
1598 -- appear in the Sdep section of Lib_File, New_Spec contains the file
1599 -- name of this new spec.
1601 Source_Name : File_Name_Type;
1602 Text : Text_Buffer_Ptr;
1604 Prev_Switch : String_Access;
1605 -- Previous switch processed
1607 Arg : Arg_Id := Arg_Id'First;
1608 -- Current index in Args.Table for a given unit (init to stop warning)
1610 Switch_Found : Boolean;
1611 -- True if a given switch has been found
1613 ALI_Project : Project_Id;
1614 -- If the ALI file is in the object directory of a project, this is
1617 -- Start of processing for Check
1620 pragma Assert (Lib_File /= No_File);
1622 -- If ALI file is read-only, temporarily set Check_Object_Consistency to
1623 -- False. We don't care if the object file is not there (presumably a
1624 -- library will be used for linking.)
1628 Saved_Check_Object_Consistency : constant Boolean :=
1629 Check_Object_Consistency;
1631 Check_Object_Consistency := False;
1632 Text := Read_Library_Info (Lib_File);
1633 Check_Object_Consistency := Saved_Check_Object_Consistency;
1637 Text := Read_Library_Info (Lib_File);
1640 Full_Lib_File := Full_Library_Info_Name;
1641 Full_Obj_File := Full_Object_File_Name;
1642 Lib_Stamp := Current_Library_File_Stamp;
1643 Obj_Stamp := Current_Object_File_Stamp;
1645 if Full_Lib_File = No_File then
1648 "being checked ...",
1650 Minimum_Verbosity => Opt.Medium);
1654 "being checked ...",
1656 Minimum_Verbosity => Opt.Medium);
1660 O_File := Full_Obj_File;
1661 O_Stamp := Obj_Stamp;
1664 if Full_Lib_File = No_File then
1665 Verbose_Msg (Lib_File, "missing.");
1667 elsif Obj_Stamp (Obj_Stamp'First) = ' ' then
1668 Verbose_Msg (Full_Obj_File, "missing.");
1672 (Full_Lib_File, "(" & String (Lib_Stamp) & ") newer than",
1673 Full_Obj_File, "(" & String (Obj_Stamp) & ")");
1677 ALI := Scan_ALI (Lib_File, Text, Ignore_ED => False, Err => True);
1680 if ALI = No_ALI_Id then
1681 Verbose_Msg (Full_Lib_File, "incorrectly formatted ALI file");
1684 elsif ALIs.Table (ALI).Ver (1 .. ALIs.Table (ALI).Ver_Len) /=
1685 Verbose_Library_Version
1687 Verbose_Msg (Full_Lib_File, "compiled with old GNAT version");
1692 -- Don't take Ali file into account if it was generated with
1695 if ALIs.Table (ALI).Compile_Errors then
1696 Verbose_Msg (Full_Lib_File, "had errors, must be recompiled");
1701 -- Don't take Ali file into account if it was generated without
1704 if Operating_Mode /= Check_Semantics
1705 and then ALIs.Table (ALI).No_Object
1707 Verbose_Msg (Full_Lib_File, "has no corresponding object");
1712 -- Check for matching compiler switches if needed
1714 if Check_Switches then
1716 -- First, collect all the switches
1719 (Source_File, Source_Index, Is_Main_Source, The_Args);
1721 Prev_Switch := Dummy_Switch;
1723 Get_Name_String (ALIs.Table (ALI).Sfile);
1725 Switches_To_Check.Set_Last (0);
1727 for J in 1 .. Last_Argument loop
1729 -- Skip non switches -c, -I and -o switches
1731 if Arguments (J) (1) = '-'
1732 and then Arguments (J) (2) /= 'c
'
1733 and then Arguments (J) (2) /= 'o
'
1734 and then Arguments (J) (2) /= 'I
'
1736 Normalize_Compiler_Switches
1738 Normalized_Switches,
1741 for K in 1 .. Last_Norm_Switch loop
1742 Switches_To_Check.Increment_Last;
1743 Switches_To_Check.Table (Switches_To_Check.Last) :=
1744 Normalized_Switches (K);
1749 for J in 1 .. Switches_To_Check.Last loop
1751 -- Comparing switches is delicate because gcc reorders a number
1752 -- of switches, according to lang-specs.h, but gnatmake doesn't
1753 -- have sufficient knowledge to perform the same reordering.
1754 -- Instead, we ignore orders between different "first letter"
1755 -- switches, but keep orders between same switches, e.g -O -O2
1756 -- is different than -O2 -O, but -g -O is equivalent to -O -g.
1758 if Switches_To_Check.Table (J) (2) /= Prev_Switch (2) or else
1759 (Prev_Switch'Length >= 6 and then
1760 Prev_Switch (2 .. 5) = "gnat" and then
1761 Switches_To_Check.Table (J)'Length >= 6 and then
1762 Switches_To_Check.Table (J) (2 .. 5) = "gnat" and then
1763 Prev_Switch (6) /= Switches_To_Check.Table (J) (6))
1765 Prev_Switch := Switches_To_Check.Table (J);
1767 Units.Table (ALIs.Table (ALI).First_Unit).First_Arg;
1770 Switch_Found := False;
1773 Units.Table (ALIs.Table (ALI).First_Unit).Last_Arg
1776 Switches_To_Check.Table (J).all = Args.Table (K).all
1779 Switch_Found := True;
1784 if not Switch_Found then
1785 if Verbose_Mode then
1786 Verbose_Msg (ALIs.Table (ALI).Sfile,
1787 "switch mismatch """ &
1788 Switches_To_Check.Table (J).all & '"');
1796 if Switches_To_Check.Last /=
1797 Integer (Units.Table (ALIs.Table (ALI).First_Unit).Last_Arg -
1798 Units.Table (ALIs.Table (ALI).First_Unit).First_Arg + 1)
1800 if Verbose_Mode then
1801 Verbose_Msg (ALIs.Table (ALI).Sfile,
1802 "different number
of switches
");
1804 for K in Units.Table (ALIs.Table (ALI).First_Unit).First_Arg
1805 .. Units.Table (ALIs.Table (ALI).First_Unit).Last_Arg
1807 Write_Str (Args.Table (K).all);
1813 for J in 1 .. Switches_To_Check.Last loop
1814 Write_Str (Switches_To_Check.Table (J).all);
1826 -- Get the source files and their message digests. Note that some
1827 -- sources may be missing if ALI is out-of-date.
1829 Set_Source_Table (ALI);
1831 Modified_Source := Time_Stamp_Mismatch (ALI, Read_Only);
1833 if Modified_Source /= No_File then
1836 if Verbose_Mode then
1837 Source_Name := Full_Source_Name (Modified_Source);
1839 if Source_Name /= No_File then
1840 Verbose_Msg (Source_Name, "time stamp mismatch
");
1842 Verbose_Msg (Modified_Source, "missing
");
1847 New_Spec := First_New_Spec (ALI);
1849 if New_Spec /= No_File then
1852 if Verbose_Mode then
1853 Source_Name := Full_Source_Name (New_Spec);
1855 if Source_Name /= No_File then
1856 Verbose_Msg (Source_Name, "new spec
");
1858 Verbose_Msg (New_Spec, "old spec missing
");
1862 elsif not Read_Only and then Main_Project /= No_Project then
1864 -- Check if a file name does not correspond to the mapping of
1865 -- units to file names.
1870 Unit_Name : Name_Id;
1874 for U in ALIs.Table (ALI).First_Unit ..
1875 ALIs.Table (ALI).Last_Unit
1877 -- Check if the file name is one of the source of the
1880 Get_Name_String (Units.Table (U).Uname);
1881 Name_Len := Name_Len - 2;
1882 Unit_Name := Name_Find;
1884 if File_Not_A_Source_Of
1885 (Unit_Name, Units.Table (U).Sfile)
1891 -- Do the same check for each of the withed units.
1894 for W in Units.Table (U).First_With
1896 Units.Table (U).Last_With
1898 WR := Withs.Table (W);
1900 if WR.Sfile /= No_File then
1901 Get_Name_String (WR.Uname);
1902 Name_Len := Name_Len - 2;
1903 Unit_Name := Name_Find;
1905 if File_Not_A_Source_Of (Unit_Name, WR.Sfile) then
1913 -- Check also the subunits
1916 for D in ALIs.Table (ALI).First_Sdep ..
1917 ALIs.Table (ALI).Last_Sdep
1919 SD := Sdep.Table (D);
1920 Unit_Name := SD.Subunit_Name;
1922 if Unit_Name /= No_Name then
1923 if File_Not_A_Source_Of (Unit_Name, SD.Sfile) then
1931 -- Check that the ALI file is in the correct object directory.
1932 -- If it is in the object directory of a project that is
1933 -- extended and it depends on a source that is in one of its
1934 -- extending projects, then the ALI file is not in the correct
1935 -- object directory.
1937 -- First, find the project of this ALI file. As there may be
1938 -- several projects with the same object directory, we first
1939 -- need to find the project of the source.
1941 ALI_Project := No_Project;
1944 Udata : Prj.Unit_Data;
1947 for U in 1 .. Unit_Table.Last (Project_Tree.Units) loop
1948 Udata := Project_Tree.Units.Table (U);
1950 if Udata.File_Names (Body_Part).Name = Source_File then
1951 ALI_Project := Udata.File_Names (Body_Part).Project;
1955 Udata.File_Names (Specification).Name = Source_File
1958 Udata.File_Names (Specification).Project;
1964 if ALI_Project = No_Project then
1969 Obj_Dir : Path_Name_Type;
1970 Res_Obj_Dir : constant String :=
1973 (Get_Name_String (Full_Lib_File)),
1974 Resolve_Links => True,
1975 Case_Sensitive => False);
1979 Add_Str_To_Name_Buffer (Res_Obj_Dir);
1981 if Name_Len > 1 and then
1982 (Name_Buffer (Name_Len) = '/'
1984 Name_Buffer (Name_Len) = Directory_Separator)
1986 Name_Len := Name_Len - 1;
1989 Obj_Dir := Name_Find;
1991 while ALI_Project /= No_Project and then
1993 Project_Tree.Projects.Table
1994 (ALI_Project).Object_Directory.Name
1997 Project_Tree.Projects.Table (ALI_Project).Extended_By;
2001 if ALI_Project = No_Project then
2005 (Lib_File, " wrong object directory
");
2009 -- If the ALI project is not extended, then it must be in
2010 -- the correct object directory.
2012 if Project_Tree.Projects.Table (ALI_Project).Extended_By =
2018 -- Count the extending projects
2026 Proj := ALI_Project;
2028 Proj := Project_Tree.Projects.Table (Proj).Extended_By;
2029 exit when Proj = No_Project;
2030 Num_Ext := Num_Ext + 1;
2033 -- Make a list of the extending projects
2036 Projects : array (1 .. Num_Ext) of Project_Id;
2038 OK : Boolean := True;
2041 Proj := ALI_Project;
2042 for J in Projects'Range loop
2043 Proj := Project_Tree.Projects.Table (Proj).Extended_By;
2044 Projects (J) := Proj;
2047 -- Now check if any of the dependant sources are in
2048 -- any of these extending projects.
2051 for D in ALIs.Table (ALI).First_Sdep ..
2052 ALIs.Table (ALI).Last_Sdep
2054 Dep := Sdep.Table (D);
2060 UID in 1 .. Unit_Table.Last (Project_Tree.Units)
2062 if Project_Tree.Units.Table (UID).
2063 File_Names (Body_Part).Name = Dep.Sfile
2065 Proj := Project_Tree.Units.Table (UID).
2066 File_Names (Body_Part).Project;
2068 elsif Project_Tree.Units.Table (UID).
2069 File_Names (Specification).Name = Dep.Sfile
2071 Proj := Project_Tree.Units.Table (UID).
2072 File_Names (Specification).Project;
2075 -- If a source is in a project, check if it is one
2078 if Proj /= No_Project then
2079 for J in Projects'Range loop
2080 if Proj = Projects (J) then
2091 -- If one of the dependent sources is in one project of
2092 -- the list, then we must recompile.
2096 Verbose_Msg (Lib_File, " wrong object directory
");
2105 ------------------------
2106 -- Check_For_S_Switch --
2107 ------------------------
2109 procedure Check_For_S_Switch is
2111 -- By default, we generate an object file
2113 Output_Is_Object := True;
2115 for Arg in 1 .. Last_Argument loop
2116 if Arguments (Arg).all = "-S
" then
2117 Output_Is_Object := False;
2119 elsif Arguments (Arg).all = "-c
" then
2120 Output_Is_Object := True;
2123 end Check_For_S_Switch;
2125 --------------------------
2126 -- Check_Linker_Options --
2127 --------------------------
2129 procedure Check_Linker_Options
2130 (E_Stamp : Time_Stamp_Type;
2131 O_File : out File_Name_Type;
2132 O_Stamp : out Time_Stamp_Type)
2134 procedure Check_File (File : File_Name_Type);
2135 -- Update O_File and O_Stamp if the given file is younger than E_Stamp
2136 -- and O_Stamp, or if O_File is No_File and File does not exist.
2138 function Get_Library_File (Name : String) return File_Name_Type;
2139 -- Return the full file name including path of a library based
2140 -- on the name specified with the -l linker option, using the
2141 -- Ada object path. Return No_File if no such file can be found.
2143 type Char_Array is array (Natural) of Character;
2144 type Char_Array_Access is access constant Char_Array;
2146 Template : Char_Array_Access;
2147 pragma Import (C, Template, "__gnat_library_template
");
2153 procedure Check_File (File : File_Name_Type) is
2154 Stamp : Time_Stamp_Type;
2155 Name : File_Name_Type := File;
2158 Get_Name_String (Name);
2160 -- Remove any trailing NUL characters
2162 while Name_Len >= Name_Buffer'First
2163 and then Name_Buffer (Name_Len) = NUL
2165 Name_Len := Name_Len - 1;
2168 if Name_Len = 0 then
2171 elsif Name_Buffer (1) = '-' then
2173 -- Do not check if File is a switch other than "-l
"
2175 if Name_Buffer (2) /= 'l' then
2179 -- The argument is a library switch, get actual name. It
2180 -- is necessary to make a copy of the relevant part of
2181 -- Name_Buffer as Get_Library_Name uses Name_Buffer as well.
2184 Base_Name : constant String := Name_Buffer (3 .. Name_Len);
2187 Name := Get_Library_File (Base_Name);
2190 if Name = No_File then
2195 Stamp := File_Stamp (Name);
2197 -- Find the youngest object file that is younger than the
2198 -- executable. If no such file exist, record the first object
2199 -- file that is not found.
2201 if (O_Stamp < Stamp and then E_Stamp < Stamp)
2202 or else (O_File = No_File and then Stamp (Stamp'First) = ' ')
2207 -- Strip the trailing NUL if present
2209 Get_Name_String (O_File);
2211 if Name_Buffer (Name_Len) = NUL then
2212 Name_Len := Name_Len - 1;
2213 O_File := Name_Find;
2218 ----------------------
2219 -- Get_Library_Name --
2220 ----------------------
2222 -- See comments in a-adaint.c about template syntax
2224 function Get_Library_File (Name : String) return File_Name_Type is
2225 File : File_Name_Type := No_File;
2230 for Ptr in Template'Range loop
2231 case Template (Ptr) is
2233 Add_Str_To_Name_Buffer (Name);
2236 File := Full_Lib_File_Name (Name_Find);
2237 exit when File /= No_File;
2244 Add_Char_To_Name_Buffer (Template (Ptr));
2248 -- The for loop exited because the end of the template
2249 -- was reached. File contains the last possible file name
2252 if File = No_File and then Name_Len > 0 then
2253 File := Full_Lib_File_Name (Name_Find);
2257 end Get_Library_File;
2259 -- Start of processing for Check_Linker_Options
2263 O_Stamp := (others => ' ');
2265 -- Process linker options from the ALI files
2267 for Opt in 1 .. Linker_Options.Last loop
2268 Check_File (File_Name_Type (Linker_Options.Table (Opt).Name));
2271 -- Process options given on the command line
2273 for Opt in Linker_Switches.First .. Linker_Switches.Last loop
2275 -- Check if the previous Opt has one of the two switches
2276 -- that take an extra parameter. (See GCC manual.)
2278 if Opt = Linker_Switches.First
2279 or else (Linker_Switches.Table (Opt - 1).all /= "-u
"
2281 Linker_Switches.Table (Opt - 1).all /= "-Xlinker
"
2283 Linker_Switches.Table (Opt - 1).all /= "-L
")
2286 Add_Str_To_Name_Buffer (Linker_Switches.Table (Opt).all);
2287 Check_File (Name_Find);
2291 end Check_Linker_Options;
2297 procedure Check_Steps is
2299 -- If either -c, -b or -l has been specified, we will not necessarily
2300 -- execute all steps.
2303 Do_Compile_Step := Do_Compile_Step and Compile_Only;
2304 Do_Bind_Step := Do_Bind_Step and Bind_Only;
2305 Do_Link_Step := Do_Link_Step and Link_Only;
2307 -- If -c has been specified, but not -b, ignore any potential -l
2309 if Do_Compile_Step and then not Do_Bind_Step then
2310 Do_Link_Step := False;
2315 -----------------------
2316 -- Collect_Arguments --
2317 -----------------------
2319 procedure Collect_Arguments
2320 (Source_File : File_Name_Type;
2322 Is_Main_Source : Boolean;
2323 Args : Argument_List)
2326 Arguments_Collected := True;
2327 Arguments_Project := No_Project;
2329 Add_Arguments (Args);
2331 if Main_Project /= No_Project then
2333 Source_File_Name : constant String :=
2334 Get_Name_String (Source_File);
2335 Compiler_Package : Prj.Package_Id;
2336 Switches : Prj.Variable_Value;
2337 Data : Project_Data;
2342 (Source_File_Name => Source_File_Name,
2343 Project => Arguments_Project,
2344 Path => Arguments_Path_Name,
2345 In_Tree => Project_Tree);
2347 -- If the source is not a source of a project file, add the
2348 -- recorded arguments. Check will be done later if the source
2349 -- need to be compiled that the switch -x has been used.
2351 if Arguments_Project = No_Project then
2352 Add_Arguments (The_Saved_Gcc_Switches.all);
2354 elsif not Project_Tree.Projects.Table
2355 (Arguments_Project).Externally_Built
2357 -- We get the project directory for the relative path
2358 -- switches and arguments.
2360 Data := Project_Tree.Projects.Table (Arguments_Project);
2362 -- If the source is in an extended project, we go to
2363 -- the ultimate extending project.
2365 while Data.Extended_By /= No_Project loop
2366 Arguments_Project := Data.Extended_By;
2367 Data := Project_Tree.Projects.Table (Arguments_Project);
2370 -- If building a dynamic or relocatable library, compile with
2371 -- PIC option, if it exists.
2373 if Data.Library and then Data.Library_Kind /= Static then
2375 PIC : constant String := MLib.Tgt.PIC_Option;
2379 Add_Arguments ((1 => new String'(PIC)));
2384 if Data.Dir_Path = null then
2386 new String'(Get_Name_String (Data.Directory.Display_Name));
2387 Project_Tree.Projects.Table (Arguments_Project) :=
2391 -- We now look for package Compiler and get the switches from
2396 (Name => Name_Compiler,
2397 In_Packages => Data.Decl.Packages,
2398 In_Tree => Project_Tree);
2400 if Compiler_Package /= No_Package then
2402 -- If package Gnatmake.Compiler exists, we get the specific
2403 -- switches for the current source, or the global switches,
2408 (Source_File => Source_File,
2409 Source_File_Name => Source_File_Name,
2410 Source_Index => Source_Index,
2411 Naming => Data.Naming,
2412 In_Package => Compiler_Package,
2413 Allow_ALI => False);
2417 case Switches.Kind is
2419 -- We have a list of switches. We add these switches,
2420 -- plus the saved gcc switches.
2425 Current : String_List_Id := Switches.Values;
2426 Element : String_Element;
2427 Number : Natural := 0;
2430 while Current /= Nil_String loop
2431 Element := Project_Tree.String_Elements.
2433 Number := Number + 1;
2434 Current := Element.Next;
2438 New_Args : Argument_List (1 .. Number);
2439 Last_New : Natural := 0;
2442 Current := Switches.Values;
2444 for Index in New_Args'Range loop
2445 Element := Project_Tree.String_Elements.
2447 Get_Name_String (Element.Value);
2449 if Name_Len > 0 then
2450 Last_New := Last_New + 1;
2451 New_Args (Last_New) :=
2452 new String'(Name_Buffer (1 .. Name_Len));
2453 Test_If_Relative_Path
2454 (New_Args (Last_New),
2455 Parent => Data.Dir_Path,
2456 Including_Non_Switch => False);
2459 Current := Element.Next;
2463 (Configuration_Pragmas_Switch
2464 (Arguments_Project) &
2465 New_Args (1 .. Last_New) &
2466 The_Saved_Gcc_Switches.all);
2470 -- We have a single switch. We add this switch,
2471 -- plus the saved gcc switches.
2474 Get_Name_String (Switches.Value);
2477 New_Args : Argument_List :=
2479 (Name_Buffer (1 .. Name_Len)));
2482 Test_If_Relative_Path
2484 Parent => Data.Dir_Path,
2485 Including_Non_Switch => False);
2487 (Configuration_Pragmas_Switch (Arguments_Project) &
2488 New_Args & The_Saved_Gcc_Switches.all);
2491 -- We have no switches from Gnatmake.Compiler.
2492 -- We add the saved gcc switches.
2496 (Configuration_Pragmas_Switch (Arguments_Project) &
2497 The_Saved_Gcc_Switches.all);
2503 -- For VMS, when compiling the main source, add switch
2504 -- -mdebug-main=_ada_ so that the executable can be debugged
2505 -- by the standard VMS debugger.
2507 if not No_Main_Subprogram
2508 and then Targparm.OpenVMS_On_Target
2509 and then Is_Main_Source
2511 -- First, check if compilation will be invoked with -g
2513 for J in 1 .. Last_Argument loop
2514 if Arguments (J)'Length >= 2
2515 and then Arguments (J) (1 .. 2) = "-g
"
2516 and then (Arguments (J)'Length < 5
2517 or else Arguments (J) (1 .. 5) /= "-gnat
")
2520 ((1 => new String'("-mdebug
-main
=_ada_
")));
2526 -- Set Output_Is_Object, depending if there is a -S switch.
2527 -- If the bind step is not performed, and there is a -S switch,
2528 -- then we will not check for a valid object file.
2531 end Collect_Arguments;
2533 ---------------------
2534 -- Compile_Sources --
2535 ---------------------
2537 procedure Compile_Sources
2538 (Main_Source : File_Name_Type;
2539 Args : Argument_List;
2540 First_Compiled_File : out File_Name_Type;
2541 Most_Recent_Obj_File : out File_Name_Type;
2542 Most_Recent_Obj_Stamp : out Time_Stamp_Type;
2543 Main_Unit : out Boolean;
2544 Compilation_Failures : out Natural;
2545 Main_Index : Int := 0;
2546 Check_Readonly_Files : Boolean := False;
2547 Do_Not_Execute : Boolean := False;
2548 Force_Compilations : Boolean := False;
2549 Keep_Going : Boolean := False;
2550 In_Place_Mode : Boolean := False;
2551 Initialize_ALI_Data : Boolean := True;
2552 Max_Process : Positive := 1)
2554 Source_Unit : Unit_Name_Type;
2555 -- Current source unit
2557 Source_File : File_Name_Type;
2558 -- Current source file
2560 Full_Source_File : File_Name_Type;
2561 -- Full name of the current source file
2563 Lib_File : File_Name_Type;
2564 -- Current library file
2566 Full_Lib_File : File_Name_Type;
2567 -- Full name of the current library file
2569 Obj_File : File_Name_Type;
2570 -- Full name of the object file corresponding to Lib_File
2572 Obj_Stamp : Time_Stamp_Type;
2573 -- Time stamp of the current object file
2575 Sfile : File_Name_Type;
2576 -- Contains the source file of the units withed by Source_File
2578 Uname : Unit_Name_Type;
2579 -- Contains the unit name of the units withed by Source_File
2582 -- ALI Id of the current ALI file
2584 -- Comment following declarations ???
2586 Read_Only : Boolean := False;
2588 Compilation_OK : Boolean;
2589 Need_To_Compile : Boolean;
2592 Text : Text_Buffer_Ptr;
2594 Mfile : Natural := No_Mapping_File;
2596 Need_To_Check_Standard_Library : Boolean :=
2597 Check_Readonly_Files
2598 and not Unique_Compile;
2600 Mapping_File_Arg : String_Access;
2602 Process_Created : Boolean := False;
2604 procedure Add_Process
2606 Sfile : File_Name_Type;
2607 Afile : File_Name_Type;
2608 Uname : Unit_Name_Type;
2609 Mfile : Natural := No_Mapping_File);
2610 -- Adds process Pid to the current list of outstanding compilation
2611 -- processes and record the full name of the source file Sfile that
2612 -- we are compiling, the name of its library file Afile and the
2613 -- name of its unit Uname. If Mfile is not equal to No_Mapping_File,
2614 -- it is the index of the mapping file used during compilation in the
2615 -- array The_Mapping_File_Names.
2617 procedure Await_Compile
2618 (Sfile : out File_Name_Type;
2619 Afile : out File_Name_Type;
2620 Uname : out Unit_Name_Type;
2622 -- Awaits that an outstanding compilation process terminates. When
2623 -- it does set Sfile to the name of the source file that was compiled
2624 -- Afile to the name of its library file and Uname to the name of its
2625 -- unit. Note that this time stamp can be used to check whether the
2626 -- compilation did generate an object file. OK is set to True if the
2627 -- compilation succeeded. Note that Sfile, Afile and Uname could be
2628 -- resp. No_File, No_File and No_Name if there were no compilations
2631 function Bad_Compilation_Count return Natural;
2632 -- Returns the number of compilation failures
2634 procedure Check_Standard_Library;
2635 -- Check if s-stalib.adb needs to be compiled
2637 procedure Collect_Arguments_And_Compile
2638 (Source_File : File_Name_Type;
2639 Source_Index : Int);
2640 -- Collect arguments from project file (if any) and compile
2643 (S : File_Name_Type;
2646 Args : Argument_List) return Process_Id;
2647 -- Compiles S using Args. If S is a GNAT predefined source "-gnatpg
" is
2648 -- added to Args. Non blocking call. L corresponds to the expected
2649 -- library file name. Process_Id of the process spawned to execute the
2652 package Good_ALI is new Table.Table (
2653 Table_Component_Type => ALI_Id,
2654 Table_Index_Type => Natural,
2655 Table_Low_Bound => 1,
2656 Table_Initial => 50,
2657 Table_Increment => 100,
2658 Table_Name => "Make
.Good_ALI
");
2659 -- Contains the set of valid ALI files that have not yet been scanned
2661 function Good_ALI_Present return Boolean;
2662 -- Returns True if any ALI file was recorded in the previous set
2664 procedure Get_Mapping_File (Project : Project_Id);
2665 -- Get a mapping file name. If there is one to be reused, reuse it.
2666 -- Otherwise, create a new mapping file.
2668 function Get_Next_Good_ALI return ALI_Id;
2669 -- Returns the next good ALI_Id record
2671 procedure Record_Failure
2672 (File : File_Name_Type;
2673 Unit : Unit_Name_Type;
2674 Found : Boolean := True);
2675 -- Records in the previous table that the compilation for File failed.
2676 -- If Found is False then the compilation of File failed because we
2677 -- could not find it. Records also Unit when possible.
2679 procedure Record_Good_ALI (A : ALI_Id);
2680 -- Records in the previous set the Id of an ALI file
2686 procedure Add_Process
2688 Sfile : File_Name_Type;
2689 Afile : File_Name_Type;
2690 Uname : Unit_Name_Type;
2691 Mfile : Natural := No_Mapping_File)
2693 OC1 : constant Positive := Outstanding_Compiles + 1;
2696 pragma Assert (OC1 <= Max_Process);
2697 pragma Assert (Pid /= Invalid_Pid);
2699 Running_Compile (OC1).Pid := Pid;
2700 Running_Compile (OC1).Full_Source_File := Sfile;
2701 Running_Compile (OC1).Lib_File := Afile;
2702 Running_Compile (OC1).Source_Unit := Uname;
2703 Running_Compile (OC1).Mapping_File := Mfile;
2704 Running_Compile (OC1).Project := Arguments_Project;
2705 Running_Compile (OC1).Syntax_Only := Syntax_Only;
2706 Running_Compile (OC1).Output_Is_Object := Output_Is_Object;
2708 Outstanding_Compiles := OC1;
2711 --------------------
2715 procedure Await_Compile
2716 (Sfile : out File_Name_Type;
2717 Afile : out File_Name_Type;
2718 Uname : out Unit_Name_Type;
2722 Project : Project_Id;
2725 pragma Assert (Outstanding_Compiles > 0);
2729 Uname := No_Unit_Name;
2732 -- The loop here is a work-around for a problem on VMS; in some
2733 -- circumstances (shared library and several executables, for
2734 -- example), there are child processes other than compilation
2735 -- processes that are received. Until this problem is resolved,
2736 -- we will ignore such processes.
2739 Wait_Process (Pid, OK);
2741 if Pid = Invalid_Pid then
2745 for J in Running_Compile'First .. Outstanding_Compiles loop
2746 if Pid = Running_Compile (J).Pid then
2747 Sfile := Running_Compile (J).Full_Source_File;
2748 Afile := Running_Compile (J).Lib_File;
2749 Uname := Running_Compile (J).Source_Unit;
2750 Syntax_Only := Running_Compile (J).Syntax_Only;
2751 Output_Is_Object := Running_Compile (J).Output_Is_Object;
2752 Project := Running_Compile (J).Project;
2754 -- If a mapping file was used by this compilation,
2755 -- get its file name for reuse by a subsequent compilation
2757 if Running_Compile (J).Mapping_File /= No_Mapping_File then
2758 Last_Free_Indices (Project) :=
2759 Last_Free_Indices (Project) + 1;
2760 The_Free_Mapping_File_Indices
2761 (Project, Last_Free_Indices (Project)) :=
2762 Running_Compile (J).Mapping_File;
2765 -- To actually remove this Pid and related info from
2766 -- Running_Compile replace its entry with the last valid
2767 -- entry in Running_Compile.
2769 if J = Outstanding_Compiles then
2773 Running_Compile (J) :=
2774 Running_Compile (Outstanding_Compiles);
2777 Outstanding_Compiles := Outstanding_Compiles - 1;
2782 -- This child process was not one of our compilation processes;
2783 -- just ignore it for now.
2785 -- raise Program_Error;
2789 ---------------------------
2790 -- Bad_Compilation_Count --
2791 ---------------------------
2793 function Bad_Compilation_Count return Natural is
2795 return Bad_Compilation.Last - Bad_Compilation.First + 1;
2796 end Bad_Compilation_Count;
2798 ----------------------------
2799 -- Check_Standard_Library --
2800 ----------------------------
2802 procedure Check_Standard_Library is
2804 Need_To_Check_Standard_Library := False;
2806 if not Targparm.Suppress_Standard_Library_On_Target then
2808 Sfile : File_Name_Type;
2809 Add_It : Boolean := True;
2812 Name_Len := Standard_Library_Package_Body_Name'Length;
2813 Name_Buffer (1 .. Name_Len) :=
2814 Standard_Library_Package_Body_Name;
2815 Sfile := Name_Enter;
2817 -- If we have a special runtime, we add the standard
2818 -- library only if we can find it.
2822 Find_File (Sfile, Osint.Source) /= No_File;
2826 if Is_Marked (Sfile) then
2827 if Is_In_Obsoleted (Sfile) then
2828 Executable_Obsolete := True;
2832 Insert_Q (Sfile, Index => 0);
2833 Mark (Sfile, Index => 0);
2838 end Check_Standard_Library;
2840 -----------------------------------
2841 -- Collect_Arguments_And_Compile --
2842 -----------------------------------
2844 procedure Collect_Arguments_And_Compile
2845 (Source_File : File_Name_Type;
2849 -- Process_Created will be set True if an attempt is made to compile
2850 -- the source, that is if it is not in an externally built project.
2852 Process_Created := False;
2854 -- If arguments not yet collected (in Check), collect them now
2856 if not Arguments_Collected then
2858 (Source_File, Source_Index, Source_File = Main_Source, Args);
2861 -- If we use mapping file (-P or -C switches), then get one
2863 if Create_Mapping_File then
2864 Get_Mapping_File (Arguments_Project);
2867 -- If the source is part of a project file, we set the ADA_*_PATHs,
2868 -- check for an eventual library project, and use the full path.
2870 if Arguments_Project /= No_Project then
2871 if not Project_Tree.Projects.Table
2872 (Arguments_Project).Externally_Built
2874 Prj.Env.Set_Ada_Paths (Arguments_Project, Project_Tree, True);
2876 if not Unique_Compile
2877 and then MLib.Tgt.Support_For_Libraries /= Prj.None
2880 The_Data : Project_Data :=
2881 Project_Tree.Projects.Table
2882 (Arguments_Project);
2884 Prj : Project_Id := Arguments_Project;
2887 while The_Data.Extended_By /= No_Project loop
2888 Prj := The_Data.Extended_By;
2889 The_Data := Project_Tree.Projects.Table (Prj);
2893 and then not The_Data.Externally_Built
2894 and then not The_Data.Need_To_Build_Lib
2896 -- Add to the Q all sources of the project that
2897 -- have not been marked
2899 Insert_Project_Sources
2900 (The_Project => Prj,
2901 All_Projects => False,
2904 -- Now mark the project as processed
2906 Project_Tree.Projects.Table
2907 (Prj).Need_To_Build_Lib := True;
2912 -- Change to the object directory of the project file,
2915 Change_To_Object_Directory (Arguments_Project);
2919 (File_Name_Type (Arguments_Path_Name),
2922 Arguments (1 .. Last_Argument));
2923 Process_Created := True;
2927 -- If this is a source outside of any project file, make sure it
2928 -- will be compiled in object directory of the main project file.
2930 if Main_Project /= No_Project then
2931 Change_To_Object_Directory (Arguments_Project);
2934 Pid := Compile (Full_Source_File, Lib_File, Source_Index,
2935 Arguments (1 .. Last_Argument));
2936 Process_Created := True;
2938 end Collect_Arguments_And_Compile;
2945 (S : File_Name_Type;
2948 Args : Argument_List) return Process_Id
2950 Comp_Args : Argument_List (Args'First .. Args'Last + 9);
2951 Comp_Next : Integer := Args'First;
2952 Comp_Last : Integer;
2953 Arg_Index : Integer;
2955 function Ada_File_Name (Name : File_Name_Type) return Boolean;
2956 -- Returns True if Name is the name of an ada source file
2957 -- (i.e. suffix is .ads or .adb)
2963 function Ada_File_Name (Name : File_Name_Type) return Boolean is
2965 Get_Name_String (Name);
2968 and then Name_Buffer (Name_Len - 3 .. Name_Len - 1) = ".ad
"
2969 and then (Name_Buffer (Name_Len) = 'b'
2971 Name_Buffer (Name_Len) = 's');
2974 -- Start of processing for Compile
2977 Enter_Into_Obsoleted (S);
2979 -- By default, Syntax_Only is False
2981 Syntax_Only := False;
2983 for J in Args'Range loop
2984 if Args (J).all = "-gnats
" then
2986 -- If we compile with -gnats, the bind step and the link step
2987 -- are inhibited. Also, we set Syntax_Only to True, so that
2988 -- we don't fail when we don't find the ALI file, after
2991 Do_Bind_Step := False;
2992 Do_Link_Step := False;
2993 Syntax_Only := True;
2995 elsif Args (J).all = "-gnatc
" then
2997 -- If we compile with -gnatc, the bind step and the link step
2998 -- are inhibited. We set Syntax_Only to False for the case when
2999 -- -gnats was previously specified.
3001 Do_Bind_Step := False;
3002 Do_Link_Step := False;
3003 Syntax_Only := False;
3007 Comp_Args (Comp_Next) := Comp_Flag;
3008 Comp_Next := Comp_Next + 1;
3010 -- Optimize the simple case where the gcc command line looks like
3011 -- gcc -c -I. ... -I- file.adb --into-> gcc -c ... file.adb
3013 if Args (Args'First).all = "-I
" & Normalized_CWD
3014 and then Args (Args'Last).all = "-I
-"
3015 and then S = Strip_Directory (S)
3017 Comp_Last := Comp_Next + Args'Length - 3;
3018 Arg_Index := Args'First + 1;
3021 Comp_Last := Comp_Next + Args'Length - 1;
3022 Arg_Index := Args'First;
3025 -- Make a deep copy of the arguments, because Normalize_Arguments
3026 -- may deallocate some arguments.
3028 for J in Comp_Next .. Comp_Last loop
3029 Comp_Args (J) := new String'(Args (Arg_Index).all);
3030 Arg_Index := Arg_Index + 1;
3033 -- Set -gnatpg for predefined files (for this purpose the renamings
3034 -- such as Text_IO do not count as predefined). Note that we strip
3035 -- the directory name from the source file name because the call to
3036 -- Fname.Is_Predefined_File_Name cannot deal with directory prefixes.
3039 Fname : constant File_Name_Type := Strip_Directory (S);
3042 if Is_Predefined_File_Name (Fname, False) then
3043 if Check_Readonly_Files then
3044 Comp_Args (Comp_Args'First + 2 .. Comp_Last + 1) :=
3045 Comp_Args (Comp_Args'First + 1 .. Comp_Last);
3046 Comp_Last := Comp_Last + 1;
3047 Comp_Args (Comp_Args'First + 1) := GNAT_Flag;
3051 ("not allowed to compile
""" &
3052 Get_Name_String (Fname) &
3053 """; use -a switch
, or compile file
with " &
3054 """-gnatg
"" switch
");
3059 -- Now check if the file name has one of the suffixes familiar to
3060 -- the gcc driver. If this is not the case then add the ada flag
3063 if not Ada_File_Name (S) and then not Targparm.AAMP_On_Target then
3064 Comp_Last := Comp_Last + 1;
3065 Comp_Args (Comp_Last) := Ada_Flag_1;
3066 Comp_Last := Comp_Last + 1;
3067 Comp_Args (Comp_Last) := Ada_Flag_2;
3070 if Source_Index /= 0 then
3072 Num : constant String := Source_Index'Img;
3074 Comp_Last := Comp_Last + 1;
3075 Comp_Args (Comp_Last) :=
3076 new String'("-gnateI
" & Num (Num'First + 1 .. Num'Last));
3080 if Source_Index /= 0
3081 or else L /= Strip_Directory (L)
3082 or else Object_Directory_Path /= null
3084 -- Build -o argument
3086 Get_Name_String (L);
3088 for J in reverse 1 .. Name_Len loop
3089 if Name_Buffer (J) = '.' then
3090 Name_Len := J + Object_Suffix'Length - 1;
3091 Name_Buffer (J .. Name_Len) := Object_Suffix;
3096 Comp_Last := Comp_Last + 1;
3097 Comp_Args (Comp_Last) := Output_Flag;
3098 Comp_Last := Comp_Last + 1;
3100 -- If an object directory was specified, prepend the object file
3101 -- name with this object directory.
3103 if Object_Directory_Path /= null then
3104 Comp_Args (Comp_Last) :=
3105 new String'(Object_Directory_Path.all &
3106 Name_Buffer (1 .. Name_Len));
3109 Comp_Args (Comp_Last) :=
3110 new String'(Name_Buffer (1 .. Name_Len));
3114 if Create_Mapping_File then
3115 Comp_Last := Comp_Last + 1;
3116 Comp_Args (Comp_Last) := Mapping_File_Arg;
3119 Get_Name_String (S);
3121 Comp_Last := Comp_Last + 1;
3122 Comp_Args (Comp_Last) := new String'(Name_Buffer (1 .. Name_Len));
3124 GNAT.OS_Lib.Normalize_Arguments (Comp_Args (Args'First .. Comp_Last));
3126 Comp_Last := Comp_Last + 1;
3127 Comp_Args (Comp_Last) := new String'("-gnatez
");
3129 Display (Gcc.all, Comp_Args (Args'First .. Comp_Last));
3131 if Gcc_Path = null then
3132 Make_Failed ("error
, unable to locate
", Gcc.all);
3136 GNAT.OS_Lib.Non_Blocking_Spawn
3137 (Gcc_Path.all, Comp_Args (Args'First .. Comp_Last));
3140 ----------------------
3141 -- Get_Mapping_File --
3142 ----------------------
3144 procedure Get_Mapping_File (Project : Project_Id) is
3146 -- If there is a mapping file ready to be reused, reuse it
3148 if Last_Free_Indices (Project) > 0 then
3149 Mfile := The_Free_Mapping_File_Indices
3150 (Project, Last_Free_Indices (Project));
3151 Last_Free_Indices (Project) := Last_Free_Indices (Project) - 1;
3153 -- Otherwise, create and initialize a new one
3156 Init_Mapping_File (Project => Project, File_Index => Mfile);
3159 -- Put the name in the mapping file argument for the invocation
3162 Free (Mapping_File_Arg);
3164 new String'("-gnatem
=" &
3166 (The_Mapping_File_Names (Project, Mfile)));
3168 end Get_Mapping_File;
3170 -----------------------
3171 -- Get_Next_Good_ALI --
3172 -----------------------
3174 function Get_Next_Good_ALI return ALI_Id is
3178 pragma Assert (Good_ALI_Present);
3179 ALI := Good_ALI.Table (Good_ALI.Last);
3180 Good_ALI.Decrement_Last;
3182 end Get_Next_Good_ALI;
3184 ----------------------
3185 -- Good_ALI_Present --
3186 ----------------------
3188 function Good_ALI_Present return Boolean is
3190 return Good_ALI.First <= Good_ALI.Last;
3191 end Good_ALI_Present;
3193 --------------------
3194 -- Record_Failure --
3195 --------------------
3197 procedure Record_Failure
3198 (File : File_Name_Type;
3199 Unit : Unit_Name_Type;
3200 Found : Boolean := True)
3203 Bad_Compilation.Increment_Last;
3204 Bad_Compilation.Table (Bad_Compilation.Last) := (File, Unit, Found);
3207 ---------------------
3208 -- Record_Good_ALI --
3209 ---------------------
3211 procedure Record_Good_ALI (A : ALI_Id) is
3213 Good_ALI.Increment_Last;
3214 Good_ALI.Table (Good_ALI.Last) := A;
3215 end Record_Good_ALI;
3217 -- Start of processing for Compile_Sources
3220 pragma Assert (Args'First = 1);
3222 Outstanding_Compiles := 0;
3223 Running_Compile := new Comp_Data_Arr (1 .. Max_Process);
3225 -- Package and Queue initializations
3229 if First_Q_Initialization then
3233 if Initialize_ALI_Data then
3235 Initialize_ALI_Source;
3238 -- The following two flags affect the behavior of ALI.Set_Source_Table.
3239 -- We set Check_Source_Files to True to ensure that source file
3240 -- time stamps are checked, and we set All_Sources to False to
3241 -- avoid checking the presence of the source files listed in the
3242 -- source dependency section of an ali file (which would be a mistake
3243 -- since the ali file may be obsolete).
3245 Check_Source_Files := True;
3246 All_Sources := False;
3248 -- Only insert in the Q if it is not already done, to avoid simultaneous
3249 -- compilations if -jnnn is used.
3251 if not Is_Marked (Main_Source, Main_Index) then
3252 Insert_Q (Main_Source, Index => Main_Index);
3253 Mark (Main_Source, Main_Index);
3256 First_Compiled_File := No_File;
3257 Most_Recent_Obj_File := No_File;
3258 Most_Recent_Obj_Stamp := Empty_Time_Stamp;
3261 -- Keep looping until there is no more work to do (the Q is empty)
3262 -- and all the outstanding compilations have terminated
3264 Make_Loop : while not Empty_Q or else Outstanding_Compiles > 0 loop
3266 -- If the user does not want to keep going in case of errors then
3267 -- wait for the remaining outstanding compiles and then exit.
3269 if Bad_Compilation_Count > 0 and then not Keep_Going then
3270 while Outstanding_Compiles > 0 loop
3272 (Full_Source_File, Lib_File, Source_Unit, Compilation_OK);
3274 if not Compilation_OK then
3275 Record_Failure (Full_Source_File, Source_Unit);
3282 -- PHASE 1: Check if there is more work that we can do (i.e. the Q
3283 -- is non empty). If there is, do it only if we have not yet used
3284 -- up all the available processes.
3286 if not Empty_Q and then Outstanding_Compiles < Max_Process then
3289 -- Index of the current unit in the current source file
3292 Extract_From_Q (Source_File, Source_Unit, Source_Index);
3293 Full_Source_File := Osint.Full_Source_Name (Source_File);
3294 Lib_File := Osint.Lib_File_Name
3295 (Source_File, Source_Index);
3296 Full_Lib_File := Osint.Full_Lib_File_Name (Lib_File);
3298 -- If this source has already been compiled, the executable is
3301 if Is_In_Obsoleted (Source_File) then
3302 Executable_Obsolete := True;
3305 -- If the library file is an Ada library skip it
3307 if Full_Lib_File /= No_File
3308 and then In_Ada_Lib_Dir (Full_Lib_File)
3312 "is in an Ada library
",
3314 Minimum_Verbosity => Opt.High);
3316 -- If the library file is a read-only library skip it, but
3317 -- only if, when using project files, this library file is
3318 -- in the right object directory (a read-only ALI file
3319 -- in the object directory of a project being extended
3320 -- should not be skipped).
3322 elsif Full_Lib_File /= No_File
3323 and then not Check_Readonly_Files
3324 and then Is_Readonly_Library (Full_Lib_File)
3325 and then Is_In_Object_Directory (Source_File, Full_Lib_File)
3329 "is a read
-only library
",
3331 Minimum_Verbosity => Opt.High);
3333 -- The source file that we are checking cannot be located
3335 elsif Full_Source_File = No_File then
3336 Record_Failure (Source_File, Source_Unit, False);
3338 -- Source and library files can be located but are internal
3341 elsif not Check_Readonly_Files
3342 and then Full_Lib_File /= No_File
3343 and then Is_Internal_File_Name (Source_File, False)
3345 if Force_Compilations then
3347 ("not allowed to compile
""" &
3348 Get_Name_String (Source_File) &
3349 """; use -a switch
, or compile file
with " &
3350 """-gnatg
"" switch
");
3355 "is an internal library
",
3357 Minimum_Verbosity => Opt.High);
3359 -- The source file that we are checking can be located
3362 Arguments_Collected := False;
3364 Collect_Arguments (Source_File, Source_Index,
3365 Source_File = Main_Source, Args);
3367 -- Do nothing if project of source is externally built
3369 if Arguments_Project = No_Project
3370 or else not Project_Tree.Projects.Table
3371 (Arguments_Project).Externally_Built
3373 -- Don't waste any time if we have to recompile anyway
3375 Obj_Stamp := Empty_Time_Stamp;
3376 Need_To_Compile := Force_Compilations;
3378 if not Force_Compilations then
3380 Full_Lib_File /= No_File
3381 and then not Check_Readonly_Files
3382 and then Is_Readonly_Library (Full_Lib_File);
3383 Check (Source_File, Source_Index,
3384 Source_File = Main_Source, Args, Lib_File,
3385 Read_Only, ALI, Obj_File, Obj_Stamp);
3386 Need_To_Compile := (ALI = No_ALI_Id);
3389 if not Need_To_Compile then
3390 -- The ALI file is up-to-date. Record its Id
3392 Record_Good_ALI (ALI);
3394 -- Record the time stamp of the most recent object
3395 -- file as long as no (re)compilations are needed.
3397 if First_Compiled_File = No_File
3398 and then (Most_Recent_Obj_File = No_File
3399 or else Obj_Stamp > Most_Recent_Obj_Stamp)
3401 Most_Recent_Obj_File := Obj_File;
3402 Most_Recent_Obj_Stamp := Obj_Stamp;
3406 -- Check that switch -x has been used if a source
3407 -- outside of project files need to be compiled.
3409 if Main_Project /= No_Project
3410 and then Arguments_Project = No_Project
3411 and then not External_Unit_Compilation_Allowed
3413 Make_Failed ("external source
(",
3414 Get_Name_String (Source_File),
3415 ") is not part
of any project
;"
3416 & " cannot be compiled without
" &
3417 " gnatmake switch
-x
");
3420 -- Is this the first file we have to compile?
3422 if First_Compiled_File = No_File then
3423 First_Compiled_File := Full_Source_File;
3424 Most_Recent_Obj_File := No_File;
3426 if Do_Not_Execute then
3431 if In_Place_Mode then
3433 -- If the library file was not found, then save
3434 -- the library file near the source file.
3436 if Full_Lib_File = No_File then
3437 Lib_File := Osint.Lib_File_Name
3438 (Full_Source_File, Source_Index);
3440 -- If the library file was found, then save the
3441 -- library file in the same place.
3444 Lib_File := Full_Lib_File;
3449 -- Start the compilation and record it. We can do
3450 -- this because there is at least one free process.
3452 Collect_Arguments_And_Compile
3453 (Source_File, Source_Index);
3455 -- Make sure we could successfully start
3458 if Process_Created then
3459 if Pid = Invalid_Pid then
3460 Record_Failure (Full_Source_File, Source_Unit);
3476 -- PHASE 2: Now check if we should wait for a compilation to
3477 -- finish. This is the case if all the available processes are
3478 -- busy compiling sources or there is nothing else to do
3479 -- (that is the Q is empty and there are no good ALIs to process).
3481 if Outstanding_Compiles = Max_Process
3483 and then not Good_ALI_Present
3484 and then Outstanding_Compiles > 0)
3487 (Full_Source_File, Lib_File, Source_Unit, Compilation_OK);
3489 if not Compilation_OK then
3490 Record_Failure (Full_Source_File, Source_Unit);
3493 if Compilation_OK or else Keep_Going then
3495 -- Re-read the updated library file
3498 Saved_Object_Consistency : constant Boolean :=
3499 Check_Object_Consistency;
3502 -- If compilation was not OK, or if output is not an
3503 -- object file and we don't do the bind step, don't check
3504 -- for object consistency.
3506 Check_Object_Consistency :=
3507 Check_Object_Consistency
3509 and (Output_Is_Object or Do_Bind_Step);
3510 Text := Read_Library_Info (Lib_File);
3512 -- Restore Check_Object_Consistency to its initial value
3514 Check_Object_Consistency := Saved_Object_Consistency;
3517 -- If an ALI file was generated by this compilation, scan
3518 -- the ALI file and record it.
3520 -- If the scan fails, a previous ali file is inconsistent with
3521 -- the unit just compiled.
3523 if Text /= null then
3525 Scan_ALI (Lib_File, Text, Ignore_ED => False, Err => True);
3527 if ALI = No_ALI_Id then
3529 -- Record a failure only if not already done
3531 if Compilation_OK then
3534 "incompatible ALI file
, please recompile
");
3535 Record_Failure (Full_Source_File, Source_Unit);
3539 Record_Good_ALI (ALI);
3542 -- If we could not read the ALI file that was just generated
3543 -- then there could be a problem reading either the ALI or the
3544 -- corresponding object file (if Check_Object_Consistency is
3545 -- set Read_Library_Info checks that the time stamp of the
3546 -- object file is more recent than that of the ALI). However,
3547 -- we record a failure only if not already done.
3550 if Compilation_OK and not Syntax_Only then
3553 "WARNING
: ALI
or object file
not found after compile
");
3554 Record_Failure (Full_Source_File, Source_Unit);
3560 -- PHASE 3: Check if we recorded good ALI files. If yes process
3561 -- them now in the order in which they have been recorded. There
3562 -- are two occasions in which we record good ali files. The first is
3563 -- in phase 1 when, after scanning an existing ALI file we realize
3564 -- it is up-to-date, the second instance is after a successful
3567 while Good_ALI_Present loop
3568 ALI := Get_Next_Good_ALI;
3571 Source_Index : Int := Unit_Index_Of (ALIs.Table (ALI).Afile);
3574 -- If we are processing the library file corresponding to the
3575 -- main source file check if this source can be a main unit.
3577 if ALIs.Table (ALI).Sfile = Main_Source and then
3578 Source_Index = Main_Index
3580 Main_Unit := ALIs.Table (ALI).Main_Program /= None;
3583 -- The following adds the standard library (s-stalib) to the
3584 -- list of files to be handled by gnatmake: this file and any
3585 -- files it depends on are always included in every bind,
3586 -- even if they are not in the explicit dependency list.
3587 -- Of course, it is not added if Suppress_Standard_Library
3590 -- However, to avoid annoying output about s-stalib.ali being
3591 -- read only, when "-v
" is used, we add the standard library
3592 -- only when "-a
" is used.
3594 if Need_To_Check_Standard_Library then
3595 Check_Standard_Library;
3598 -- Now insert in the Q the unmarked source files (i.e. those
3599 -- which have never been inserted in the Q and hence never
3600 -- considered). Only do that if Unique_Compile is False.
3602 if not Unique_Compile then
3604 ALIs.Table (ALI).First_Unit .. ALIs.Table (ALI).Last_Unit
3607 Units.Table (J).First_With .. Units.Table (J).Last_With
3609 Sfile := Withs.Table (K).Sfile;
3610 Uname := Withs.Table (K).Uname;
3612 -- If project files are used, find the proper source
3613 -- to compile, in case Sfile is the spec, but there
3616 if Main_Project /= No_Project then
3618 Unit_Name : Name_Id;
3619 Uid : Prj.Unit_Index;
3623 Get_Name_String (Uname);
3624 Name_Len := Name_Len - 2;
3625 Unit_Name := Name_Find;
3628 (Project_Tree.Units_HT, Unit_Name);
3630 if Uid /= Prj.No_Unit_Index then
3631 Udata := Project_Tree.Units.Table (Uid);
3634 Udata.File_Names (Body_Part).Name /=
3637 Udata.File_Names (Body_Part).Path.Name /=
3640 Sfile := Udata.File_Names (Body_Part).Name;
3642 Udata.File_Names (Body_Part).Index;
3645 Udata.File_Names (Specification).Name /=
3649 (Specification).Path.Name /= Slash
3652 Udata.File_Names (Specification).Name;
3654 Udata.File_Names (Specification).Index;
3660 Dependencies.Append ((ALIs.Table (ALI).Sfile, Sfile));
3662 if Is_In_Obsoleted (Sfile) then
3663 Executable_Obsolete := True;
3666 if Sfile = No_File then
3668 ("Skipping
generic:", Withs.Table (K).Uname);
3672 Unit_Index_Of (Withs.Table (K).Afile);
3674 if Is_Marked (Sfile, Source_Index) then
3675 Debug_Msg ("Skipping marked file
:", Sfile);
3677 elsif not Check_Readonly_Files
3678 and then Is_Internal_File_Name (Sfile, False)
3680 Debug_Msg ("Skipping internal file
:", Sfile);
3684 (Sfile, Withs.Table (K).Uname, Source_Index);
3685 Mark (Sfile, Source_Index);
3694 if Display_Compilation_Progress then
3695 Write_Str ("completed
");
3696 Write_Int (Int (Q_Front));
3697 Write_Str (" out of ");
3698 Write_Int (Int (Q.Last));
3700 Write_Int (Int ((Q_Front * 100) / (Q.Last - Q.First)));
3701 Write_Str ("%)...");
3706 Compilation_Failures := Bad_Compilation_Count;
3708 -- Compilation is finished
3710 -- Delete any temporary configuration pragma file
3712 if not Debug.Debug_Flag_N then
3713 Delete_Temp_Config_Files;
3715 end Compile_Sources;
3717 -----------------------------------
3718 -- Compute_All_Imported_Projects --
3719 -----------------------------------
3721 procedure Compute_All_Imported_Projects (Project : Project_Id) is
3722 procedure Add_To_List (Prj : Project_Id);
3723 -- Add a project to the list All_Imported_Projects of project Project
3725 procedure Recursive_Add_Imported (Project : Project_Id);
3726 -- Recursively add the projects imported by project Project, but not
3727 -- those that are extended.
3733 procedure Add_To_List (Prj : Project_Id) is
3734 Element : constant Project_Element :=
3735 (Prj, Project_Tree.Projects.Table (Project).All_Imported_Projects);
3736 List : Project_List;
3738 Project_List_Table.Increment_Last (Project_Tree.Project_Lists);
3739 List := Project_List_Table.Last (Project_Tree.Project_Lists);
3740 Project_Tree.Project_Lists.Table (List) := Element;
3741 Project_Tree.Projects.Table (Project).All_Imported_Projects := List;
3744 ----------------------------
3745 -- Recursive_Add_Imported --
3746 ----------------------------
3748 procedure Recursive_Add_Imported (Project : Project_Id) is
3749 List : Project_List;
3750 Element : Project_Element;
3754 if Project /= No_Project then
3756 -- For all the imported projects
3758 List := Project_Tree.Projects.Table (Project).Imported_Projects;
3759 while List /= Empty_Project_List loop
3760 Element := Project_Tree.Project_Lists.Table (List);
3761 Prj := Element.Project;
3763 -- Get the ultimate extending project
3766 Project_Tree.Projects.Table (Prj).Extended_By /= No_Project
3768 Prj := Project_Tree.Projects.Table (Prj).Extended_By;
3771 -- If project has not yet been visited, add to list and recurse
3773 if not Project_Tree.Projects.Table (Prj).Seen then
3774 Project_Tree.Projects.Table (Prj).Seen := True;
3776 Recursive_Add_Imported (Prj);
3779 List := Element.Next;
3782 -- Recurse on projects being imported, if any
3784 Recursive_Add_Imported
3785 (Project_Tree.Projects.Table (Project).Extends);
3787 end Recursive_Add_Imported;
3790 -- Reset the Seen flag for all projects
3792 for Index in 1 .. Project_Table.Last (Project_Tree.Projects) loop
3793 Project_Tree.Projects.Table (Index).Seen := False;
3796 -- Make sure the list is empty
3798 Project_Tree.Projects.Table (Project).All_Imported_Projects :=
3801 -- Add to the list all projects imported directly or indirectly
3803 Recursive_Add_Imported (Project);
3804 end Compute_All_Imported_Projects;
3806 ----------------------------------
3807 -- Configuration_Pragmas_Switch --
3808 ----------------------------------
3810 function Configuration_Pragmas_Switch
3811 (For_Project : Project_Id) return Argument_List
3813 The_Packages : Package_Id;
3814 Gnatmake : Package_Id;
3815 Compiler : Package_Id;
3817 Global_Attribute : Variable_Value := Nil_Variable_Value;
3818 Local_Attribute : Variable_Value := Nil_Variable_Value;
3820 Global_Attribute_Present : Boolean := False;
3821 Local_Attribute_Present : Boolean := False;
3823 Result : Argument_List (1 .. 3);
3824 Last : Natural := 0;
3826 function Absolute_Path
3827 (Path : Path_Name_Type;
3828 Project : Project_Id) return String;
3829 -- Returns an absolute path for a configuration pragmas file
3835 function Absolute_Path
3836 (Path : Path_Name_Type;
3837 Project : Project_Id) return String
3840 Get_Name_String (Path);
3843 Path_Name : constant String := Name_Buffer (1 .. Name_Len);
3846 if Is_Absolute_Path (Path_Name) then
3851 Parent_Directory : constant String :=
3853 (Project_Tree.Projects.Table
3854 (Project).Directory.Display_Name);
3857 if Parent_Directory (Parent_Directory'Last) =
3860 return Parent_Directory & Path_Name;
3863 return Parent_Directory & Directory_Separator & Path_Name;
3870 -- Start of processing for Configuration_Pragmas_Switch
3873 Prj.Env.Create_Config_Pragmas_File
3874 (For_Project, Main_Project, Project_Tree);
3876 if Project_Tree.Projects.Table
3877 (For_Project).Config_File_Name /= No_Path
3879 Temporary_Config_File :=
3880 Project_Tree.Projects.Table (For_Project).Config_File_Temp;
3886 (Project_Tree.Projects.Table
3887 (For_Project).Config_File_Name));
3890 Temporary_Config_File := False;
3893 -- Check for attribute Builder'Global_Configuration_Pragmas
3895 The_Packages := Project_Tree.Projects.Table
3896 (Main_Project).Decl.Packages;
3899 (Name => Name_Builder,
3900 In_Packages => The_Packages,
3901 In_Tree => Project_Tree);
3903 if Gnatmake /= No_Package then
3904 Global_Attribute := Prj.Util.Value_Of
3905 (Variable_Name => Name_Global_Configuration_Pragmas,
3906 In_Variables => Project_Tree.Packages.Table
3907 (Gnatmake).Decl.Attributes,
3908 In_Tree => Project_Tree);
3909 Global_Attribute_Present :=
3910 Global_Attribute /= Nil_Variable_Value
3911 and then Get_Name_String (Global_Attribute.Value) /= "";
3913 if Global_Attribute_Present then
3915 Path : constant String :=
3917 (Path_Name_Type (Global_Attribute.Value),
3918 Global_Attribute.Project);
3920 if not Is_Regular_File (Path) then
3921 if Debug.Debug_Flag_F then
3923 ("cannot find configuration pragmas file
",
3927 ("cannot find configuration pragmas file
",
3933 Result (Last) := new String'("-gnatec
=" & Path);
3938 -- Check for attribute Compiler'Local_Configuration_Pragmas
3941 Project_Tree.Projects.Table (For_Project).Decl.Packages;
3944 (Name => Name_Compiler,
3945 In_Packages => The_Packages,
3946 In_Tree => Project_Tree);
3948 if Compiler /= No_Package then
3949 Local_Attribute := Prj.Util.Value_Of
3950 (Variable_Name => Name_Local_Configuration_Pragmas,
3951 In_Variables => Project_Tree.Packages.Table
3952 (Compiler).Decl.Attributes,
3953 In_Tree => Project_Tree);
3954 Local_Attribute_Present :=
3955 Local_Attribute /= Nil_Variable_Value
3956 and then Get_Name_String (Local_Attribute.Value) /= "";
3958 if Local_Attribute_Present then
3960 Path : constant String :=
3962 (Path_Name_Type (Local_Attribute.Value),
3963 Local_Attribute.Project);
3965 if not Is_Regular_File (Path) then
3966 if Debug.Debug_Flag_F then
3968 ("cannot find configuration pragmas file
",
3973 ("cannot find configuration pragmas file
", Path);
3978 Result (Last) := new String'("-gnatec
=" & Path);
3983 return Result (1 .. Last);
3984 end Configuration_Pragmas_Switch;
3990 procedure Debug_Msg (S : String; N : Name_Id) is
3992 if Debug.Debug_Flag_W then
3993 Write_Str (" ... ");
4001 procedure Debug_Msg (S : String; N : File_Name_Type) is
4003 Debug_Msg (S, Name_Id (N));
4006 procedure Debug_Msg (S : String; N : Unit_Name_Type) is
4008 Debug_Msg (S, Name_Id (N));
4011 ---------------------------
4012 -- Delete_All_Temp_Files --
4013 ---------------------------
4015 procedure Delete_All_Temp_Files is
4017 if not Debug.Debug_Flag_N then
4018 Delete_Mapping_Files;
4019 Delete_Temp_Config_Files;
4020 Prj.Env.Delete_All_Path_Files (Project_Tree);
4022 end Delete_All_Temp_Files;
4024 --------------------------
4025 -- Delete_Mapping_Files --
4026 --------------------------
4028 procedure Delete_Mapping_Files is
4030 pragma Warnings (Off, Success);
4033 -- The caller is responsible for ensuring that Debug_Flag_N is False
4035 pragma Assert (not Debug.Debug_Flag_N);
4037 if The_Mapping_File_Names /= null then
4038 for Project in The_Mapping_File_Names'Range (1) loop
4039 for Index in 1 .. Last_Mapping_File_Names (Project) loop
4041 (Name => Get_Name_String
4042 (The_Mapping_File_Names (Project, Index)),
4043 Success => Success);
4047 end Delete_Mapping_Files;
4049 ------------------------------
4050 -- Delete_Temp_Config_Files --
4051 ------------------------------
4053 procedure Delete_Temp_Config_Files is
4055 pragma Warnings (Off, Success);
4058 -- The caller is responsible for ensuring that Debug_Flag_N is False
4060 pragma Assert (not Debug.Debug_Flag_N);
4062 if Main_Project /= No_Project then
4063 for Project in Project_Table.First ..
4064 Project_Table.Last (Project_Tree.Projects)
4067 Project_Tree.Projects.Table (Project).Config_File_Temp
4069 if Verbose_Mode then
4070 Write_Str ("Deleting temp configuration file
""");
4071 Write_Str (Get_Name_String
4072 (Project_Tree.Projects.Table
4073 (Project).Config_File_Name));
4078 (Name => Get_Name_String
4079 (Project_Tree.Projects.Table
4080 (Project).Config_File_Name),
4081 Success => Success);
4083 -- Make sure that we don't have a config file for this project,
4084 -- in case there are several mains. In this case, we will
4085 -- recreate another config file: we cannot reuse the one that
4088 Project_Tree.Projects.Table (Project).
4089 Config_Checked := False;
4090 Project_Tree.Projects.Table (Project).
4091 Config_File_Name := No_Path;
4092 Project_Tree.Projects.Table (Project).
4093 Config_File_Temp := False;
4097 end Delete_Temp_Config_Files;
4103 procedure Display (Program : String; Args : Argument_List) is
4105 pragma Assert (Args'First = 1);
4107 if Display_Executed_Programs then
4108 Write_Str (Program);
4110 for J in Args'Range loop
4112 -- Never display -gnatez
4114 if Args (J).all /= "-gnatez
" then
4116 -- Do not display the mapping file argument automatically
4117 -- created when using a project file.
4119 if Main_Project = No_Project
4120 or else Debug.Debug_Flag_N
4121 or else Args (J)'Length < 8
4123 Args (J) (Args (J)'First .. Args (J)'First + 6) /= "-gnatem
"
4125 -- When -dn is not specified, do not display the config
4126 -- pragmas switch (-gnatec) for the temporary file created
4127 -- by the project manager (always the first -gnatec switch).
4128 -- Reset Temporary_Config_File to False so that the eventual
4129 -- other -gnatec switches will be displayed.
4131 if (not Debug.Debug_Flag_N)
4132 and then Temporary_Config_File
4133 and then Args (J)'Length > 7
4134 and then Args (J) (Args (J)'First .. Args (J)'First + 6)
4137 Temporary_Config_File := False;
4139 -- Do not display the -F=mapping_file switch for
4140 -- gnatbind, if -dn is not specified.
4142 elsif Debug.Debug_Flag_N
4143 or else Args (J)'Length < 4
4145 Args (J) (Args (J)'First .. Args (J)'First + 2) /= "-F
="
4149 -- If -df is used, only display file names, not path
4152 if Debug.Debug_Flag_F then
4154 Equal_Pos : Natural;
4156 Equal_Pos := Args (J)'First - 1;
4157 for K in Args (J)'Range loop
4158 if Args (J) (K) = '=' then
4165 (Args (J) (Equal_Pos + 1 .. Args (J)'Last))
4168 (Args (J) (Args (J)'First .. Equal_Pos));
4172 (Equal_Pos + 1 .. Args (J)'Last)));
4175 Write_Str (Args (J).all);
4180 Write_Str (Args (J).all);
4191 ----------------------
4192 -- Display_Commands --
4193 ----------------------
4195 procedure Display_Commands (Display : Boolean := True) is
4197 Display_Executed_Programs := Display;
4198 end Display_Commands;
4204 function Empty_Q return Boolean is
4206 if Debug.Debug_Flag_P then
4207 Write_Str (" Q
:= [");
4209 for J in Q_Front .. Q.Last - 1 loop
4211 Write_Name (Q.Table (J).File);
4220 return Q_Front >= Q.Last;
4223 --------------------------
4224 -- Enter_Into_Obsoleted --
4225 --------------------------
4227 procedure Enter_Into_Obsoleted (F : File_Name_Type) is
4228 Name : constant String := Get_Name_String (F);
4230 F2 : File_Name_Type;
4234 while First > Name'First
4235 and then Name (First - 1) /= Directory_Separator
4236 and then Name (First - 1) /= '/'
4241 if First /= Name'First then
4243 Add_Str_To_Name_Buffer (Name (First .. Name'Last));
4250 Debug_Msg ("New entry in Obsoleted table
:", F2);
4251 Obsoleted.Set (F2, True);
4252 end Enter_Into_Obsoleted;
4254 --------------------
4255 -- Extract_From_Q --
4256 --------------------
4258 procedure Extract_From_Q
4259 (Source_File : out File_Name_Type;
4260 Source_Unit : out Unit_Name_Type;
4261 Source_Index : out Int)
4263 File : constant File_Name_Type := Q.Table (Q_Front).File;
4264 Unit : constant Unit_Name_Type := Q.Table (Q_Front).Unit;
4265 Index : constant Int := Q.Table (Q_Front).Index;
4268 if Debug.Debug_Flag_Q then
4269 Write_Str (" Q
:= Q
- [ ");
4281 Q_Front := Q_Front + 1;
4282 Source_File := File;
4283 Source_Unit := Unit;
4284 Source_Index := Index;
4291 procedure Gnatmake is
4292 Main_Source_File : File_Name_Type;
4293 -- The source file containing the main compilation unit
4295 Compilation_Failures : Natural;
4297 Total_Compilation_Failures : Natural := 0;
4299 Is_Main_Unit : Boolean;
4300 -- Set to True by Compile_Sources if the Main_Source_File can be a
4303 Main_ALI_File : File_Name_Type;
4304 -- The ali file corresponding to Main_Source_File
4306 Executable : File_Name_Type := No_File;
4307 -- The file name of an executable
4309 Non_Std_Executable : Boolean := False;
4310 -- Non_Std_Executable is set to True when there is a possibility
4311 -- that the linker will not choose the correct executable file name.
4313 Current_Work_Dir : constant String_Access :=
4314 new String'(Get_Current_Dir);
4315 -- The current working directory, used to modify some relative path
4316 -- switches on the command line when a project file is used.
4318 Current_Main_Index : Int := 0;
4319 -- If not zero, the index of the current main unit in its source file
4321 There_Are_Stand_Alone_Libraries : Boolean := False;
4322 -- Set to True when there are Stand-Alone Libraries, so that gnatbind
4323 -- is invoked with the -F switch to force checking of elaboration flags.
4325 Mapping_Path : Path_Name_Type := No_Path;
4326 -- The path name of the mapping file
4329 pragma Warnings (Off, Discard);
4331 procedure Check_Mains;
4332 -- Check that the main subprograms do exist and that they all
4333 -- belong to the same project file.
4335 procedure Create_Binder_Mapping_File
4336 (Args : in out Argument_List; Last_Arg : in out Natural);
4337 -- Create a binder mapping file and add the necessary switch
4343 procedure Check_Mains is
4344 Real_Main_Project : Project_Id := No_Project;
4345 -- The project of the first main
4347 Proj : Project_Id := No_Project;
4348 -- The project of the current main
4350 Data : Project_Data;
4352 Real_Path : String_Access;
4361 Main : constant String := Mains.Next_Main;
4362 -- The name specified on the command line may include
4363 -- directory information.
4365 File_Name : constant String := Base_Name (Main);
4366 -- The simple file name of the current main main
4369 exit when Main = "";
4371 -- Get the project of the current main
4373 Proj := Prj.Env.Project_Of
4374 (File_Name, Main_Project, Project_Tree);
4376 -- Fail if the current main is not a source of a
4379 if Proj = No_Project then
4382 """ is not a source
of any project
");
4385 -- If there is directory information, check that
4386 -- the source exists and, if it does, that the path
4387 -- is the actual path of a source of a project.
4389 if Main /= File_Name then
4391 Project_Tree.Projects.Table (Main_Project);
4396 Body_Suffix_Of (Project_Tree, "ada
", Data.Naming),
4398 if Real_Path = null then
4402 Spec_Suffix_Of (Project_Tree, "ada
", Data.Naming),
4406 if Real_Path = null then
4408 Locate_Regular_File (Main, "");
4411 -- Fail if the file cannot be found
4413 if Real_Path = null then
4415 ("file
""" & Main & """ does
not exist
");
4419 Project_Path : constant String :=
4420 Prj.Env.File_Name_Of_Library_Unit_Body
4422 Project => Main_Project,
4423 In_Tree => Project_Tree,
4424 Main_Project_Only => False,
4426 Normed_Path : constant String :=
4429 Case_Sensitive => False);
4430 Proj_Path : constant String :=
4433 Case_Sensitive => False);
4438 -- Fail if it is not the correct path
4440 if Normed_Path /= Proj_Path then
4441 if Verbose_Mode then
4443 Write_Str (Normed_Path);
4445 Write_Line (Proj_Path);
4450 """ is not a source
of any project
");
4455 if not Unique_Compile then
4457 -- Record the project, if it is the first main
4459 if Real_Main_Project = No_Project then
4460 Real_Main_Project := Proj;
4462 elsif Proj /= Real_Main_Project then
4464 -- Fail, as the current main is not a source
4465 -- of the same project as the first main.
4469 """ is not a source
of project
" &
4471 (Project_Tree.Projects.Table
4472 (Real_Main_Project).Name));
4477 -- If -u and -U are not used, we may have mains that
4478 -- are sources of a project that is not the one
4479 -- specified with switch -P.
4481 if not Unique_Compile then
4482 Main_Project := Real_Main_Project;
4488 --------------------------------
4489 -- Create_Binder_Mapping_File --
4490 --------------------------------
4492 procedure Create_Binder_Mapping_File
4493 (Args : in out Argument_List; Last_Arg : in out Natural)
4495 Mapping_FD : File_Descriptor := Invalid_FD;
4496 -- A File Descriptor for an eventual mapping file
4498 ALI_Unit : Unit_Name_Type := No_Unit_Name;
4499 -- The unit name of an ALI file
4501 ALI_Name : File_Name_Type := No_File;
4502 -- The file name of the ALI file
4504 ALI_Project : Project_Id := No_Project;
4505 -- The project of the ALI file
4508 OK : Boolean := True;
4511 -- For call to Close
4514 Tempdir.Create_Temp_File (Mapping_FD, Mapping_Path);
4515 Record_Temp_File (Mapping_Path);
4517 if Mapping_FD /= Invalid_FD then
4519 -- Traverse all units
4521 for J in Unit_Table.First ..
4522 Unit_Table.Last (Project_Tree.Units)
4525 Unit : constant Unit_Data := Project_Tree.Units.Table (J);
4527 if Unit.Name /= No_Name then
4529 -- If there is a body, put it in the mapping
4531 if Unit.File_Names (Body_Part).Name /= No_File
4532 and then Unit.File_Names (Body_Part).Project /=
4535 Get_Name_String (Unit.Name);
4536 Name_Buffer (Name_Len + 1 .. Name_Len + 2) := "%b
";
4537 Name_Len := Name_Len + 2;
4538 ALI_Unit := Name_Find;
4541 (Unit.File_Names (Body_Part).Display_Name);
4543 Unit.File_Names (Body_Part).Project;
4545 -- Otherwise, if there is a spec, put it
4548 elsif Unit.File_Names (Specification).Name /= No_File
4549 and then Unit.File_Names (Specification).Project /=
4552 Get_Name_String (Unit.Name);
4553 Name_Buffer (Name_Len + 1 .. Name_Len + 2) := "%s
";
4554 Name_Len := Name_Len + 2;
4555 ALI_Unit := Name_Find;
4558 (Unit.File_Names (Specification).Display_Name);
4560 Unit.File_Names (Specification).Project;
4563 ALI_Name := No_File;
4566 -- If we have something to put in the mapping
4567 -- then we do it now. However, if the project
4568 -- is extended, we don't put anything in the
4569 -- mapping file, because we do not know where
4570 -- the ALI file is: it might be in the ext-
4571 -- ended project obj dir as well as in the
4572 -- extending project obj dir.
4574 if ALI_Name /= No_File
4576 Project_Tree.Projects.Table
4577 (ALI_Project).Extended_By = No_Project
4579 Project_Tree.Projects.Table
4580 (ALI_Project).Extends = No_Project
4582 -- First check if the ALI file exists. If it does not,
4583 -- do not put the unit in the mapping file.
4586 ALI : constant String :=
4587 Get_Name_String (ALI_Name);
4588 PD : Project_Data renames
4589 Project_Tree.Projects.Table (ALI_Project);
4592 -- For library projects, use the library directory,
4593 -- for other projects, use the object directory.
4596 Get_Name_String (PD.Library_Dir.Name);
4598 Get_Name_String (PD.Object_Directory.Name);
4601 if Name_Buffer (Name_Len) /=
4604 Name_Len := Name_Len + 1;
4605 Name_Buffer (Name_Len) :=
4606 Directory_Separator;
4611 Name_Len + ALI'Length) := ALI;
4613 Name_Len + ALI'Length + 1;
4614 Name_Buffer (Name_Len) := ASCII.LF;
4617 ALI_Path_Name : constant String :=
4618 Name_Buffer (1 .. Name_Len);
4622 (ALI_Path_Name (1 .. ALI_Path_Name'Last - 1))
4625 -- First line is the unit name
4627 Get_Name_String (ALI_Unit);
4628 Name_Len := Name_Len + 1;
4629 Name_Buffer (Name_Len) := ASCII.LF;
4633 Name_Buffer (1)'Address,
4635 OK := Bytes = Name_Len;
4639 -- Second line it the ALI file name
4641 Get_Name_String (ALI_Name);
4642 Name_Len := Name_Len + 1;
4643 Name_Buffer (Name_Len) := ASCII.LF;
4647 Name_Buffer (1)'Address,
4649 OK := Bytes = Name_Len;
4653 -- Third line it the ALI path name
4658 ALI_Path_Name (1)'Address,
4659 ALI_Path_Name'Length);
4660 OK := Bytes = ALI_Path_Name'Length;
4662 -- If OK is False, it means we were unable
4663 -- to write a line. No point in continuing
4664 -- with the other units.
4675 Close (Mapping_FD, Status);
4677 OK := OK and Status;
4679 -- If the creation of the mapping file was successful,
4680 -- we add the switch to the arguments of gnatbind.
4683 Last_Arg := Last_Arg + 1;
4685 new String'("-F
=" & Get_Name_String (Mapping_Path));
4688 end Create_Binder_Mapping_File;
4690 -- Start of processing for Gnatmake
4692 -- This body is very long, should be broken down ???
4695 Install_Int_Handler (Sigint_Intercepted'Access);
4697 Do_Compile_Step := True;
4698 Do_Bind_Step := True;
4699 Do_Link_Step := True;
4705 Bind_Shared := No_Shared_Switch'Access;
4706 Link_With_Shared_Libgcc := No_Shared_Libgcc_Switch'Access;
4708 Failed_Links.Set_Last (0);
4709 Successful_Links.Set_Last (0);
4711 -- Special case when switch -B was specified
4713 if Build_Bind_And_Link_Full_Project then
4715 -- When switch -B is specified, there must be a project file
4717 if Main_Project = No_Project then
4718 Make_Failed ("-B cannot be used without a project file
");
4720 -- No main program may be specified on the command line
4722 elsif Osint.Number_Of_Files /= 0 then
4723 Make_Failed ("-B cannot be used
with a main specified on
" &
4724 "the command line
");
4726 -- And the project file cannot be a library project file
4728 elsif Project_Tree.Projects.Table (Main_Project).Library then
4729 Make_Failed ("-B cannot be used
for a library project file
");
4732 No_Main_Subprogram := True;
4733 Insert_Project_Sources
4734 (The_Project => Main_Project,
4735 All_Projects => Unique_Compile_All_Projects,
4738 -- If there are no sources to compile, we fail
4740 if Osint.Number_Of_Files = 0 then
4741 Make_Failed ("no sources to compile
");
4744 -- Specify -n for gnatbind and add the ALI files of all the
4745 -- sources, except the one which is a fake main subprogram:
4746 -- this is the one for the binder generated file and it will be
4747 -- transmitted to gnatlink. These sources are those that are
4750 Add_Switch ("-n
", Binder, And_Save => True);
4752 for J in Q.First .. Q.Last - 1 loop
4755 (Lib_File_Name (Q.Table (J).File)),
4756 Binder, And_Save => True);
4760 elsif Main_Index /= 0 and then Osint.Number_Of_Files > 1 then
4761 Make_Failed ("cannot specify several mains
with a multi
-unit index
");
4763 elsif Main_Project /= No_Project then
4765 -- If the main project file is a library project file, main(s)
4766 -- cannot be specified on the command line.
4768 if Osint.Number_Of_Files /= 0 then
4769 if Project_Tree.Projects.Table (Main_Project).Library
4770 and then not Unique_Compile
4771 and then ((not Make_Steps) or else Bind_Only or else Link_Only)
4773 Make_Failed ("cannot specify a main program
" &
4774 "on the command line
for a library project file
");
4777 -- Check that each main on the command line is a source of a
4778 -- project file and, if there are several mains, each of them
4779 -- is a source of the same project file.
4784 -- If no mains have been specified on the command line,
4785 -- and we are using a project file, we either find the main(s)
4786 -- in the attribute Main of the main project, or we put all
4787 -- the sources of the project file as mains.
4790 if Main_Index /= 0 then
4791 Make_Failed ("cannot specify a multi
-unit index but no main
" &
4792 "on the command line
");
4796 Value : String_List_Id :=
4797 Project_Tree.Projects.Table (Main_Project).Mains;
4800 -- The attribute Main is an empty list or not specified,
4801 -- or else gnatmake was invoked with the switch "-u
".
4803 if Value = Prj.Nil_String or else Unique_Compile then
4805 if (not Make_Steps) or else Compile_Only
4806 or else not Project_Tree.Projects.Table
4807 (Main_Project).Library
4809 -- First make sure that the binder and the linker
4810 -- will not be invoked.
4812 Do_Bind_Step := False;
4813 Do_Link_Step := False;
4815 -- Put all the sources in the queue
4817 No_Main_Subprogram := True;
4818 Insert_Project_Sources
4819 (The_Project => Main_Project,
4820 All_Projects => Unique_Compile_All_Projects,
4823 -- If no sources to compile, then there is nothing to do
4825 if Osint.Number_Of_Files = 0 then
4826 if not Quiet_Output then
4827 Osint.Write_Program_Name;
4828 Write_Line (": no sources to compile
");
4831 Delete_All_Temp_Files;
4832 Exit_Program (E_Success);
4837 -- The attribute Main is not an empty list.
4838 -- Put all the main subprograms in the list as if there
4839 -- were specified on the command line. However, if attribute
4840 -- Languages includes a language other than Ada, only
4841 -- include the Ada mains; if there is no Ada main, compile
4842 -- all the sources of the project.
4845 Data : constant Project_Data :=
4846 Project_Tree.Projects.Table (Main_Project);
4848 Languages : constant Variable_Value :=
4851 Data.Decl.Attributes,
4854 Current : String_List_Id;
4855 Element : String_Element;
4857 Foreign_Language : Boolean := False;
4858 At_Least_One_Main : Boolean := False;
4861 -- First, determine if there is a foreign language in
4862 -- attribute Languages.
4864 if not Languages.Default then
4865 Current := Languages.Values;
4868 while Current /= Nil_String loop
4869 Element := Project_Tree.String_Elements.
4871 Get_Name_String (Element.Value);
4872 To_Lower (Name_Buffer (1 .. Name_Len));
4874 if Name_Buffer (1 .. Name_Len) /= "ada
" then
4875 Foreign_Language := True;
4876 exit Look_For_Foreign;
4879 Current := Element.Next;
4880 end loop Look_For_Foreign;
4883 -- Then, find all mains, or if there is a foreign
4884 -- language, all the Ada mains.
4886 while Value /= Prj.Nil_String loop
4888 (Project_Tree.String_Elements.Table
4891 -- To know if a main is an Ada main, get its project.
4892 -- It should be the project specified on the command
4895 if (not Foreign_Language) or else
4897 (Name_Buffer (1 .. Name_Len),
4902 At_Least_One_Main := True;
4905 (Project_Tree.String_Elements.Table
4908 Project_Tree.String_Elements.Table
4912 Value := Project_Tree.String_Elements.Table
4916 -- If we did not get any main, it means that all mains
4917 -- in attribute Mains are in a foreign language and -B
4918 -- was not specified to gnatmake; so, we fail.
4920 if not At_Least_One_Main then
4922 ("no Ada mains
; use -B to build foreign main
");
4931 if Verbose_Mode then
4933 Display_Version ("GNATMAKE
", "1995");
4936 if Main_Project /= No_Project
4937 and then Project_Tree.Projects.Table
4938 (Main_Project).Externally_Built
4941 ("nothing to
do for a main project that
is externally built
");
4944 if Osint.Number_Of_Files = 0 then
4945 if Main_Project /= No_Project
4946 and then Project_Tree.Projects.Table (Main_Project).Library
4949 and then not Project_Tree.Projects.Table
4950 (Main_Project).Standalone_Library
4952 Make_Failed ("only stand
-alone libraries may be bound
");
4955 -- Add the default search directories to be able to find libgnat
4957 Osint.Add_Default_Search_Dirs;
4959 -- Get the target parameters, so that the correct binder generated
4960 -- files are generated if OpenVMS is the target.
4963 Targparm.Get_Target_Parameters;
4966 when Unrecoverable_Error =>
4967 Make_Failed ("*** make failed
.");
4970 -- And bind and or link the library
4972 MLib.Prj.Build_Library
4973 (For_Project => Main_Project,
4974 In_Tree => Project_Tree,
4975 Gnatbind => Gnatbind.all,
4976 Gnatbind_Path => Gnatbind_Path,
4978 Gcc_Path => Gcc_Path,
4982 Delete_All_Temp_Files;
4983 Exit_Program (E_Success);
4986 -- Output usage information if no files to compile
4989 Exit_Program (E_Fatal);
4993 -- If -M was specified, behave as if -n was specified
4995 if List_Dependencies then
4996 Do_Not_Execute := True;
4999 -- Note that Osint.M.Next_Main_Source will always return the (possibly
5000 -- abbreviated file) without any directory information.
5002 Main_Source_File := Next_Main_Source;
5004 if Current_File_Index /= No_Index then
5005 Main_Index := Current_File_Index;
5008 Add_Switch ("-I
-", Compiler, And_Save => True);
5010 if Main_Project = No_Project then
5011 if Look_In_Primary_Dir then
5015 Normalize_Directory_Name
5016 (Get_Primary_Src_Search_Directory.all).all,
5017 Compiler, Append_Switch => False,
5023 -- If we use a project file, we have already checked that a main
5024 -- specified on the command line with directory information has the
5025 -- path name corresponding to a correct source in the project tree.
5026 -- So, we don't need the directory information to be taken into
5027 -- account by Find_File, and in fact it may lead to take the wrong
5028 -- sources for other compilation units, when there are extending
5031 Look_In_Primary_Dir := False;
5032 Add_Switch ("-I
-", Binder, And_Save => True);
5035 -- If the user wants a program without a main subprogram, add the
5036 -- appropriate switch to the binder.
5038 if No_Main_Subprogram then
5039 Add_Switch ("-z
", Binder, And_Save => True);
5042 if Main_Project /= No_Project then
5044 if Project_Tree.Projects.Table
5045 (Main_Project).Object_Directory /= No_Path_Information
5047 -- Change current directory to object directory of main project
5049 Project_Of_Current_Object_Directory := No_Project;
5050 Change_To_Object_Directory (Main_Project);
5053 -- Source file lookups should be cached for efficiency.
5054 -- Source files are not supposed to change.
5056 Osint.Source_File_Data (Cache => True);
5058 -- Find the file name of the (first) main unit
5061 Main_Source_File_Name : constant String :=
5062 Get_Name_String (Main_Source_File);
5063 Main_Unit_File_Name : constant String :=
5064 Prj.Env.File_Name_Of_Library_Unit_Body
5065 (Name => Main_Source_File_Name,
5066 Project => Main_Project,
5067 In_Tree => Project_Tree,
5068 Main_Project_Only =>
5069 not Unique_Compile);
5071 The_Packages : constant Package_Id :=
5072 Project_Tree.Projects.Table
5073 (Main_Project).Decl.Packages;
5075 Builder_Package : constant Prj.Package_Id :=
5077 (Name => Name_Builder,
5078 In_Packages => The_Packages,
5079 In_Tree => Project_Tree);
5081 Binder_Package : constant Prj.Package_Id :=
5083 (Name => Name_Binder,
5084 In_Packages => The_Packages,
5085 In_Tree => Project_Tree);
5087 Linker_Package : constant Prj.Package_Id :=
5089 (Name => Name_Linker,
5090 In_Packages => The_Packages,
5091 In_Tree => Project_Tree);
5093 Default_Switches_Array : Array_Id;
5095 Global_Compilation_Array : Array_Element_Id;
5096 Global_Compilation_Elem : Array_Element;
5097 Global_Compilation_Switches : Variable_Value;
5100 -- We fail if we cannot find the main source file
5102 if Main_Unit_File_Name = "" then
5103 Make_Failed ('"' & Main_Source_File_Name,
5104 """ is not a unit of project ",
5105 Project_File_Name.all & ".");
5107 -- Remove any directory information from the main
5108 -- source file name.
5111 Pos : Natural := Main_Unit_File_Name'Last;
5115 exit when Pos < Main_Unit_File_Name'First or else
5116 Main_Unit_File_Name (Pos) = Directory_Separator;
5120 Name_Len := Main_Unit_File_Name'Last - Pos;
5122 Name_Buffer (1 .. Name_Len) :=
5124 (Pos + 1 .. Main_Unit_File_Name'Last);
5126 Main_Source_File := Name_Find;
5128 -- We only output the main source file if there is only one
5130 if Verbose_Mode and then Osint.Number_Of_Files = 1 then
5131 Write_Str ("Main source file: """);
5132 Write_Str (Main_Unit_File_Name
5133 (Pos + 1 .. Main_Unit_File_Name'Last));
5139 -- If there is a package Builder in the main project file, add
5140 -- the switches from it.
5142 if Builder_Package /= No_Package then
5144 Global_Compilation_Array := Prj.Util.Value_Of
5145 (Name => Name_Global_Compilation_Switches,
5146 In_Arrays => Project_Tree.Packages.Table
5147 (Builder_Package).Decl.Arrays,
5148 In_Tree => Project_Tree);
5150 Default_Switches_Array :=
5151 Project_Tree.Packages.Table
5152 (Builder_Package).Decl.Arrays;
5154 while Default_Switches_Array /= No_Array and then
5155 Project_Tree.Arrays.Table (Default_Switches_Array).Name /=
5156 Name_Default_Switches
5158 Default_Switches_Array :=
5159 Project_Tree.Arrays.Table (Default_Switches_Array).Next;
5162 if Global_Compilation_Array /= No_Array_Element and then
5163 Default_Switches_Array /= No_Array
5166 ("Default_Switches forbidden in presence of " &
5167 "Global_Compilation_Switches. Use Switches instead.",
5168 Project_Tree.Arrays.Table
5169 (Default_Switches_Array).Location);
5172 ("*** illegal combination of Builder attributes");
5175 -- If there is only one main, we attempt to get the gnatmake
5176 -- switches for this main (if any). If there are no specific
5177 -- switch for this particular main, get the general gnatmake
5178 -- switches (if any).
5180 if Osint.Number_Of_Files = 1 then
5181 if Verbose_Mode then
5182 Write_Str ("Adding gnatmake switches for """);
5183 Write_Str (Main_Unit_File_Name);
5188 (File_Name => Main_Unit_File_Name,
5189 Index => Main_Index,
5190 The_Package => Builder_Package,
5192 Unknown_Switches_To_The_Compiler =>
5193 Global_Compilation_Array = No_Array_Element);
5196 -- If there are several mains, we always get the general
5197 -- gnatmake switches (if any).
5199 -- Warn the user, if necessary, so that he is not surprised
5200 -- that specific switches are not taken into account.
5203 Defaults : constant Variable_Value :=
5207 Attribute_Or_Array_Name =>
5208 Name_Default_Switches,
5211 In_Tree => Project_Tree);
5213 Switches : constant Array_Element_Id :=
5215 (Name => Name_Switches,
5217 Project_Tree.Packages.Table
5218 (Builder_Package).Decl.Arrays,
5219 In_Tree => Project_Tree);
5221 Other_Switches : constant Variable_Value :=
5223 (Name => All_Other_Names,
5225 Attribute_Or_Array_Name
5227 In_Package => Builder_Package,
5228 In_Tree => Project_Tree);
5231 if Other_Switches /= Nil_Variable_Value then
5233 and then Switches /= No_Array_Element
5234 and then Project_Tree.Array_Elements.Table
5235 (Switches).Next /= No_Array_Element
5238 ("Warning: using Builder'Switches(others), "
5239 & "as there are several mains");
5245 The_Package => Builder_Package,
5247 Unknown_Switches_To_The_Compiler => False);
5249 elsif Defaults /= Nil_Variable_Value then
5251 and then Switches /= No_Array_Element
5254 ("Warning: using Builder'Default_Switches"
5255 & "(""Ada""), as there are several mains");
5261 The_Package => Builder_Package,
5264 elsif not Quiet_Output
5265 and then Switches /= No_Array_Element
5268 ("Warning: using no switches from package "
5269 & "Builder, as there are several mains");
5274 -- Take into account attribute Global_Compilation_Switches
5279 List : String_List_Id;
5280 Elem : String_Element;
5283 while Global_Compilation_Array /= No_Array_Element loop
5284 Global_Compilation_Elem :=
5285 Project_Tree.Array_Elements.Table
5286 (Global_Compilation_Array);
5288 Get_Name_String (Global_Compilation_Elem.Index);
5289 To_Lower (Name_Buffer (1 .. Name_Len));
5292 if Index = Name_Ada then
5293 Global_Compilation_Switches :=
5294 Global_Compilation_Elem.Value;
5296 if Global_Compilation_Switches /= Nil_Variable_Value
5297 and then not Global_Compilation_Switches.Default
5299 -- We have found attribute
5300 -- Global_Compilation_Switches ("Ada"): put the
5301 -- switches in the appropriate table.
5303 List := Global_Compilation_Switches.Values;
5305 while List /= Nil_String loop
5307 Project_Tree.String_Elements.Table (List);
5309 if Elem.Value /= No_Name then
5311 (Get_Name_String (Elem.Value),
5323 Global_Compilation_Array := Global_Compilation_Elem.Next;
5328 Osint.Add_Default_Search_Dirs;
5330 -- Record the current last switch index for table Binder_Switches
5331 -- and Linker_Switches, so that these tables may be reset before
5332 -- for each main, before adding switches from the project file
5333 -- and from the command line.
5335 Last_Binder_Switch := Binder_Switches.Last;
5336 Last_Linker_Switch := Linker_Switches.Last;
5340 -- Add binder switches from the project file for the first main
5342 if Do_Bind_Step and Binder_Package /= No_Package then
5343 if Verbose_Mode then
5344 Write_Str ("Adding binder switches for """);
5345 Write_Str (Main_Unit_File_Name);
5350 (File_Name => Main_Unit_File_Name,
5351 Index => Main_Index,
5352 The_Package => Binder_Package,
5356 -- Add linker switches from the project file for the first main
5358 if Do_Link_Step and Linker_Package /= No_Package then
5359 if Verbose_Mode then
5360 Write_Str ("Adding linker switches for""");
5361 Write_Str (Main_Unit_File_Name);
5366 (File_Name => Main_Unit_File_Name,
5367 Index => Main_Index,
5368 The_Package => Linker_Package,
5374 -- Get the target parameters, which are only needed for a couple of
5375 -- cases in gnatmake. Protect against an exception, such as the case
5376 -- of system.ads missing from the library, and fail gracefully.
5379 Targparm.Get_Target_Parameters;
5381 when Unrecoverable_Error =>
5382 Make_Failed ("*** make failed.");
5385 -- Special processing for VM targets
5387 if Targparm.VM_Target /= No_VM then
5389 -- Set proper processing commands
5391 case Targparm.VM_Target is
5392 when Targparm.JVM_Target =>
5394 -- Do not check for an object file (".o") when compiling to
5395 -- JVM machine since ".class" files are generated instead.
5397 Check_Object_Consistency := False;
5399 Gcc := new String'("jgnat");
5400 Gnatbind
:= new String'("jgnatbind");
5401 Gnatlink := new String'("jgnatlink");
5403 when Targparm
.CLI_Target
=>
5404 Gcc
:= new String'("dotnet-gnatcompile");
5406 when Targparm.No_VM =>
5407 raise Program_Error;
5411 Display_Commands (not Quiet_Output);
5415 if Main_Project /= No_Project then
5417 -- For all library project, if the library file does not exist, put
5418 -- all the project sources in the queue, and flag the project so that
5419 -- the library is generated.
5421 if not Unique_Compile
5422 and then MLib.Tgt.Support_For_Libraries /= Prj.None
5424 for Proj in Project_Table.First ..
5425 Project_Table.Last (Project_Tree.Projects)
5427 if Project_Tree.Projects.Table (Proj).Library then
5428 Project_Tree.Projects.Table
5429 (Proj).Need_To_Build_Lib :=
5430 (not MLib.Tgt.Library_Exists_For (Proj, Project_Tree))
5431 and then (not Project_Tree.Projects.Table
5432 (Proj).Externally_Built);
5434 if Project_Tree.Projects.Table (Proj).Need_To_Build_Lib then
5436 -- If there is no object directory, then it will be
5437 -- impossible to build the library. So fail immediately.
5439 if Project_Tree.Projects.Table (Proj).Object_Directory =
5443 ("no object files to build library for project """,
5445 (Project_Tree.Projects.Table (Proj).Name),
5447 Project_Tree.Projects.Table
5448 (Proj).Need_To_Build_Lib := False;
5451 if Verbose_Mode then
5453 ("Library file does not exist for project """);
5456 (Project_Tree.Projects.Table
5461 Insert_Project_Sources
5462 (The_Project => Proj,
5463 All_Projects => False,
5471 -- If a relative path output file has been specified, we add
5472 -- the exec directory.
5474 for J in reverse 1 .. Saved_Linker_Switches.Last - 1 loop
5475 if Saved_Linker_Switches.Table (J).all = Output_Flag.all then
5477 Exec_File_Name : constant String :=
5478 Saved_Linker_Switches.Table (J + 1).all;
5481 if not Is_Absolute_Path (Exec_File_Name) then
5483 (Project_Tree.Projects.Table
5484 (Main_Project).Exec_Directory.Name);
5486 if Name_Buffer (Name_Len) /= Directory_Separator then
5487 Name_Len := Name_Len + 1;
5488 Name_Buffer (Name_Len) := Directory_Separator;
5491 Name_Buffer (Name_Len + 1 ..
5492 Name_Len + Exec_File_Name'Length) :=
5494 Name_Len := Name_Len + Exec_File_Name'Length;
5495 Saved_Linker_Switches.Table (J + 1) :=
5496 new String'(Name_Buffer
(1 .. Name_Len
));
5504 -- If we are using a project file, for relative paths we add the
5505 -- current working directory for any relative path on the command
5506 -- line and the project directory, for any relative path in the
5510 Dir_Path
: constant String_Access
:=
5511 new String'(Get_Name_String
5512 (Project_Tree.Projects.Table
5513 (Main_Project).Directory.Name));
5515 for J in 1 .. Binder_Switches.Last loop
5516 Test_If_Relative_Path
5517 (Binder_Switches.Table (J),
5518 Parent => Dir_Path, Including_L_Switch => False);
5521 for J in 1 .. Saved_Binder_Switches.Last loop
5522 Test_If_Relative_Path
5523 (Saved_Binder_Switches.Table (J),
5524 Parent => Current_Work_Dir, Including_L_Switch => False);
5527 for J in 1 .. Linker_Switches.Last loop
5528 Test_If_Relative_Path
5529 (Linker_Switches.Table (J), Parent => Dir_Path);
5532 for J in 1 .. Saved_Linker_Switches.Last loop
5533 Test_If_Relative_Path
5534 (Saved_Linker_Switches.Table (J), Parent => Current_Work_Dir);
5537 for J in 1 .. Gcc_Switches.Last loop
5538 Test_If_Relative_Path
5539 (Gcc_Switches.Table (J),
5541 Including_Non_Switch => False);
5544 for J in 1 .. Saved_Gcc_Switches.Last loop
5545 Test_If_Relative_Path
5546 (Saved_Gcc_Switches.Table (J),
5547 Parent => Current_Work_Dir,
5548 Including_Non_Switch => False);
5553 -- We now put in the Binder_Switches and Linker_Switches tables, the
5554 -- binder and linker switches of the command line that have been put in
5555 -- the Saved_ tables. If a project file was used, then the command line
5556 -- switches will follow the project file switches.
5558 for J in 1 .. Saved_Binder_Switches.Last loop
5560 (Saved_Binder_Switches.Table (J),
5565 for J in 1 .. Saved_Linker_Switches.Last loop
5567 (Saved_Linker_Switches.Table (J),
5572 -- If no project file is used, we just put the gcc switches
5573 -- from the command line in the Gcc_Switches table.
5575 if Main_Project = No_Project then
5576 for J in 1 .. Saved_Gcc_Switches.Last loop
5578 (Saved_Gcc_Switches.Table (J),
5584 -- If there is a project, put the command line gcc switches in the
5585 -- variable The_Saved_Gcc_Switches. They are going to be used later
5586 -- in procedure Compile_Sources.
5588 The_Saved_Gcc_Switches :=
5589 new Argument_List (1 .. Saved_Gcc_Switches.Last + 1);
5591 for J in 1 .. Saved_Gcc_Switches.Last loop
5592 The_Saved_Gcc_Switches (J) := Saved_Gcc_Switches.Table (J);
5595 -- We never use gnat.adc when a project file is used
5597 The_Saved_Gcc_Switches (The_Saved_Gcc_Switches'Last) :=
5601 -- If there was a --GCC, --GNATBIND or --GNATLINK switch on
5602 -- the command line, then we have to use it, even if there was
5603 -- another switch in the project file.
5605 if Saved_Gcc /= null then
5609 if Saved_Gnatbind /= null then
5610 Gnatbind := Saved_Gnatbind;
5613 if Saved_Gnatlink /= null then
5614 Gnatlink := Saved_Gnatlink;
5617 Gcc_Path := GNAT.OS_Lib.Locate_Exec_On_Path (Gcc.all);
5618 Gnatbind_Path := GNAT.OS_Lib.Locate_Exec_On_Path (Gnatbind.all);
5619 Gnatlink_Path := GNAT.OS_Lib.Locate_Exec_On_Path (Gnatlink.all);
5621 -- If we have specified -j switch both from the project file
5622 -- and on the command line, the one from the command line takes
5625 if Saved_Maximum_Processes = 0 then
5626 Saved_Maximum_Processes := Maximum_Processes;
5629 -- Allocate as many temporary mapping file names as the maximum
5630 -- number of compilation processed, for each possible project.
5632 The_Mapping_File_Names :=
5634 (No_Project .. Project_Table.Last (Project_Tree.Projects),
5635 1 .. Saved_Maximum_Processes);
5636 Last_Mapping_File_Names :=
5638 (No_Project
.. Project_Table
.Last
(Project_Tree
.Projects
)
5641 The_Free_Mapping_File_Indices
:=
5642 new Free_File_Indices
5643 (No_Project
.. Project_Table
.Last
(Project_Tree
.Projects
),
5644 1 .. Saved_Maximum_Processes
);
5645 Last_Free_Indices
:=
5646 new Indices
'(No_Project .. Project_Table.Last
5647 (Project_Tree.Projects) => 0);
5649 Bad_Compilation.Init;
5651 -- If project files are used, create the mapping of all the sources,
5652 -- so that the correct paths will be found. Otherwise, if there is
5653 -- a file which is not a source with the same name in a source directory
5654 -- this file may be incorrectly found.
5656 if Main_Project /= No_Project then
5657 Prj.Env.Create_Mapping (Project_Tree);
5660 Current_Main_Index := Main_Index;
5662 -- Here is where the make process is started
5664 -- We do the same process for each main
5666 Multiple_Main_Loop : for N_File in 1 .. Osint.Number_Of_Files loop
5668 -- First, find the executable name and path
5670 Executable := No_File;
5671 Executable_Obsolete := False;
5672 Non_Std_Executable :=
5673 Targparm.Executable_Extension_On_Target /= No_Name;
5675 -- Look inside the linker switches to see if the name of the final
5676 -- executable program was specified.
5679 J in reverse Linker_Switches.First .. Linker_Switches.Last
5681 if Linker_Switches.Table (J).all = Output_Flag.all then
5682 pragma Assert (J < Linker_Switches.Last);
5684 -- We cannot specify a single executable for several
5685 -- main subprograms!
5687 if Osint.Number_Of_Files > 1 then
5689 ("cannot specify a single executable " &
5690 "for several mains");
5693 Name_Len := Linker_Switches.Table (J + 1)'Length;
5694 Name_Buffer (1 .. Name_Len) :=
5695 Linker_Switches.Table (J + 1).all;
5696 Executable := Name_Enter;
5698 Verbose_Msg (Executable, "final executable");
5702 -- If the name of the final executable program was not specified
5703 -- then construct it from the main input file.
5705 if Executable = No_File then
5706 if Main_Project = No_Project then
5708 Executable_Name (Strip_Suffix (Main_Source_File));
5711 -- If we are using a project file, we attempt to remove the
5712 -- body (or spec) termination of the main subprogram. We find
5713 -- it the naming scheme of the project file. This avoids
5714 -- generating an executable "main.2" for a main subprogram
5715 -- "main.2.ada", when the body termination is ".2.ada".
5718 Prj.Util.Executable_Of
5719 (Main_Project, Project_Tree, Main_Source_File, Main_Index);
5723 if Main_Project /= No_Project then
5725 Exec_File_Name : constant String :=
5726 Get_Name_String (Executable);
5729 if not Is_Absolute_Path (Exec_File_Name) then
5731 (Project_Tree.Projects.Table
5732 (Main_Project).Exec_Directory.Display_Name);
5734 if Name_Buffer (Name_Len) /= Directory_Separator then
5735 Name_Len := Name_Len + 1;
5736 Name_Buffer (Name_Len) := Directory_Separator;
5739 Name_Buffer (Name_Len + 1 ..
5740 Name_Len + Exec_File_Name'Length) :=
5743 Name_Len := Name_Len + Exec_File_Name'Length;
5744 Executable := Name_Find;
5747 Non_Std_Executable := True;
5751 if Do_Compile_Step then
5752 Recursive_Compilation_Step : declare
5753 Args : Argument_List (1 .. Gcc_Switches.Last);
5755 First_Compiled_File : File_Name_Type;
5756 Youngest_Obj_File : File_Name_Type;
5757 Youngest_Obj_Stamp : Time_Stamp_Type;
5759 Executable_Stamp : Time_Stamp_Type;
5760 -- Executable is the final executable program
5762 Library_Rebuilt : Boolean := False;
5765 for J in 1 .. Gcc_Switches.Last loop
5766 Args (J) := Gcc_Switches.Table (J);
5769 -- Now we invoke Compile_Sources for the current main
5772 (Main_Source => Main_Source_File,
5774 First_Compiled_File => First_Compiled_File,
5775 Most_Recent_Obj_File => Youngest_Obj_File,
5776 Most_Recent_Obj_Stamp => Youngest_Obj_Stamp,
5777 Main_Unit => Is_Main_Unit,
5778 Main_Index => Current_Main_Index,
5779 Compilation_Failures => Compilation_Failures,
5780 Check_Readonly_Files => Check_Readonly_Files,
5781 Do_Not_Execute => Do_Not_Execute,
5782 Force_Compilations => Force_Compilations,
5783 In_Place_Mode => In_Place_Mode,
5784 Keep_Going => Keep_Going,
5785 Initialize_ALI_Data => True,
5786 Max_Process => Saved_Maximum_Processes);
5788 if Verbose_Mode then
5789 Write_Str ("End of compilation");
5793 -- Make sure the queue will be reinitialized for the next round
5795 First_Q_Initialization := True;
5797 Total_Compilation_Failures :=
5798 Total_Compilation_Failures + Compilation_Failures;
5800 if Total_Compilation_Failures /= 0 then
5804 List_Bad_Compilations;
5805 Report_Compilation_Failed;
5809 -- Regenerate libraries, if there are any and if object files
5810 -- have been regenerated.
5812 if Main_Project /= No_Project
5813 and then MLib.Tgt.Support_For_Libraries /= Prj.None
5814 and then (Do_Bind_Step
5815 or Unique_Compile_All_Projects
5816 or not Compile_Only)
5817 and then (Do_Link_Step or N_File = Osint.Number_Of_Files)
5825 procedure Add_To_Library_Projs (Proj : Project_Id);
5826 -- Add project Project to table Library_Projs in
5827 -- decreasing depth order.
5829 --------------------------
5830 -- Add_To_Library_Projs --
5831 --------------------------
5833 procedure Add_To_Library_Projs (Proj : Project_Id) is
5837 Library_Projs.Increment_Last;
5838 Depth := Project_Tree.Projects.Table (Proj).Depth;
5840 -- Put the projects in decreasing depth order, so that
5841 -- if libA depends on libB, libB is first in order.
5843 Current := Library_Projs.Last;
5844 while Current > 1 loop
5845 Prj := Library_Projs.Table (Current - 1);
5846 exit when Project_Tree.Projects.Table
5847 (Prj).Depth >= Depth;
5848 Library_Projs.Table (Current) := Prj;
5849 Current := Current - 1;
5852 Library_Projs.Table (Current) := Proj;
5853 end Add_To_Library_Projs;
5855 -- Start of processing for ??? (should name declare block
5856 -- or probably better, break this out as a nested proc).
5859 -- Put in Library_Projs table all library project
5860 -- file ids when the library need to be rebuilt.
5862 for Proj1 in Project_Table.First ..
5863 Project_Table.Last (Project_Tree.Projects)
5865 if Project_Tree.Projects.Table
5866 (Proj1).Standalone_Library
5868 There_Are_Stand_Alone_Libraries := True;
5871 if Project_Tree.Projects.Table (Proj1).Library then
5872 MLib.Prj.Check_Library (Proj1, Project_Tree);
5875 if Project_Tree.Projects.Table
5876 (Proj1).Need_To_Build_Lib
5878 Add_To_Library_Projs (Proj1);
5882 -- Check if importing libraries should be regenerated
5883 -- because at least an imported library will be
5884 -- regenerated or is more recent.
5886 for Proj1 in Project_Table.First ..
5887 Project_Table.Last (Project_Tree.Projects)
5889 if Project_Tree.Projects.Table (Proj1).Library
5891 Project_Tree.Projects.Table (Proj1).Library_Kind /=
5893 and then not Project_Tree.Projects.Table
5894 (Proj1).Need_To_Build_Lib
5895 and then not Project_Tree.Projects.Table
5896 (Proj1).Externally_Built
5899 List : Project_List;
5900 Element : Project_Element;
5902 Rebuild : Boolean := False;
5904 Lib_Timestamp1 : constant Time_Stamp_Type :=
5905 Project_Tree.Projects.Table
5909 List := Project_Tree.Projects.Table (Proj1).
5910 All_Imported_Projects;
5911 while List /= Empty_Project_List loop
5913 Project_Tree.Project_Lists.Table (List);
5914 Proj2 := Element.Project;
5917 Project_Tree.Projects.Table (Proj2).Library
5919 if Project_Tree.Projects.Table (Proj2).
5923 Project_Tree.Projects.Table
5931 List := Element.Next;
5935 Project_Tree.Projects.Table
5936 (Proj1).Need_To_Build_Lib := True;
5937 Add_To_Library_Projs (Proj1);
5943 -- Reset the flags Need_To_Build_Lib for the next main,
5944 -- to avoid rebuilding libraries uselessly.
5946 for Proj1 in Project_Table.First ..
5947 Project_Table.Last (Project_Tree.Projects)
5949 Project_Tree.Projects.Table
5950 (Proj1).Need_To_Build_Lib := False;
5954 -- Build the libraries, if any need to be built
5956 for J in 1 .. Library_Projs.Last loop
5957 Library_Rebuilt := True;
5959 -- If a library is rebuilt, then executables are obsolete
5961 Executable_Obsolete := True;
5963 MLib.Prj.Build_Library
5964 (For_Project => Library_Projs.Table (J),
5965 In_Tree => Project_Tree,
5966 Gnatbind => Gnatbind.all,
5967 Gnatbind_Path => Gnatbind_Path,
5969 Gcc_Path => Gcc_Path);
5973 if List_Dependencies then
5974 if First_Compiled_File /= No_File then
5976 (First_Compiled_File,
5977 "must be recompiled. Can't generate dependence list.");
5982 elsif First_Compiled_File = No_File
5983 and then not Do_Bind_Step
5984 and then not Quiet_Output
5985 and then not Library_Rebuilt
5986 and then Osint.Number_Of_Files = 1
5988 Inform (Msg => "objects up to date.");
5990 elsif Do_Not_Execute
5991 and then First_Compiled_File /= No_File
5993 Write_Name (First_Compiled_File);
5997 -- Stop after compile step if any of:
5999 -- 1) -n (Do_Not_Execute) specified
6001 -- 2) -M (List_Dependencies) specified (also sets
6002 -- Do_Not_Execute above, so this is probably superfluous).
6004 -- 3) -c (Compile_Only) specified, but not -b (Bind_Only)
6006 -- 4) Made unit cannot be a main unit
6009 or List_Dependencies
6011 or not Is_Main_Unit)
6012 and then not No_Main_Subprogram
6013 and then not Build_Bind_And_Link_Full_Project)
6014 or else Unique_Compile
6016 if Osint.Number_Of_Files = 1 then
6017 exit Multiple_Main_Loop;
6024 -- If the objects were up-to-date check if the executable file
6025 -- is also up-to-date. For now always bind and link on the JVM
6026 -- since there is currently no simple way to check the
6027 -- up-to-date status of objects
6029 if Targparm.VM_Target /= JVM_Target
6030 and then First_Compiled_File = No_File
6032 Executable_Stamp := File_Stamp (Executable);
6034 if not Executable_Obsolete then
6035 Executable_Obsolete :=
6036 Youngest_Obj_Stamp > Executable_Stamp;
6039 if not Executable_Obsolete then
6040 for Index in reverse 1 .. Dependencies.Last loop
6042 (Dependencies.Table (Index).Depends_On)
6044 Enter_Into_Obsoleted
6045 (Dependencies.Table (Index).This);
6049 Executable_Obsolete := Is_In_Obsoleted (Main_Source_File);
6053 if not Executable_Obsolete then
6055 -- If no Ada object files obsolete the executable, check
6056 -- for younger or missing linker files.
6058 Check_Linker_Options
6061 Youngest_Obj_Stamp);
6063 Executable_Obsolete := Youngest_Obj_File /= No_File;
6066 -- Return if the executable is up to date
6067 -- and otherwise motivate the relink/rebind.
6069 if not Executable_Obsolete then
6070 if not Quiet_Output then
6071 Inform (Executable, "up to date.");
6074 if Osint.Number_Of_Files = 1 then
6075 exit Multiple_Main_Loop;
6082 if Executable_Stamp (1) = ' ' then
6083 if not No_Main_Subprogram then
6084 Verbose_Msg (Executable, "missing.", Prefix => " ");
6087 elsif Youngest_Obj_Stamp (1) = ' ' then
6089 (Youngest_Obj_File, "missing.", Prefix => " ");
6091 elsif Youngest_Obj_Stamp > Executable_Stamp then
6094 "(" & String (Youngest_Obj_Stamp) & ") newer than",
6096 "(" & String (Executable_Stamp) & ")");
6100 (Executable, "needs to be rebuilt", Prefix => " ");
6104 end Recursive_Compilation_Step;
6107 -- For binding and linking, we need to be in the object directory of
6108 -- the main project.
6110 if Main_Project /= No_Project then
6111 Change_To_Object_Directory (Main_Project);
6114 -- If we are here, it means that we need to rebuilt the current
6115 -- main. So we set Executable_Obsolete to True to make sure that
6116 -- the subsequent mains will be rebuilt.
6118 Main_ALI_In_Place_Mode_Step : declare
6119 ALI_File : File_Name_Type;
6120 Src_File : File_Name_Type;
6123 Src_File := Strip_Directory (Main_Source_File);
6124 ALI_File := Lib_File_Name (Src_File, Current_Main_Index);
6125 Main_ALI_File := Full_Lib_File_Name (ALI_File);
6127 -- When In_Place_Mode, the library file can be located in the
6128 -- Main_Source_File directory which may not be present in the
6129 -- library path. If it is not present then use the corresponding
6130 -- library file name.
6132 if Main_ALI_File = No_File and then In_Place_Mode then
6133 Get_Name_String (Get_Directory (Full_Source_Name (Src_File)));
6134 Get_Name_String_And_Append (ALI_File);
6135 Main_ALI_File := Name_Find;
6136 Main_ALI_File := Full_Lib_File_Name (Main_ALI_File);
6139 if Main_ALI_File = No_File then
6140 Make_Failed ("could not find the main ALI file");
6142 end Main_ALI_In_Place_Mode_Step;
6144 if Do_Bind_Step then
6146 Args : Argument_List
6147 (Binder_Switches.First .. Binder_Switches.Last + 2);
6148 -- The arguments for the invocation of gnatbind
6150 Last_Arg : Natural := Binder_Switches.Last;
6151 -- Index of the last argument in Args
6153 Shared_Libs : Boolean := False;
6154 -- Set to True when there are shared library project files or
6155 -- when gnatbind is invoked with -shared.
6158 -- Check if there are shared libraries, so that gnatbind is
6159 -- called with -shared. Check also if gnatbind is called with
6160 -- -shared, so that gnatlink is called with -shared-libgcc
6161 -- ensuring that the shared version of libgcc will be used.
6163 if Main_Project /= No_Project
6164 and then MLib.Tgt.Support_For_Libraries /= Prj.None
6166 for Proj in Project_Table.First ..
6167 Project_Table.Last (Project_Tree.Projects)
6169 if Project_Tree.Projects.Table (Proj).Library
6170 and then Project_Tree.Projects.Table
6171 (Proj).Library_Kind /= Static
6173 Shared_Libs := True;
6174 Bind_Shared := Shared_Switch'Access;
6180 -- Check now for switch -shared
6182 if not Shared_Libs then
6183 for J in Binder_Switches.First .. Last_Arg loop
6184 if Binder_Switches.Table (J).all = "-shared" then
6185 Shared_Libs := True;
6191 -- If shared libraries present, invoke gnatlink with
6195 Link_With_Shared_Libgcc := Shared_Libgcc_Switch'Access;
6198 -- Get all the binder switches
6200 for J in Binder_Switches.First .. Last_Arg loop
6201 Args (J) := Binder_Switches.Table (J);
6204 if There_Are_Stand_Alone_Libraries then
6205 Last_Arg := Last_Arg + 1;
6206 Args (Last_Arg) := Force_Elab_Flags_String'Access;
6209 if Main_Project /= No_Project then
6211 -- Put all the source directories in ADA_INCLUDE_PATH,
6212 -- and all the object directories in ADA_OBJECTS_PATH.
6214 Prj.Env.Set_Ada_Paths (Main_Project, Project_Tree, False);
6216 -- If switch -C was specified, create a binder mapping file
6218 if Create_Mapping_File then
6219 Create_Binder_Mapping_File (Args, Last_Arg);
6225 Bind (Main_ALI_File,
6226 Bind_Shared.all & Args (Args'First .. Last_Arg));
6231 -- If -dn was not specified, delete the temporary mapping
6232 -- file, if one was created.
6234 if not Debug.Debug_Flag_N
6235 and then Mapping_Path /= No_Path
6237 Delete_File (Get_Name_String (Mapping_Path), Discard);
6240 -- And reraise the exception
6245 -- If -dn was not specified, delete the temporary mapping file,
6246 -- if one was created.
6248 if not Debug.Debug_Flag_N and then Mapping_Path /= No_Path then
6249 Delete_File (Get_Name_String (Mapping_Path), Discard);
6254 if Do_Link_Step then
6256 Linker_Switches_Last : constant Integer := Linker_Switches.Last;
6257 Path_Option : constant String_Access :=
6258 MLib.Linker_Library_Path_Option;
6259 There_Are_Libraries : Boolean := False;
6265 if not Run_Path_Option then
6266 Linker_Switches.Increment_Last;
6267 Linker_Switches.Table (Linker_Switches.Last) :=
6271 if Main_Project
/= No_Project
then
6272 Library_Paths
.Set_Last
(0);
6275 if MLib
.Tgt
.Support_For_Libraries
/= Prj
.None
then
6277 -- Check for library projects
6279 for Proj1
in Project_Table
.First
..
6280 Project_Table
.Last
(Project_Tree
.Projects
)
6282 if Proj1
/= Main_Project
6284 Project_Tree
.Projects
.Table
(Proj1
).Library
6286 -- Add this project to table Library_Projs
6288 There_Are_Libraries
:= True;
6289 Depth
:= Project_Tree
.Projects
.Table
(Proj1
).Depth
;
6290 Library_Projs
.Increment_Last
;
6291 Current
:= Library_Projs
.Last
;
6293 -- Any project with a greater depth should be
6294 -- after this project in the list.
6296 while Current
> 1 loop
6297 Proj2
:= Library_Projs
.Table
(Current
- 1);
6298 exit when Project_Tree
.Projects
.Table
6299 (Proj2
).Depth
<= Depth
;
6300 Library_Projs
.Table
(Current
) := Proj2
;
6301 Current
:= Current
- 1;
6304 Library_Projs
.Table
(Current
) := Proj1
;
6306 -- If it is not a static library and path option
6307 -- is set, add it to the Library_Paths table.
6309 if Project_Tree
.Projects
.Table
6310 (Proj1
).Library_Kind
/= Static
6311 and then Path_Option
/= null
6313 Library_Paths
.Increment_Last
;
6314 Library_Paths
.Table
(Library_Paths
.Last
) :=
6317 (Project_Tree.Projects.Table
6318 (Proj1).Library_Dir.Display_Name));
6323 for Index in 1 .. Library_Projs.Last loop
6325 -- Add the -L switch
6327 Linker_Switches.Increment_Last;
6328 Linker_Switches.Table (Linker_Switches.Last) :=
6331 (Project_Tree
.Projects
.Table
6332 (Library_Projs
.Table
(Index
)).
6333 Library_Dir
.Display_Name
));
6335 -- Add the -l switch
6337 Linker_Switches
.Increment_Last
;
6338 Linker_Switches
.Table
(Linker_Switches
.Last
) :=
6341 (Project_Tree.Projects.Table
6342 (Library_Projs.Table (Index)).
6347 if There_Are_Libraries then
6349 -- If Path_Option is not null, create the switch
6350 -- ("-Wl,-rpath," or equivalent) with all the non static
6351 -- library dirs plus the standard GNAT library dir.
6352 -- We do that only if Run_Path_Option is True
6353 -- (not disabled by -R switch).
6355 if Run_Path_Option and Path_Option /= null then
6357 Option : String_Access;
6358 Length : Natural := Path_Option'Length;
6363 Library_Paths.First .. Library_Paths.Last
6365 -- Add the length of the library dir plus one
6366 -- for the directory separator.
6370 Library_Paths.Table (Index)'Length + 1;
6373 -- Finally, add the length of the standard GNAT
6376 Length := Length + MLib.Utl.Lib_Directory'Length;
6377 Option := new String (1 .. Length);
6378 Option (1 .. Path_Option'Length) := Path_Option.all;
6379 Current := Path_Option'Length;
6381 -- Put each library dir followed by a dir separator
6384 Library_Paths.First .. Library_Paths.Last
6389 Library_Paths.Table (Index)'Length) :=
6390 Library_Paths.Table (Index).all;
6393 Library_Paths.Table (Index)'Length + 1;
6394 Option (Current) := Path_Separator;
6397 -- Finally put the standard GNAT library dir
6401 Current + MLib.Utl.Lib_Directory'Length) :=
6402 MLib.Utl.Lib_Directory;
6404 -- And add the switch to the linker switches
6406 Linker_Switches.Increment_Last;
6407 Linker_Switches.Table (Linker_Switches.Last) :=
6414 -- Put the object directories in ADA_OBJECTS_PATH
6416 Prj.Env.Set_Ada_Paths (Main_Project, Project_Tree, False);
6418 -- Check for attributes Linker'Linker_Options in projects
6419 -- other than the main project
6422 Linker_Options : constant String_List :=
6423 Linker_Options_Switches
6424 (Main_Project, Project_Tree);
6426 for Option in Linker_Options'Range loop
6427 Linker_Switches.Increment_Last;
6428 Linker_Switches.Table (Linker_Switches.Last) :=
6429 Linker_Options (Option);
6435 Args : Argument_List
6436 (Linker_Switches.First .. Linker_Switches.Last + 2);
6438 Last_Arg : Integer := Linker_Switches.First - 1;
6439 Skip : Boolean := False;
6442 -- Get all the linker switches
6444 for J in Linker_Switches.First .. Linker_Switches.Last loop
6448 elsif Non_Std_Executable
6449 and then Linker_Switches.Table (J).all = "-o"
6454 Last_Arg := Last_Arg + 1;
6455 Args (Last_Arg) := Linker_Switches.Table (J);
6459 -- If need be, add the -o switch
6461 if Non_Std_Executable then
6462 Last_Arg := Last_Arg + 1;
6463 Args (Last_Arg) := new String'("-o");
6464 Last_Arg
:= Last_Arg
+ 1;
6466 new String'(Get_Name_String (Executable));
6469 -- And invoke the linker
6472 Success : Boolean := False;
6474 Link (Main_ALI_File,
6475 Link_With_Shared_Libgcc.all &
6476 Args (Args'First .. Last_Arg),
6480 Successful_Links.Increment_Last;
6481 Successful_Links.Table (Successful_Links.Last) :=
6484 elsif Osint.Number_Of_Files = 1 or not Keep_Going then
6485 Make_Failed ("*** link failed.");
6489 Write_Line ("*** link failed");
6491 if Commands_To_Stdout then
6492 Set_Standard_Output;
6495 Failed_Links.Increment_Last;
6496 Failed_Links.Table (Failed_Links.Last) :=
6502 Linker_Switches.Set_Last (Linker_Switches_Last);
6506 -- We go to here when we skip the bind and link steps
6510 -- We go to the next main, if we did not process the last one
6512 if N_File < Osint.Number_Of_Files then
6513 Main_Source_File := Next_Main_Source;
6515 if Current_File_Index /= No_Index then
6516 Main_Index := Current_File_Index;
6519 if Main_Project /= No_Project then
6521 -- Find the file name of the main unit
6524 Main_Source_File_Name : constant String :=
6525 Get_Name_String (Main_Source_File);
6527 Main_Unit_File_Name : constant String :=
6529 File_Name_Of_Library_Unit_Body
6530 (Name => Main_Source_File_Name,
6531 Project => Main_Project,
6532 In_Tree => Project_Tree,
6533 Main_Project_Only =>
6534 not Unique_Compile);
6536 The_Packages : constant Package_Id :=
6537 Project_Tree.Projects.Table
6538 (Main_Project).Decl.Packages;
6540 Binder_Package : constant Prj.Package_Id :=
6542 (Name => Name_Binder,
6543 In_Packages => The_Packages,
6544 In_Tree => Project_Tree);
6546 Linker_Package : constant Prj.Package_Id :=
6548 (Name => Name_Linker,
6549 In_Packages => The_Packages,
6550 In_Tree => Project_Tree);
6553 -- We fail if we cannot find the main source file
6554 -- as an immediate source of the main project file.
6556 if Main_Unit_File_Name = "" then
6557 Make_Failed ('"' & Main_Source_File_Name,
6558 """ is not a unit
of project
",
6559 Project_File_Name.all & ".");
6562 -- Remove any directory information from the main
6563 -- source file name.
6566 Pos : Natural := Main_Unit_File_Name'Last;
6570 exit when Pos < Main_Unit_File_Name'First
6572 Main_Unit_File_Name (Pos) = Directory_Separator;
6576 Name_Len := Main_Unit_File_Name'Last - Pos;
6578 Name_Buffer (1 .. Name_Len) :=
6580 (Pos + 1 .. Main_Unit_File_Name'Last);
6582 Main_Source_File := Name_Find;
6586 -- We now deal with the binder and linker switches.
6587 -- If no project file is used, there is nothing to do
6588 -- because the binder and linker switches are the same
6591 -- Reset the tables Binder_Switches and Linker_Switches
6593 Binder_Switches.Set_Last (Last_Binder_Switch);
6594 Linker_Switches.Set_Last (Last_Linker_Switch);
6596 -- Add binder switches from the project file for this main,
6599 if Do_Bind_Step and Binder_Package /= No_Package then
6600 if Verbose_Mode then
6601 Write_Str ("Adding binder switches
for """);
6602 Write_Str (Main_Unit_File_Name);
6607 (File_Name => Main_Unit_File_Name,
6608 Index => Main_Index,
6609 The_Package => Binder_Package,
6613 -- Add linker switches from the project file for this main,
6616 if Do_Link_Step and Linker_Package /= No_Package then
6617 if Verbose_Mode then
6618 Write_Str ("Adding linker switches
for""");
6619 Write_Str (Main_Unit_File_Name);
6624 (File_Name => Main_Unit_File_Name,
6625 Index => Main_Index,
6626 The_Package => Linker_Package,
6630 -- As we are using a project file, for relative paths we add
6631 -- the current working directory for any relative path on
6632 -- the command line and the project directory, for any
6633 -- relative path in the project file.
6636 Dir_Path : constant String_Access :=
6637 new String'(Get_Name_String
6638 (Project_Tree.Projects.Table
6639 (Main_Project).Directory.Name));
6642 J in Last_Binder_Switch + 1 .. Binder_Switches.Last
6644 Test_If_Relative_Path
6645 (Binder_Switches.Table (J),
6646 Parent => Dir_Path, Including_L_Switch => False);
6650 J in Last_Linker_Switch + 1 .. Linker_Switches.Last
6652 Test_If_Relative_Path
6653 (Linker_Switches.Table (J), Parent => Dir_Path);
6657 -- We now put in the Binder_Switches and Linker_Switches
6658 -- tables, the binder and linker switches of the command
6659 -- line that have been put in the Saved_ tables.
6660 -- These switches will follow the project file switches.
6662 for J in 1 .. Saved_Binder_Switches.Last loop
6664 (Saved_Binder_Switches.Table (J),
6669 for J in 1 .. Saved_Linker_Switches.Last loop
6671 (Saved_Linker_Switches.Table (J),
6679 -- Remove all marks to be sure to check sources for all executables,
6680 -- as the switches may be different and -s may be in use.
6683 end loop Multiple_Main_Loop;
6685 if Failed_Links.Last > 0 then
6686 for Index in 1 .. Successful_Links.Last loop
6687 Write_Str ("Linking
of """);
6688 Write_Str (Get_Name_String (Successful_Links.Table (Index)));
6689 Write_Line (""" succeeded
.");
6694 for Index in 1 .. Failed_Links.Last loop
6695 Write_Str ("Linking
of """);
6696 Write_Str (Get_Name_String (Failed_Links.Table (Index)));
6697 Write_Line (""" failed
.");
6700 if Commands_To_Stdout then
6701 Set_Standard_Output;
6704 if Total_Compilation_Failures = 0 then
6705 Report_Compilation_Failed;
6709 if Total_Compilation_Failures /= 0 then
6710 List_Bad_Compilations;
6711 Report_Compilation_Failed;
6714 -- Delete the temporary mapping file that was created if we are
6715 -- using project files.
6717 Delete_All_Temp_Files;
6722 Write_Line (Exception_Information (X));
6723 Make_Failed ("INTERNAL ERROR
. Please report
.");
6730 function Hash (F : File_Name_Type) return Header_Num is
6732 return Header_Num (1 + F mod Max_Header);
6735 --------------------
6736 -- In_Ada_Lib_Dir --
6737 --------------------
6739 function In_Ada_Lib_Dir (File : File_Name_Type) return Boolean is
6740 D : constant File_Name_Type := Get_Directory (File);
6741 B : constant Byte := Get_Name_Table_Byte (D);
6743 return (B and Ada_Lib_Dir) /= 0;
6746 -----------------------
6747 -- Init_Mapping_File --
6748 -----------------------
6750 procedure Init_Mapping_File
6751 (Project : Project_Id;
6752 File_Index : in out Natural)
6754 FD : File_Descriptor;
6756 -- For call to Close
6759 -- Increase the index of the last mapping file for this project
6761 Last_Mapping_File_Names (Project) :=
6762 Last_Mapping_File_Names (Project) + 1;
6764 -- If there is a project file, call Create_Mapping_File with
6767 if Project /= No_Project then
6768 Prj.Env.Create_Mapping_File
6769 (Project, Project_Tree,
6770 The_Mapping_File_Names
6771 (Project, Last_Mapping_File_Names (Project)));
6773 -- Otherwise, just create an empty file
6776 Tempdir.Create_Temp_File
6778 The_Mapping_File_Names
6779 (No_Project, Last_Mapping_File_Names (No_Project)));
6781 if FD = Invalid_FD then
6782 Make_Failed ("disk full
");
6786 (The_Mapping_File_Names
6787 (No_Project, Last_Mapping_File_Names (No_Project)));
6793 Make_Failed ("disk full
");
6797 -- And return the index of the newly created file
6799 File_Index := Last_Mapping_File_Names (Project);
6800 end Init_Mapping_File;
6808 First_Q_Initialization := False;
6810 Q.Set_Last (Q.First);
6817 procedure Initialize is
6819 procedure Check_Version_And_Help is
6820 new Check_Version_And_Help_G (Makeusg);
6822 -- Start of processing for Initialize
6825 Prj.Set_Mode (Ada_Only);
6827 -- Override default initialization of Check_Object_Consistency since
6828 -- this is normally False for GNATBIND, but is True for GNATMAKE since
6829 -- we do not need to check source consistency again once GNATMAKE has
6830 -- looked at the sources to check.
6832 Check_Object_Consistency := True;
6834 -- Package initializations. The order of calls is important here
6836 Output.Set_Standard_Error;
6839 Binder_Switches.Init;
6840 Linker_Switches.Init;
6847 Prj.Initialize (Project_Tree);
6851 RTS_Specified := null;
6855 -- Add the directory where gnatmake is invoked in front of the
6856 -- path, if gnatmake is invoked from a bin directory or with directory
6857 -- information. Only do this if the platform is not VMS, where the
6858 -- notion of path does not really exist.
6862 Prefix : constant String := Executable_Prefix_Path;
6863 Command : constant String := Command_Name;
6866 if Prefix'Length > 0 then
6868 PATH : constant String :=
6869 Prefix & Directory_Separator & "bin
" &
6871 Getenv ("PATH
").all;
6873 Setenv ("PATH
", PATH);
6877 for Index in reverse Command'Range loop
6878 if Command (Index) = Directory_Separator then
6880 Absolute_Dir : constant String :=
6882 (Command (Command'First .. Index));
6883 PATH : constant String :=
6886 Getenv ("PATH
").all;
6888 Setenv ("PATH
", PATH);
6898 -- Scan the switches and arguments
6900 -- First, scan to detect --version and/or --help
6902 Check_Version_And_Help ("GNATMAKE
", "1995");
6904 -- Scan again the switch and arguments, now that we are sure that they
6905 -- do not include --version or --help.
6907 Scan_Args : for Next_Arg in 1 .. Argument_Count loop
6908 Scan_Make_Arg (Argument (Next_Arg), And_Save => True);
6911 if Commands_To_Stdout then
6912 Set_Standard_Output;
6915 if Usage_Requested then
6919 -- Test for trailing -P switch
6921 if Project_File_Name_Present and then Project_File_Name = null then
6922 Make_Failed ("project file name missing after
-P
");
6924 -- Test for trailing -o switch
6926 elsif Output_File_Name_Present
6927 and then not Output_File_Name_Seen
6929 Make_Failed ("output file name missing after
-o
");
6931 -- Test for trailing -D switch
6933 elsif Object_Directory_Present
6934 and then not Object_Directory_Seen then
6935 Make_Failed ("object directory missing after
-D
");
6938 -- Test for simultaneity of -i and -D
6940 if Object_Directory_Path /= null and then In_Place_Mode then
6941 Make_Failed ("-i
and -D cannot be used simultaneously
");
6944 -- Deal with -C= switch
6946 if Gnatmake_Mapping_File /= null then
6948 -- First, check compatibility with other switches
6950 if Project_File_Name /= null then
6951 Make_Failed ("-C
= switch
is not compatible
with -P switch
");
6953 elsif Saved_Maximum_Processes > 1 then
6954 Make_Failed ("-C
= switch
is not compatible
with -jnnn switch
");
6957 Fmap.Initialize (Gnatmake_Mapping_File.all);
6959 ("-gnatem
=" & Gnatmake_Mapping_File.all,
6964 if Project_File_Name /= null then
6966 -- A project file was specified by a -P switch
6968 if Verbose_Mode then
6970 Write_Str ("Parsing project file
""");
6971 Write_Str (Project_File_Name.all);
6976 -- Avoid looking in the current directory for ALI files
6978 -- Look_In_Primary_Dir := False;
6980 -- Set the project parsing verbosity to whatever was specified
6981 -- by a possible -vP switch.
6983 Prj.Pars.Set_Verbosity (To => Current_Verbosity);
6985 -- Parse the project file.
6986 -- If there is an error, Main_Project will still be No_Project.
6989 (Project => Main_Project,
6990 In_Tree => Project_Tree,
6991 Project_File_Name => Project_File_Name.all,
6992 Packages_To_Check => Packages_To_Check_By_Gnatmake);
6994 -- The parsing of project files may have changed the current output
6996 if Commands_To_Stdout then
6997 Set_Standard_Output;
7002 if Main_Project = No_Project then
7003 Make_Failed ("""", Project_File_Name.all, """ processing failed
");
7006 Create_Mapping_File := True;
7008 if Verbose_Mode then
7010 Write_Str ("Parsing
of project file
""");
7011 Write_Str (Project_File_Name.all);
7012 Write_Str (""" is finished
.");
7016 -- We add the source directories and the object directories
7017 -- to the search paths.
7019 Add_Source_Directories (Main_Project, Project_Tree);
7020 Add_Object_Directories (Main_Project, Project_Tree);
7022 -- Compute depth of each project
7024 for Proj in Project_Table.First ..
7025 Project_Table.Last (Project_Tree.Projects)
7027 Project_Tree.Projects.Table (Proj).Seen := False;
7028 Project_Tree.Projects.Table (Proj).Depth := 0;
7031 Recursive_Compute_Depth (Main_Project, Depth => 1);
7033 -- For each project compute the list of the projects it imports
7034 -- directly or indirectly.
7036 for Proj in Project_Table.First ..
7037 Project_Table.Last (Project_Tree.Projects)
7039 Compute_All_Imported_Projects (Proj);
7044 Osint.Add_Default_Search_Dirs;
7046 -- Source file lookups should be cached for efficiency. Source files
7047 -- are not supposed to change. However, we do that now only if no
7048 -- project file is used; if a project file is used, we do it just
7049 -- after changing the directory to the object directory.
7051 Osint.Source_File_Data (Cache => True);
7053 -- Read gnat.adc file to initialize Fname.UF
7055 Fname.UF.Initialize;
7058 Fname.SF.Read_Source_File_Name_Pragmas;
7061 when Err : SFN_Scan.Syntax_Error_In_GNAT_ADC =>
7062 Make_Failed (Exception_Message (Err));
7066 -- Make sure no project object directory is recorded
7068 Project_Of_Current_Object_Directory := No_Project;
7072 ----------------------------
7073 -- Insert_Project_Sources --
7074 ----------------------------
7076 procedure Insert_Project_Sources
7077 (The_Project : Project_Id;
7078 All_Projects : Boolean;
7081 Put_In_Q : Boolean := Into_Q;
7083 Sfile : File_Name_Type;
7086 Extending : constant Boolean :=
7087 Project_Tree.Projects.Table
7088 (The_Project).Extends /= No_Project;
7090 function Check_Project (P : Project_Id) return Boolean;
7091 -- Returns True if P is The_Project or a project extended by The_Project
7097 function Check_Project (P : Project_Id) return Boolean is
7099 if All_Projects or P = The_Project then
7102 elsif Extending then
7104 Data : Project_Data :=
7105 Project_Tree.Projects.Table (The_Project);
7109 if P = Data.Extends then
7113 Data := Project_Tree.Projects.Table (Data.Extends);
7114 exit when Data.Extends = No_Project;
7122 -- Start of processing for Insert_Project_Sources
7125 -- For all the sources in the project files,
7127 for Id in Unit_Table.First ..
7128 Unit_Table.Last (Project_Tree.Units)
7130 Unit := Project_Tree.Units.Table (Id);
7134 -- If there is a source for the body, and the body has not been
7137 if Unit.File_Names (Body_Part).Name /= No_File
7138 and then Unit.File_Names (Body_Part).Path.Name /= Slash
7140 -- And it is a source for the specified project
7142 if Check_Project (Unit.File_Names (Body_Part).Project) then
7144 -- If we don't have a spec, we cannot consider the source
7145 -- if it is a subunit
7147 if Unit.File_Names (Specification).Name = No_File then
7149 Src_Ind : Source_File_Index;
7151 -- Here we are cheating a little bit: we don't want to
7152 -- use Sinput.L, because it depends on the GNAT tree
7153 -- (Atree, Sinfo, ...). So, we pretend that it is a
7154 -- project file, and we use Sinput.P.
7156 -- Source_File_Is_Subunit is just scanning through the
7157 -- file until it finds one of the reserved words
7158 -- separate, procedure, function, generic or package.
7159 -- Fortunately, these Ada reserved words are also
7160 -- reserved for project files.
7163 Src_Ind := Sinput.P.Load_Project_File
7165 (Unit.File_Names (Body_Part).Path.Name));
7167 -- If it is a subunit, discard it
7169 if Sinput.P.Source_File_Is_Subunit (Src_Ind) then
7173 Sfile := Unit.File_Names (Body_Part).Display_Name;
7174 Index := Unit.File_Names (Body_Part).Index;
7179 Sfile := Unit.File_Names (Body_Part).Display_Name;
7180 Index := Unit.File_Names (Body_Part).Index;
7184 elsif Unit.File_Names (Specification).Name /= No_File
7185 and then Unit.File_Names (Specification).Path.Name /= Slash
7186 and then Check_Project (Unit.File_Names (Specification).Project)
7188 -- If there is no source for the body, but there is a source
7189 -- for the spec which has not been locally removed, then we take
7192 Sfile := Unit.File_Names (Specification).Display_Name;
7193 Index := Unit.File_Names (Specification).Index;
7196 -- If Put_In_Q is True, we insert into the Q
7200 -- For the first source inserted into the Q, we need to initialize
7201 -- the Q, but not for the subsequent sources.
7203 if First_Q_Initialization then
7207 -- And of course, we only insert in the Q if the source is not
7210 if Sfile /= No_File and then not Is_Marked (Sfile, Index) then
7211 if Verbose_Mode then
7212 Write_Str ("Adding
""");
7213 Write_Str (Get_Name_String (Sfile));
7214 Write_Line (""" to the queue
");
7217 Insert_Q (Sfile, Index => Index);
7218 Mark (Sfile, Index);
7221 elsif Sfile /= No_File then
7223 -- If Put_In_Q is False, we add the source as it it were specified
7224 -- on the command line, and we set Put_In_Q to True, so that the
7225 -- following sources will be put directly in the queue. This will
7226 -- allow parallel compilation processes if -jx switch is used.
7228 if Verbose_Mode then
7229 Write_Str ("Adding
""");
7230 Write_Str (Get_Name_String (Sfile));
7231 Write_Line (""" as
if on the command line
");
7234 Osint.Add_File (Get_Name_String (Sfile), Index);
7237 -- As we may look into the Q later, ensure the Q has been
7238 -- initialized to avoid errors.
7240 if First_Q_Initialization then
7245 end Insert_Project_Sources;
7252 (Source_File : File_Name_Type;
7253 Source_Unit : Unit_Name_Type := No_Unit_Name;
7257 if Debug.Debug_Flag_Q then
7258 Write_Str (" Q
:= Q
+ [ ");
7259 Write_Name (Source_File);
7271 (File => Source_File,
7272 Unit => Source_Unit,
7277 ---------------------
7278 -- Is_In_Obsoleted --
7279 ---------------------
7281 function Is_In_Obsoleted (F : File_Name_Type) return Boolean is
7288 Name : constant String := Get_Name_String (F);
7290 F2 : File_Name_Type;
7294 while First > Name'First
7295 and then Name (First - 1) /= Directory_Separator
7296 and then Name (First - 1) /= '/'
7301 if First /= Name'First then
7303 Add_Str_To_Name_Buffer (Name (First .. Name'Last));
7310 return Obsoleted.Get (F2);
7313 end Is_In_Obsoleted;
7315 ----------------------------
7316 -- Is_In_Object_Directory --
7317 ----------------------------
7319 function Is_In_Object_Directory
7320 (Source_File : File_Name_Type;
7321 Full_Lib_File : File_Name_Type) return Boolean
7324 -- There is something to check only when using project files.
7325 -- Otherwise, this function returns True (last line of the function).
7327 if Main_Project /= No_Project then
7329 Source_File_Name : constant String :=
7330 Get_Name_String (Source_File);
7331 Saved_Verbosity : constant Verbosity := Current_Verbosity;
7332 Project : Project_Id := No_Project;
7333 Data : Project_Data;
7335 Path_Name : Path_Name_Type := No_Path;
7336 pragma Warnings (Off, Path_Name);
7339 -- Call Get_Reference to know the ultimate extending project of
7340 -- the source. Call it with verbosity default to avoid verbose
7343 Current_Verbosity := Default;
7344 Prj.Env.Get_Reference
7345 (Source_File_Name => Source_File_Name,
7347 In_Tree => Project_Tree,
7349 Current_Verbosity := Saved_Verbosity;
7351 -- If this source is in a project, check that the ALI file is
7352 -- in its object directory. If it is not, return False, so that
7353 -- the ALI file will not be skipped.
7355 if Project /= No_Project then
7356 Data := Project_Tree.Projects.Table (Project);
7359 Object_Directory : constant String :=
7362 (Data.Object_Directory.Display_Name));
7364 Olast : Natural := Object_Directory'Last;
7366 Lib_File_Directory : constant String :=
7367 Normalize_Pathname (Dir_Name
7368 (Get_Name_String (Full_Lib_File)));
7370 Llast : Natural := Lib_File_Directory'Last;
7373 -- For directories, Normalize_Pathname may or may not put
7374 -- a directory separator at the end, depending on its input.
7375 -- Remove any last directory separator before comparison.
7376 -- Returns True only if the two directories are the same.
7378 if Object_Directory (Olast) = Directory_Separator then
7382 if Lib_File_Directory (Llast) = Directory_Separator then
7386 return Object_Directory (Object_Directory'First .. Olast) =
7387 Lib_File_Directory (Lib_File_Directory'First .. Llast);
7393 -- When the source is not in a project file, always return True
7396 end Is_In_Object_Directory;
7403 (ALI_File : File_Name_Type;
7404 Args : Argument_List;
7405 Success : out Boolean)
7407 Link_Args : Argument_List (1 .. Args'Length + 1);
7410 Get_Name_String (ALI_File);
7411 Link_Args (1) := new String'(Name_Buffer (1 .. Name_Len));
7413 Link_Args (2 .. Args'Length + 1) := Args;
7415 GNAT.OS_Lib.Normalize_Arguments (Link_Args);
7417 Display (Gnatlink.all, Link_Args);
7419 if Gnatlink_Path = null then
7420 Make_Failed ("error
, unable to locate
", Gnatlink.all);
7423 GNAT.OS_Lib.Spawn (Gnatlink_Path.all, Link_Args, Success);
7426 ---------------------------
7427 -- List_Bad_Compilations --
7428 ---------------------------
7430 procedure List_Bad_Compilations is
7432 for J in Bad_Compilation.First .. Bad_Compilation.Last loop
7433 if Bad_Compilation.Table (J).File = No_File then
7435 elsif not Bad_Compilation.Table (J).Found then
7436 Inform (Bad_Compilation.Table (J).File, "not found
");
7438 Inform (Bad_Compilation.Table (J).File, "compilation error
");
7441 end List_Bad_Compilations;
7447 procedure List_Depend is
7448 Lib_Name : File_Name_Type;
7449 Obj_Name : File_Name_Type;
7450 Src_Name : File_Name_Type;
7454 Line_Size : constant := 77;
7457 Set_Standard_Output;
7459 for A in ALIs.First .. ALIs.Last loop
7460 Lib_Name := ALIs.Table (A).Afile;
7462 -- We have to provide the full library file name in In_Place_Mode
7464 if In_Place_Mode then
7465 Lib_Name := Full_Lib_File_Name (Lib_Name);
7468 Obj_Name := Object_File_Name (Lib_Name);
7469 Write_Name (Obj_Name);
7472 Get_Name_String (Obj_Name);
7474 Line_Pos := Len + 2;
7476 for D in ALIs.Table (A).First_Sdep .. ALIs.Table (A).Last_Sdep loop
7477 Src_Name := Sdep.Table (D).Sfile;
7479 if Is_Internal_File_Name (Src_Name)
7480 and then not Check_Readonly_Files
7484 if not Quiet_Output then
7485 Src_Name := Full_Source_Name (Src_Name);
7488 Get_Name_String (Src_Name);
7491 if Line_Pos + Len + 1 > Line_Size then
7497 Line_Pos
:= Line_Pos
+ Len
+ 1;
7500 Write_Name
(Src_Name
);
7507 if not Commands_To_Stdout
then
7516 procedure Make_Failed
(S1
: String; S2
: String := ""; S3
: String := "") is
7518 Delete_All_Temp_Files
;
7519 Osint
.Fail
(S1
, S2
, S3
);
7522 --------------------
7523 -- Mark_Directory --
7524 --------------------
7526 procedure Mark_Directory
7528 Mark
: Lib_Mark_Type
;
7529 On_Command_Line
: Boolean)
7535 if On_Command_Line
then
7537 Real_Path
: constant String := Normalize_Pathname
(Dir
);
7540 if Real_Path
'Length = 0 then
7541 Name_Len
:= Dir
'Length;
7542 Name_Buffer
(1 .. Name_Len
) := Dir
;
7545 Name_Len
:= Real_Path
'Length;
7546 Name_Buffer
(1 .. Name_Len
) := Real_Path
;
7552 Real_Path
: constant String :=
7556 (Project_Tree
.Projects
.Table
7557 (Main_Project
).Directory
.Display_Name
));
7560 if Real_Path
'Length = 0 then
7561 Name_Len
:= Dir
'Length;
7562 Name_Buffer
(1 .. Name_Len
) := Dir
;
7565 Name_Len
:= Real_Path
'Length;
7566 Name_Buffer
(1 .. Name_Len
) := Real_Path
;
7571 -- Last character is supposed to be a directory separator
7573 if not Is_Directory_Separator
(Name_Buffer
(Name_Len
)) then
7574 Name_Len
:= Name_Len
+ 1;
7575 Name_Buffer
(Name_Len
) := Directory_Separator
;
7578 -- Add flags to the already existing flags
7581 B
:= Get_Name_Table_Byte
(N
);
7582 Set_Name_Table_Byte
(N
, B
or Mark
);
7585 -----------------------------
7586 -- Recursive_Compute_Depth --
7587 -----------------------------
7589 procedure Recursive_Compute_Depth
7590 (Project
: Project_Id
;
7593 List
: Project_List
;
7597 -- Nothing to do if there is no project or if the project has already
7598 -- been seen or if the depth is large enough.
7600 if Project
= No_Project
7601 or else Project_Tree
.Projects
.Table
(Project
).Seen
7602 or else Project_Tree
.Projects
.Table
(Project
).Depth
>= Depth
7607 Project_Tree
.Projects
.Table
(Project
).Depth
:= Depth
;
7609 -- Mark project as Seen to avoid endless loop caused by limited withs
7611 Project_Tree
.Projects
.Table
(Project
).Seen
:= True;
7613 List
:= Project_Tree
.Projects
.Table
(Project
).Imported_Projects
;
7615 -- Visit each imported project
7617 while List
/= Empty_Project_List
loop
7618 Proj
:= Project_Tree
.Project_Lists
.Table
(List
).Project
;
7619 List
:= Project_Tree
.Project_Lists
.Table
(List
).Next
;
7620 Recursive_Compute_Depth
7622 Depth
=> Depth
+ 1);
7625 -- Visit a project being extended, if any
7627 Recursive_Compute_Depth
7628 (Project
=> Project_Tree
.Projects
.Table
(Project
).Extends
,
7629 Depth
=> Depth
+ 1);
7631 -- Reset the Seen flag, as we leave this project
7633 Project_Tree
.Projects
.Table
(Project
).Seen
:= False;
7634 end Recursive_Compute_Depth
;
7636 -------------------------------
7637 -- Report_Compilation_Failed --
7638 -------------------------------
7640 procedure Report_Compilation_Failed
is
7642 Delete_All_Temp_Files
;
7643 Exit_Program
(E_Fatal
);
7644 end Report_Compilation_Failed
;
7646 ------------------------
7647 -- Sigint_Intercepted --
7648 ------------------------
7650 procedure Sigint_Intercepted
is
7651 SIGINT
: constant := 2;
7654 Write_Line
("*** Interrupted ***");
7656 -- Send SIGINT to all outstanding compilation processes spawned
7658 for J
in 1 .. Outstanding_Compiles
loop
7659 Kill
(Running_Compile
(J
).Pid
, SIGINT
, 1);
7662 Delete_All_Temp_Files
;
7664 -- ??? OS_Exit (1) is equivalent to Exit_Program (E_No_Compile),
7665 -- shouldn't that be Exit_Program (E_Abort) instead?
7666 end Sigint_Intercepted
;
7672 procedure Scan_Make_Arg
(Argv
: String; And_Save
: Boolean) is
7676 Gnatmake_Switch_Found
:= True;
7678 pragma Assert
(Argv
'First = 1);
7680 if Argv
'Length = 0 then
7684 -- If the previous switch has set the Project_File_Name_Present flag
7685 -- (that is we have seen a -P alone), then the next argument is the name
7686 -- of the project file.
7688 if Project_File_Name_Present
and then Project_File_Name
= null then
7689 if Argv
(1) = '-' then
7690 Make_Failed
("project file name missing after -P");
7693 Project_File_Name_Present
:= False;
7694 Project_File_Name
:= new String'(Argv);
7697 -- If the previous switch has set the Output_File_Name_Present flag
7698 -- (that is we have seen a -o), then the next argument is the name of
7699 -- the output executable.
7701 elsif Output_File_Name_Present
7702 and then not Output_File_Name_Seen
7704 Output_File_Name_Seen := True;
7706 if Argv (1) = '-' then
7707 Make_Failed ("output file name missing after -o");
7710 Add_Switch ("-o", Linker, And_Save => And_Save);
7711 Add_Switch (Executable_Name (Argv), Linker, And_Save => And_Save);
7714 -- If the previous switch has set the Object_Directory_Present flag
7715 -- (that is we have seen a -D), then the next argument is the path name
7716 -- of the object directory..
7718 elsif Object_Directory_Present
7719 and then not Object_Directory_Seen
7721 Object_Directory_Seen := True;
7723 if Argv (1) = '-' then
7724 Make_Failed ("object directory path name missing after -D");
7726 elsif not Is_Directory (Argv) then
7727 Make_Failed ("cannot find object directory """, Argv, """");
7730 Add_Lib_Search_Dir (Argv);
7732 -- Specify the object directory to the binder
7734 Add_Switch ("-aO" & Argv, Binder, And_Save => And_Save);
7736 -- Record the object directory. Make sure it ends with a directory
7739 if Argv (Argv'Last) = Directory_Separator then
7740 Object_Directory_Path :=
7743 Object_Directory_Path
:=
7744 new String'(Argv & Directory_Separator);
7748 -- Then check if we are dealing with -cargs/-bargs/-largs/-margs
7750 elsif Argv = "-bargs"
7759 when 'c
' => Program_Args := Compiler;
7760 when 'b
' => Program_Args := Binder;
7761 when 'l
' => Program_Args := Linker;
7762 when 'm
' => Program_Args := None;
7765 raise Program_Error;
7768 -- A special test is needed for the -o switch within a -largs
7769 -- since that is another way to specify the name of the final
7772 elsif Program_Args = Linker
7773 and then Argv = "-o"
7775 Make_Failed ("switch -o not allowed within a -largs. " &
7776 "Use -o directly.");
7778 -- Check to see if we are reading switches after a -cargs,
7779 -- -bargs or -largs switch. If yes save it.
7781 elsif Program_Args /= None then
7783 -- Check to see if we are reading -I switches in order
7784 -- to take into account in the src & lib search directories.
7786 if Argv'Length > 2 and then Argv (1 .. 2) = "-I" then
7787 if Argv (3 .. Argv'Last) = "-" then
7788 Look_In_Primary_Dir := False;
7790 elsif Program_Args = Compiler then
7791 if Argv (3 .. Argv'Last) /= "-" then
7792 Add_Source_Search_Dir (Argv (3 .. Argv'Last), And_Save);
7795 elsif Program_Args = Binder then
7796 Add_Library_Search_Dir (Argv (3 .. Argv'Last), And_Save);
7800 Add_Switch (Argv, Program_Args, And_Save => And_Save);
7802 -- Handle non-default compiler, binder, linker, and handle --RTS switch
7804 elsif Argv'Length > 2 and then Argv (1 .. 2) = "--" then
7806 and then Argv (1 .. 6) = "--GCC="
7809 Program_Args : constant Argument_List_Access :=
7810 Argument_String_To_List
7811 (Argv (7 .. Argv'Last));
7815 Saved_Gcc := new String'(Program_Args
.all (1).all);
7817 Gcc
:= new String'(Program_Args.all (1).all);
7820 for J in 2 .. Program_Args.all'Last loop
7822 (Program_Args.all (J).all,
7824 And_Save => And_Save);
7828 elsif Argv'Length > 11
7829 and then Argv (1 .. 11) = "--GNATBIND="
7832 Program_Args : constant Argument_List_Access :=
7833 Argument_String_To_List
7834 (Argv (12 .. Argv'Last));
7838 Saved_Gnatbind := new String'(Program_Args
.all (1).all);
7840 Gnatbind
:= new String'(Program_Args.all (1).all);
7843 for J in 2 .. Program_Args.all'Last loop
7845 (Program_Args.all (J).all, Binder, And_Save => And_Save);
7849 elsif Argv'Length > 11
7850 and then Argv (1 .. 11) = "--GNATLINK="
7853 Program_Args : constant Argument_List_Access :=
7854 Argument_String_To_List
7855 (Argv (12 .. Argv'Last));
7858 Saved_Gnatlink := new String'(Program_Args
.all (1).all);
7860 Gnatlink
:= new String'(Program_Args.all (1).all);
7863 for J in 2 .. Program_Args.all'Last loop
7864 Add_Switch (Program_Args.all (J).all, Linker);
7868 elsif Argv'Length >= 5 and then
7869 Argv (1 .. 5) = "--RTS"
7871 Add_Switch (Argv, Compiler, And_Save => And_Save);
7872 Add_Switch (Argv, Binder, And_Save => And_Save);
7874 if Argv'Length <= 6 or else Argv (6) /= '=' then
7875 Make_Failed ("missing path for --RTS");
7878 -- Check that this is the first time we see this switch or
7879 -- if it is not the first time, the same path is specified.
7881 if RTS_Specified = null then
7882 RTS_Specified := new String'(Argv
(7 .. Argv
'Last));
7884 elsif RTS_Specified
.all /= Argv
(7 .. Argv
'Last) then
7885 Make_Failed
("--RTS cannot be specified multiple times");
7888 -- Valid --RTS switch
7895 Src_Path_Name
: constant String_Ptr
:=
7897 (Argv
(7 .. Argv
'Last), Include
);
7899 Lib_Path_Name
: constant String_Ptr
:=
7901 (Argv
(7 .. Argv
'Last), Objects
);
7904 if Src_Path_Name
/= null
7905 and then Lib_Path_Name
/= null
7907 -- Set RTS_*_Path_Name variables, so that correct direct-
7908 -- ories will be set when Osint.Add_Default_Search_Dirs
7911 RTS_Src_Path_Name
:= Src_Path_Name
;
7912 RTS_Lib_Path_Name
:= Lib_Path_Name
;
7914 elsif Src_Path_Name
= null
7915 and Lib_Path_Name
= null
7917 Make_Failed
("RTS path not valid: missing " &
7918 "adainclude and adalib directories");
7920 elsif Src_Path_Name
= null then
7921 Make_Failed
("RTS path not valid: missing adainclude " &
7924 elsif Lib_Path_Name
= null then
7925 Make_Failed
("RTS path not valid: missing adalib " &
7932 Scan_Make_Switches
(Argv
, Success
);
7935 -- If we have seen a regular switch process it
7937 elsif Argv
(1) = '-' then
7938 if Argv
'Length = 1 then
7939 Make_Failed
("switch character cannot be followed by a blank");
7941 -- Incorrect switches that should start with "--"
7943 elsif (Argv
'Length > 5 and then Argv
(1 .. 5) = "-RTS=")
7944 or else (Argv
'Length > 5 and then Argv
(1 .. 5) = "-GCC=")
7945 or else (Argv
'Length > 10 and then Argv
(1 .. 10) = "-GNATLINK=")
7946 or else (Argv
'Length > 10 and then Argv
(1 .. 10) = "-GNATBIND=")
7948 Make_Failed
("option ", Argv
, " should start with '--'");
7952 elsif Argv
(2 .. Argv
'Last) = "I-" then
7953 Look_In_Primary_Dir
:= False;
7955 -- Forbid -?- or -??- where ? is any character
7957 elsif (Argv
'Length = 3 and then Argv
(3) = '-')
7958 or else (Argv
'Length = 4 and then Argv
(4) = '-')
7960 Make_Failed
("trailing ""-"" at the end of ", Argv
, " forbidden.");
7964 elsif Argv
(2) = 'I' then
7965 Add_Source_Search_Dir
(Argv
(3 .. Argv
'Last), And_Save
);
7966 Add_Library_Search_Dir
(Argv
(3 .. Argv
'Last), And_Save
);
7967 Add_Switch
(Argv
, Compiler
, And_Save
=> And_Save
);
7968 Add_Switch
(Argv
, Binder
, And_Save
=> And_Save
);
7970 -- -aIdir (to gcc this is like a -I switch)
7972 elsif Argv
'Length >= 3 and then Argv
(2 .. 3) = "aI" then
7973 Add_Source_Search_Dir
(Argv
(4 .. Argv
'Last), And_Save
);
7974 Add_Switch
("-I" & Argv
(4 .. Argv
'Last),
7976 And_Save
=> And_Save
);
7977 Add_Switch
(Argv
, Binder
, And_Save
=> And_Save
);
7981 elsif Argv
'Length >= 3 and then Argv
(2 .. 3) = "aO" then
7982 Add_Library_Search_Dir
(Argv
(4 .. Argv
'Last), And_Save
);
7983 Add_Switch
(Argv
, Binder
, And_Save
=> And_Save
);
7985 -- -aLdir (to gnatbind this is like a -aO switch)
7987 elsif Argv
'Length >= 3 and then Argv
(2 .. 3) = "aL" then
7988 Mark_Directory
(Argv
(4 .. Argv
'Last), Ada_Lib_Dir
, And_Save
);
7989 Add_Library_Search_Dir
(Argv
(4 .. Argv
'Last), And_Save
);
7990 Add_Switch
("-aO" & Argv
(4 .. Argv
'Last),
7992 And_Save
=> And_Save
);
7996 elsif Argv
'Length >= 13 and then Argv
(2 .. 13) = "aamp_target=" then
7997 Add_Switch
(Argv
, Compiler
, And_Save
=> And_Save
);
7999 -- Set the aamp_target environment variable so that the binder and
8000 -- linker will use the proper target library. This is consistent
8001 -- with how things work when -aamp_target is passed on the command
8002 -- line to gnaampmake.
8004 Setenv
("aamp_target", Argv
(14 .. Argv
'Last));
8006 -- -Adir (to gnatbind this is like a -aO switch, to gcc like a -I)
8008 elsif Argv
(2) = 'A' then
8009 Mark_Directory
(Argv
(3 .. Argv
'Last), Ada_Lib_Dir
, And_Save
);
8010 Add_Source_Search_Dir
(Argv
(3 .. Argv
'Last), And_Save
);
8011 Add_Library_Search_Dir
(Argv
(3 .. Argv
'Last), And_Save
);
8012 Add_Switch
("-I" & Argv
(3 .. Argv
'Last),
8014 And_Save
=> And_Save
);
8015 Add_Switch
("-aO" & Argv
(3 .. Argv
'Last),
8017 And_Save
=> And_Save
);
8021 elsif Argv
(2) = 'L' then
8022 Add_Switch
(Argv
, Linker
, And_Save
=> And_Save
);
8024 -- For -gxxxxx, -pg, -mxxx, -fxxx: give the switch to both the
8025 -- compiler and the linker (except for -gnatxxx which is only for
8026 -- the compiler). Some of the -mxxx (for example -m64) and -fxxx
8027 -- (for example -ftest-coverage for gcov) need to be used when
8028 -- compiling the binder generated files, and using all these gcc
8029 -- switches for the binder generated files should not be a problem.
8032 (Argv
(2) = 'g' and then (Argv
'Last < 5
8033 or else Argv
(2 .. 5) /= "gnat"))
8034 or else Argv
(2 .. Argv
'Last) = "pg"
8035 or else (Argv
(2) = 'm' and then Argv
'Last > 2)
8036 or else (Argv
(2) = 'f' and then Argv
'Last > 2)
8038 Add_Switch
(Argv
, Compiler
, And_Save
=> And_Save
);
8039 Add_Switch
(Argv
, Linker
, And_Save
=> And_Save
);
8041 -- -C=<mapping file>
8043 elsif Argv
'Last > 2 and then Argv
(2) = 'C' then
8045 if Argv
(3) /= '=' or else Argv
'Last <= 3 then
8046 Make_Failed
("illegal switch ", Argv
);
8049 Gnatmake_Mapping_File
:= new String'(Argv (4 .. Argv'Last));
8054 elsif Argv'Last = 2 and then Argv (2) = 'D
' then
8055 if Project_File_Name /= null then
8056 Make_Failed ("-D cannot be used in conjunction with a " &
8060 Scan_Make_Switches (Argv, Success);
8065 elsif Argv (2) = 'd
'
8066 and then Argv'Last = 2
8068 Display_Compilation_Progress := True;
8072 elsif Argv'Last = 2 and then Argv (2) = 'i
' then
8073 if Project_File_Name /= null then
8074 Make_Failed ("-i cannot be used in conjunction with a " &
8077 Scan_Make_Switches (Argv, Success);
8080 -- -j (need to save the result)
8082 elsif Argv (2) = 'j
' then
8083 Scan_Make_Switches (Argv, Success);
8086 Saved_Maximum_Processes := Maximum_Processes;
8091 elsif Argv (2) = 'm
'
8092 and then Argv'Last = 2
8094 Minimal_Recompilation := True;
8098 elsif Argv (2) = 'u
'
8099 and then Argv'Last = 2
8101 Unique_Compile := True;
8102 Compile_Only := True;
8103 Do_Bind_Step := False;
8104 Do_Link_Step := False;
8108 elsif Argv (2) = 'U
'
8109 and then Argv'Last = 2
8111 Unique_Compile_All_Projects := True;
8112 Unique_Compile := True;
8113 Compile_Only := True;
8114 Do_Bind_Step := False;
8115 Do_Link_Step := False;
8117 -- -Pprj or -P prj (only once, and only on the command line)
8119 elsif Argv (2) = 'P
' then
8120 if Project_File_Name /= null then
8121 Make_Failed ("cannot have several project files specified");
8123 elsif Object_Directory_Path /= null then
8124 Make_Failed ("-D cannot be used in conjunction with a " &
8127 elsif In_Place_Mode then
8128 Make_Failed ("-i cannot be used in conjunction with a " &
8131 elsif not And_Save then
8133 -- It could be a tool other than gnatmake (i.e, gnatdist)
8134 -- or a -P switch inside a project file.
8137 ("either the tool is not ""project-aware"" or " &
8138 "a project file is specified inside a project file");
8140 elsif Argv'Last = 2 then
8142 -- -P is used alone: the project file name is the next option
8144 Project_File_Name_Present := True;
8147 Project_File_Name := new String'(Argv
(3 .. Argv
'Last));
8150 -- -vPx (verbosity of the parsing of the project files)
8153 and then Argv
(2 .. 3) = "vP"
8154 and then Argv
(4) in '0' .. '2'
8159 Current_Verbosity
:= Prj
.Default
;
8161 Current_Verbosity
:= Prj
.Medium
;
8163 Current_Verbosity
:= Prj
.High
;
8169 -- -Xext=val (External assignment)
8171 elsif Argv
(2) = 'X'
8172 and then Is_External_Assignment
(Argv
)
8174 -- Is_External_Assignment has side effects
8175 -- when it returns True;
8179 -- If -gnath is present, then generate the usage information
8180 -- right now and do not pass this option on to the compiler calls.
8182 elsif Argv
= "-gnath" then
8185 -- If -gnatc is specified, make sure the bind step and the link
8186 -- step are not executed.
8188 elsif Argv
'Length >= 6 and then Argv
(2 .. 6) = "gnatc" then
8190 -- If -gnatc is specified, make sure the bind step and the link
8191 -- step are not executed.
8193 Add_Switch
(Argv
, Compiler
, And_Save
=> And_Save
);
8194 Operating_Mode
:= Check_Semantics
;
8195 Check_Object_Consistency
:= False;
8196 Compile_Only
:= True;
8197 Do_Bind_Step
:= False;
8198 Do_Link_Step
:= False;
8200 elsif Argv
(2 .. Argv
'Last) = "nostdlib" then
8202 -- Don't pass -nostdlib to gnatlink, it will disable
8203 -- linking with all standard library files.
8207 Add_Switch
(Argv
, Compiler
, And_Save
=> And_Save
);
8208 Add_Switch
(Argv
, Binder
, And_Save
=> And_Save
);
8210 elsif Argv
(2 .. Argv
'Last) = "nostdinc" then
8212 -- Pass -nostdinc to the Compiler and to gnatbind
8215 Add_Switch
(Argv
, Compiler
, And_Save
=> And_Save
);
8216 Add_Switch
(Argv
, Binder
, And_Save
=> And_Save
);
8218 -- All other switches are processed by Scan_Make_Switches. If the
8219 -- call returns with Gnatmake_Switch_Found = False, then the switch
8220 -- is passed to the compiler.
8223 Scan_Make_Switches
(Argv
, Gnatmake_Switch_Found
);
8225 if not Gnatmake_Switch_Found
then
8226 Add_Switch
(Argv
, Compiler
, And_Save
=> And_Save
);
8230 -- If not a switch it must be a file name
8234 Mains
.Add_Main
(Argv
);
8242 function Switches_Of
8243 (Source_File
: File_Name_Type
;
8244 Source_File_Name
: String;
8246 Naming
: Naming_Data
;
8247 In_Package
: Package_Id
;
8248 Allow_ALI
: Boolean) return Variable_Value
8250 Switches
: Variable_Value
;
8252 Defaults
: constant Array_Element_Id
:=
8254 (Name
=> Name_Default_Switches
,
8256 Project_Tree
.Packages
.Table
8257 (In_Package
).Decl
.Arrays
,
8258 In_Tree
=> Project_Tree
);
8260 Switches_Array
: constant Array_Element_Id
:=
8262 (Name
=> Name_Switches
,
8264 Project_Tree
.Packages
.Table
8265 (In_Package
).Decl
.Arrays
,
8266 In_Tree
=> Project_Tree
);
8269 -- First, try Switches (<file name>)
8273 (Index
=> Name_Id
(Source_File
),
8274 Src_Index
=> Source_Index
,
8275 In_Array
=> Switches_Array
,
8276 In_Tree
=> Project_Tree
);
8278 -- Check also without the suffix
8280 if Switches
= Nil_Variable_Value
then
8282 Name
: String (1 .. Source_File_Name
'Length + 3);
8283 Last
: Positive := Source_File_Name
'Length;
8284 Spec_Suffix
: constant String :=
8285 Spec_Suffix_Of
(Project_Tree
, "ada", Naming
);
8286 Body_Suffix
: constant String :=
8287 Body_Suffix_Of
(Project_Tree
, "ada", Naming
);
8288 Truncated
: Boolean := False;
8291 Name
(1 .. Last
) := Source_File_Name
;
8293 if Last
> Body_Suffix
'Length
8294 and then Name
(Last
- Body_Suffix
'Length + 1 .. Last
) =
8298 Last
:= Last
- Body_Suffix
'Length;
8302 and then Last
> Spec_Suffix
'Length
8303 and then Name
(Last
- Spec_Suffix
'Length + 1 .. Last
) =
8307 Last
:= Last
- Spec_Suffix
'Length;
8312 Name_Buffer
(1 .. Name_Len
) := Name
(1 .. Last
);
8315 (Index
=> Name_Find
,
8317 In_Array
=> Switches_Array
,
8318 In_Tree
=> Project_Tree
);
8320 if Switches
= Nil_Variable_Value
8323 Last
:= Source_File_Name
'Length;
8325 while Name
(Last
) /= '.' loop
8329 Name
(Last
+ 1 .. Last
+ 3) := "ali";
8330 Name_Len
:= Last
+ 3;
8331 Name_Buffer
(1 .. Name_Len
) := Name
(1 .. Name_Len
);
8334 (Index
=> Name_Find
,
8336 In_Array
=> Switches_Array
,
8337 In_Tree
=> Project_Tree
);
8343 -- Next, try Switches ("Ada")
8345 if Switches
= Nil_Variable_Value
then
8350 In_Array
=> Switches_Array
,
8351 In_Tree
=> Project_Tree
,
8352 Force_Lower_Case_Index
=> True);
8354 if Switches
/= Nil_Variable_Value
then
8355 Switch_May_Be_Passed_To_The_Compiler
:= False;
8359 -- Next, try Switches (others)
8361 if Switches
= Nil_Variable_Value
then
8364 (Index
=> All_Other_Names
,
8366 In_Array
=> Switches_Array
,
8367 In_Tree
=> Project_Tree
);
8369 if Switches
/= Nil_Variable_Value
then
8370 Switch_May_Be_Passed_To_The_Compiler
:= False;
8374 -- And finally, Default_Switches ("Ada")
8376 if Switches
= Nil_Variable_Value
then
8381 In_Array
=> Defaults
,
8382 In_Tree
=> Project_Tree
);
8394 if Usage_Needed
then
8395 Usage_Needed
:= False;
8404 procedure Verbose_Msg
8407 N2
: Name_Id
:= No_Name
;
8409 Prefix
: String := " -> ";
8410 Minimum_Verbosity
: Verbosity_Level_Type
:= Opt
.Low
)
8413 if (not Verbose_Mode
) or else (Minimum_Verbosity
> Verbosity_Level
) then
8423 if N2
/= No_Name
then
8433 procedure Verbose_Msg
8434 (N1
: File_Name_Type
;
8436 N2
: File_Name_Type
:= No_File
;
8438 Prefix
: String := " -> ";
8439 Minimum_Verbosity
: Verbosity_Level_Type
:= Opt
.Low
)
8443 (Name_Id
(N1
), S1
, Name_Id
(N2
), S2
, Prefix
, Minimum_Verbosity
);
8447 -- Make sure that in case of failure, the temp files will be deleted
8449 Prj
.Com
.Fail
:= Make_Failed
'Access;
8450 MLib
.Fail
:= Make_Failed
'Access;
8451 Makeutl
.Do_Fail
:= Make_Failed
'Access;