10.14 An Extended Example

Suppose that we have two programs, prog1 and prog2, with the sources in the respective directories. We would like to build them with a single gnatmake command, and we would like to place their object files into .build subdirectories of the source directories. Furthermore, we would like to have to have two separate subdirectories in .build – release and debug – which will contain the object files compiled with different set of compilation flags.

In other words, we have the following structure:

        main
          |- prog1
          |    |- .build
          |         | debug
          |         | release
          |- prog2
               |- .build
                    | debug
                    | release

Here are the project files that we need to create in a directory main to maintain this structure:

1. We create a Common project with a package Compiler that specifies the compilation switches:

             File "common.gpr":
             project Common is
             
                for Source_Dirs use (); -- No source files
             
                type Build_Type is ("release", "debug");
                Build : Build_Type := External ("BUILD", "debug");
                package Compiler is
                   case Build is
                      when "release" =>
                        for Default_Switches ("Ada") use ("-O2");
                      when "debug"   =>
                        for Default_Switches ("Ada") use ("-g");
                   end case;
                end Compiler;
             
             end Common;
        

2. We create separate projects for the two programs:

             File "prog1.gpr":
             
             with "common";
             project Prog1 is
             
                 for Source_Dirs use ("prog1");
                 for Object_Dir  use "prog1/.build/" & Common.Build;
             
                 package Compiler renames Common.Compiler;
             
             end Prog1;
        

             File "prog2.gpr":
             
             with "common";
             project Prog2 is
             
                 for Source_Dirs use ("prog2");
                 for Object_Dir  use "prog2/.build/" & Common.Build;
             
                 package Compiler renames Common.Compiler;
             end Prog2;
        

3. We create a wrapping project Main:

             File "main.gpr":
             
             with "common";
             with "prog1";
             with "prog2";
             project Main is
             
                package Compiler renames Common.Compiler;
             
             end Main;
        

4. Finally we need to create a dummy procedure that withs (either explicitly or implicitly) all the sources of our two programs.

Now we can build the programs using the command

        gnatmake -Pmain dummy

for the Debug mode, or

        gnatmake -Pmain -XBUILD=release

for the Release mode.