@copying
@quotation
-GNAT User's Guide for Native Platforms , November 13, 2015
+GNAT User's Guide for Native Platforms , November 18, 2015
AdaCore
* Calling Conventions::
* Building Mixed Ada and C++ Programs::
* Generating Ada Bindings for C and C++ headers::
+* Generating C Headers for Ada Specifications::
Building Mixed Ada and C++ Programs
Generating Ada Bindings for C and C++ headers
-* Running the binding generator::
-* Generating bindings for C++ headers::
+* Running the Binding Generator::
+* Generating Bindings for C++ Headers::
* Switches::
+Generating C Headers for Ada Specifications
+
+* Running the C Header Generator::
+
GNAT and Other Compilation Models
* Comparison between GNAT and C/C++ Compilation Models::
Overflow Check Handling in GNAT
* Background::
-* Overflow Checking Modes in GNAT::
+* Management of Overflows in GNAT::
* Specifying the Desired Mode::
* Default Settings::
* Implementation Notes::
* Calling Conventions::
* Building Mixed Ada and C++ Programs::
* Generating Ada Bindings for C and C++ headers::
+* Generating C Headers for Ada Specifications::
@end menu
@}
@end example
-@node Generating Ada Bindings for C and C++ headers,,Building Mixed Ada and C++ Programs,Mixed Language Programming
+@node Generating Ada Bindings for C and C++ headers,Generating C Headers for Ada Specifications,Building Mixed Ada and C++ Programs,Mixed Language Programming
@anchor{gnat_ugn/the_gnat_compilation_model id70}@anchor{c9}@anchor{gnat_ugn/the_gnat_compilation_model generating-ada-bindings-for-c-and-c-headers}@anchor{1b}
@subsection Generating Ada Bindings for C and C++ headers
easier to interface with other languages than previous versions of Ada.
@menu
-* Running the binding generator::
-* Generating bindings for C++ headers::
+* Running the Binding Generator::
+* Generating Bindings for C++ Headers::
* Switches::
@end menu
-@node Running the binding generator,Generating bindings for C++ headers,,Generating Ada Bindings for C and C++ headers
+@node Running the Binding Generator,Generating Bindings for C++ Headers,,Generating Ada Bindings for C and C++ headers
@anchor{gnat_ugn/the_gnat_compilation_model id71}@anchor{ca}@anchor{gnat_ugn/the_gnat_compilation_model running-the-binding-generator}@anchor{cb}
-@subsubsection Running the binding generator
+@subsubsection Running the Binding Generator
The binding generator is part of the @emph{gcc} compiler and can be
$ g++ -c -fdump-ada-spec readline1.h
@end example
-@node Generating bindings for C++ headers,Switches,Running the binding generator,Generating Ada Bindings for C and C++ headers
+@node Generating Bindings for C++ Headers,Switches,Running the Binding Generator,Generating Ada Bindings for C and C++ headers
@anchor{gnat_ugn/the_gnat_compilation_model id72}@anchor{cc}@anchor{gnat_ugn/the_gnat_compilation_model generating-bindings-for-c-headers}@anchor{cd}
-@subsubsection Generating bindings for C++ headers
+@subsubsection Generating Bindings for C++ Headers
Generating bindings for C++ headers is done using the same options, always
use Class_Dog;
@end example
-@node Switches,,Generating bindings for C++ headers,Generating Ada Bindings for C and C++ headers
+@node Switches,,Generating Bindings for C++ Headers,Generating Ada Bindings for C and C++ headers
@anchor{gnat_ugn/the_gnat_compilation_model switches}@anchor{ce}@anchor{gnat_ugn/the_gnat_compilation_model switches-for-ada-binding-generation}@anchor{cf}
@subsubsection Switches
Extract comments from headers and generate Ada comments in the Ada spec files.
@end table
+@node Generating C Headers for Ada Specifications,,Generating Ada Bindings for C and C++ headers,Mixed Language Programming
+@anchor{gnat_ugn/the_gnat_compilation_model generating-c-headers-for-ada-specifications}@anchor{d0}@anchor{gnat_ugn/the_gnat_compilation_model id73}@anchor{d1}
+@subsection Generating C Headers for Ada Specifications
+
+
+@geindex Binding generation (for Ada specs)
+
+@geindex C headers (binding generation)
+
+GNAT includes a C header generator for Ada specifications which supports
+Ada types that have a direct mapping to C types. This includes in particular
+support for:
+
+
+@itemize *
+
+@item
+Scalar types
+
+@item
+Constrained arrays
+
+@item
+Records (untagged)
+
+@item
+Composition of the above types
+
+@item
+Constant declarations
+
+@item
+Object declarations
+
+@item
+Subprogram declarations
+@end itemize
+
+@menu
+* Running the C Header Generator::
+
+@end menu
+
+@node Running the C Header Generator,,,Generating C Headers for Ada Specifications
+@anchor{gnat_ugn/the_gnat_compilation_model running-the-c-header-generator}@anchor{d2}
+@subsubsection Running the C Header Generator
+
+
+The C header generator is part of the GNAT compiler and can be invoked via
+the @emph{-gnatceg} combination of switches, which will generate a @code{.h}
+file corresponding to the given input file (Ada spec or body). Note that
+only spec files are processed in any case, so giving a spec or a body file
+as input is equivalent. For example:
+
+@example
+$ gcc -c -gnatceg pack1.ads
+@end example
+
+will generate a self-contained file called @code{pack1.h} including
+common definitions from the Ada Standard package, followed by the
+definitions included in @code{pack1.ads}, as well as all the other units
+withed by this file.
+
+For instance, given the following Ada files:
+
+@example
+package Pack2 is
+ type Int is range 1 .. 10;
+end Pack2;
+@end example
+
+@example
+with Pack2;
+
+package Pack1 is
+ type Rec is record
+ Field1, Field2 : Pack2.Int;
+ end record;
+
+ Global : Rec := (1, 2);
+
+ procedure Proc1 (R : Rec);
+ procedure Proc2 (R : in out Rec);
+end Pack1;
+@end example
+
+The above @cite{gcc} command will generate the following @code{pack1.h} file:
+
+@example
+/* Standard definitions skipped */
+#ifndef PACK2_ADS
+#define PACK2_ADS
+typedef short_short_integer pack2__TintB;
+typedef pack2__TintB pack2__int;
+#endif /* PACK2_ADS */
+
+#ifndef PACK1_ADS
+#define PACK1_ADS
+typedef struct _pack1__rec @{
+ pack2__int field1;
+ pack2__int field2;
+@} pack1__rec;
+extern pack1__rec pack1__global;
+extern void pack1__proc1(const pack1__rec r);
+extern void pack1__proc2(pack1__rec *r);
+#endif /* PACK1_ADS */
+@end example
+
+You can then @cite{include} @code{pack1.h} from a C source file and use the types,
+call subprograms, reference objects, and constants.
+
@node GNAT and Other Compilation Models,Using GNAT Files with External Tools,Mixed Language Programming,The GNAT Compilation Model
-@anchor{gnat_ugn/the_gnat_compilation_model id73}@anchor{d0}@anchor{gnat_ugn/the_gnat_compilation_model gnat-and-other-compilation-models}@anchor{47}
+@anchor{gnat_ugn/the_gnat_compilation_model id74}@anchor{d3}@anchor{gnat_ugn/the_gnat_compilation_model gnat-and-other-compilation-models}@anchor{47}
@section GNAT and Other Compilation Models
@end menu
@node Comparison between GNAT and C/C++ Compilation Models,Comparison between GNAT and Conventional Ada Library Models,,GNAT and Other Compilation Models
-@anchor{gnat_ugn/the_gnat_compilation_model comparison-between-gnat-and-c-c-compilation-models}@anchor{d1}@anchor{gnat_ugn/the_gnat_compilation_model id74}@anchor{d2}
+@anchor{gnat_ugn/the_gnat_compilation_model comparison-between-gnat-and-c-c-compilation-models}@anchor{d4}@anchor{gnat_ugn/the_gnat_compilation_model id75}@anchor{d5}
@subsection Comparison between GNAT and C/C++ Compilation Models
malfunctioned at run time.
@node Comparison between GNAT and Conventional Ada Library Models,,Comparison between GNAT and C/C++ Compilation Models,GNAT and Other Compilation Models
-@anchor{gnat_ugn/the_gnat_compilation_model comparison-between-gnat-and-conventional-ada-library-models}@anchor{d3}@anchor{gnat_ugn/the_gnat_compilation_model id75}@anchor{d4}
+@anchor{gnat_ugn/the_gnat_compilation_model comparison-between-gnat-and-conventional-ada-library-models}@anchor{d6}@anchor{gnat_ugn/the_gnat_compilation_model id76}@anchor{d7}
@subsection Comparison between GNAT and Conventional Ada Library Models
compiled.
@node Using GNAT Files with External Tools,,GNAT and Other Compilation Models,The GNAT Compilation Model
-@anchor{gnat_ugn/the_gnat_compilation_model using-gnat-files-with-external-tools}@anchor{1c}@anchor{gnat_ugn/the_gnat_compilation_model id76}@anchor{d5}
+@anchor{gnat_ugn/the_gnat_compilation_model using-gnat-files-with-external-tools}@anchor{1c}@anchor{gnat_ugn/the_gnat_compilation_model id77}@anchor{d8}
@section Using GNAT Files with External Tools
@end menu
@node Using Other Utility Programs with GNAT,The External Symbol Naming Scheme of GNAT,,Using GNAT Files with External Tools
-@anchor{gnat_ugn/the_gnat_compilation_model using-other-utility-programs-with-gnat}@anchor{d6}@anchor{gnat_ugn/the_gnat_compilation_model id77}@anchor{d7}
+@anchor{gnat_ugn/the_gnat_compilation_model using-other-utility-programs-with-gnat}@anchor{d9}@anchor{gnat_ugn/the_gnat_compilation_model id78}@anchor{da}
@subsection Using Other Utility Programs with GNAT
as Purify.
@node The External Symbol Naming Scheme of GNAT,,Using Other Utility Programs with GNAT,Using GNAT Files with External Tools
-@anchor{gnat_ugn/the_gnat_compilation_model the-external-symbol-naming-scheme-of-gnat}@anchor{d8}@anchor{gnat_ugn/the_gnat_compilation_model id78}@anchor{d9}
+@anchor{gnat_ugn/the_gnat_compilation_model the-external-symbol-naming-scheme-of-gnat}@anchor{db}@anchor{gnat_ugn/the_gnat_compilation_model id79}@anchor{dc}
@subsection The External Symbol Naming Scheme of GNAT
@c -- Example: A |withing| unit has a |with| clause, it |withs| a |withed| unit
@node Building Executable Programs with GNAT,GNAT Project Manager,The GNAT Compilation Model,Top
-@anchor{gnat_ugn/building_executable_programs_with_gnat building-executable-programs-with-gnat}@anchor{a}@anchor{gnat_ugn/building_executable_programs_with_gnat doc}@anchor{da}@anchor{gnat_ugn/building_executable_programs_with_gnat id1}@anchor{db}
+@anchor{gnat_ugn/building_executable_programs_with_gnat building-executable-programs-with-gnat}@anchor{a}@anchor{gnat_ugn/building_executable_programs_with_gnat doc}@anchor{dd}@anchor{gnat_ugn/building_executable_programs_with_gnat id1}@anchor{de}
@chapter Building Executable Programs with GNAT
@end menu
@node Building with gnatmake,Compiling with gcc,,Building Executable Programs with GNAT
-@anchor{gnat_ugn/building_executable_programs_with_gnat the-gnat-make-program-gnatmake}@anchor{1d}@anchor{gnat_ugn/building_executable_programs_with_gnat building-with-gnatmake}@anchor{dc}
+@anchor{gnat_ugn/building_executable_programs_with_gnat the-gnat-make-program-gnatmake}@anchor{1d}@anchor{gnat_ugn/building_executable_programs_with_gnat building-with-gnatmake}@anchor{df}
@section Building with @emph{gnatmake}
@end menu
@node Running gnatmake,Switches for gnatmake,,Building with gnatmake
-@anchor{gnat_ugn/building_executable_programs_with_gnat running-gnatmake}@anchor{dd}@anchor{gnat_ugn/building_executable_programs_with_gnat id2}@anchor{de}
+@anchor{gnat_ugn/building_executable_programs_with_gnat running-gnatmake}@anchor{e0}@anchor{gnat_ugn/building_executable_programs_with_gnat id2}@anchor{e1}
@subsection Running @emph{gnatmake}
@emph{-M} switch is sent to @code{stdout}.
@node Switches for gnatmake,Mode Switches for gnatmake,Running gnatmake,Building with gnatmake
-@anchor{gnat_ugn/building_executable_programs_with_gnat switches-for-gnatmake}@anchor{df}@anchor{gnat_ugn/building_executable_programs_with_gnat id3}@anchor{e0}
+@anchor{gnat_ugn/building_executable_programs_with_gnat switches-for-gnatmake}@anchor{e2}@anchor{gnat_ugn/building_executable_programs_with_gnat id3}@anchor{e3}
@subsection Switches for @emph{gnatmake}
@item @code{-P@emph{project}}
Use project file @cite{project}. Only one such switch can be used.
-@ref{e1,,gnatmake and Project Files}.
+@ref{e4,,gnatmake and Project Files}.
@end table
@geindex -q (gnatmake)
Unique. Recompile at most the main files. It implies -c. Combined with
-f, it is equivalent to calling the compiler directly. Note that using
-u with a project file and no main has a special meaning
-(@ref{e2,,Project Files and Main Subprograms}).
+(@ref{e5,,Project Files and Main Subprograms}).
@end table
@geindex -U (gnatmake)
@item @code{-vP@emph{x}}
Indicate the verbosity of the parsing of GNAT project files.
-See @ref{e3,,Switches Related to Project Files}.
+See @ref{e6,,Switches Related to Project Files}.
@end table
@geindex -x (gnatmake)
Indicate that external variable @cite{name} has the value @cite{value}.
The Project Manager will use this value for occurrences of
@cite{external(name)} when parsing the project file.
-@ref{e3,,Switches Related to Project Files}.
+@ref{e6,,Switches Related to Project Files}.
@end table
@geindex -z (gnatmake)
@end table
@node Mode Switches for gnatmake,Notes on the Command Line,Switches for gnatmake,Building with gnatmake
-@anchor{gnat_ugn/building_executable_programs_with_gnat id4}@anchor{e4}@anchor{gnat_ugn/building_executable_programs_with_gnat mode-switches-for-gnatmake}@anchor{e5}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id4}@anchor{e7}@anchor{gnat_ugn/building_executable_programs_with_gnat mode-switches-for-gnatmake}@anchor{e8}
@subsection Mode Switches for @emph{gnatmake}
@end table
@node Notes on the Command Line,How gnatmake Works,Mode Switches for gnatmake,Building with gnatmake
-@anchor{gnat_ugn/building_executable_programs_with_gnat id5}@anchor{e6}@anchor{gnat_ugn/building_executable_programs_with_gnat notes-on-the-command-line}@anchor{e7}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id5}@anchor{e9}@anchor{gnat_ugn/building_executable_programs_with_gnat notes-on-the-command-line}@anchor{ea}
@subsection Notes on the Command Line
@end itemize
@node How gnatmake Works,Examples of gnatmake Usage,Notes on the Command Line,Building with gnatmake
-@anchor{gnat_ugn/building_executable_programs_with_gnat id6}@anchor{e8}@anchor{gnat_ugn/building_executable_programs_with_gnat how-gnatmake-works}@anchor{e9}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id6}@anchor{eb}@anchor{gnat_ugn/building_executable_programs_with_gnat how-gnatmake-works}@anchor{ec}
@subsection How @emph{gnatmake} Works
-f.
@node Examples of gnatmake Usage,,How gnatmake Works,Building with gnatmake
-@anchor{gnat_ugn/building_executable_programs_with_gnat examples-of-gnatmake-usage}@anchor{ea}@anchor{gnat_ugn/building_executable_programs_with_gnat id7}@anchor{eb}
+@anchor{gnat_ugn/building_executable_programs_with_gnat examples-of-gnatmake-usage}@anchor{ed}@anchor{gnat_ugn/building_executable_programs_with_gnat id7}@anchor{ee}
@subsection Examples of @emph{gnatmake} Usage
@end table
@node Compiling with gcc,Compiler Switches,Building with gnatmake,Building Executable Programs with GNAT
-@anchor{gnat_ugn/building_executable_programs_with_gnat compiling-with-gcc}@anchor{1e}@anchor{gnat_ugn/building_executable_programs_with_gnat id8}@anchor{ec}
+@anchor{gnat_ugn/building_executable_programs_with_gnat compiling-with-gcc}@anchor{1e}@anchor{gnat_ugn/building_executable_programs_with_gnat id8}@anchor{ef}
@section Compiling with @emph{gcc}
@end menu
@node Compiling Programs,Search Paths and the Run-Time Library RTL,,Compiling with gcc
-@anchor{gnat_ugn/building_executable_programs_with_gnat compiling-programs}@anchor{ed}@anchor{gnat_ugn/building_executable_programs_with_gnat id9}@anchor{ee}
+@anchor{gnat_ugn/building_executable_programs_with_gnat compiling-programs}@anchor{f0}@anchor{gnat_ugn/building_executable_programs_with_gnat id9}@anchor{f1}
@subsection Compiling Programs
The compiler generates two object files @code{x.o} and @code{y.o}
and the two ALI files @code{x.ali} and @code{y.ali}.
-Any switches apply to all the files listed, see @ref{ef,,Compiler Switches} for a
+Any switches apply to all the files listed, see @ref{f2,,Compiler Switches} for a
list of available @emph{gcc} switches.
@node Search Paths and the Run-Time Library RTL,Order of Compilation Issues,Compiling Programs,Compiling with gcc
-@anchor{gnat_ugn/building_executable_programs_with_gnat id10}@anchor{f0}@anchor{gnat_ugn/building_executable_programs_with_gnat search-paths-and-the-run-time-library-rtl}@anchor{8e}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id10}@anchor{f3}@anchor{gnat_ugn/building_executable_programs_with_gnat search-paths-and-the-run-time-library-rtl}@anchor{8e}
@subsection Search Paths and the Run-Time Library (RTL)
development environments much more flexible.
@node Order of Compilation Issues,Examples,Search Paths and the Run-Time Library RTL,Compiling with gcc
-@anchor{gnat_ugn/building_executable_programs_with_gnat id11}@anchor{f1}@anchor{gnat_ugn/building_executable_programs_with_gnat order-of-compilation-issues}@anchor{f2}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id11}@anchor{f4}@anchor{gnat_ugn/building_executable_programs_with_gnat order-of-compilation-issues}@anchor{f5}
@subsection Order of Compilation Issues
@end itemize
@node Examples,,Order of Compilation Issues,Compiling with gcc
-@anchor{gnat_ugn/building_executable_programs_with_gnat id12}@anchor{f3}@anchor{gnat_ugn/building_executable_programs_with_gnat examples}@anchor{f4}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id12}@anchor{f6}@anchor{gnat_ugn/building_executable_programs_with_gnat examples}@anchor{f7}
@subsection Examples
mode.
@node Compiler Switches,Binding with gnatbind,Compiling with gcc,Building Executable Programs with GNAT
-@anchor{gnat_ugn/building_executable_programs_with_gnat compiler-switches}@anchor{f5}@anchor{gnat_ugn/building_executable_programs_with_gnat switches-for-gcc}@anchor{ef}
+@anchor{gnat_ugn/building_executable_programs_with_gnat compiler-switches}@anchor{f8}@anchor{gnat_ugn/building_executable_programs_with_gnat switches-for-gcc}@anchor{f2}
@section Compiler Switches
@end menu
@node Alphabetical List of All Switches,Output and Error Message Control,,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat id13}@anchor{f6}@anchor{gnat_ugn/building_executable_programs_with_gnat alphabetical-list-of-all-switches}@anchor{f7}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id13}@anchor{f9}@anchor{gnat_ugn/building_executable_programs_with_gnat alphabetical-list-of-all-switches}@anchor{fa}
@subsection Alphabetical List of All Switches
Causes the compiler to avoid assumptions regarding non-aliasing
of objects of different types. See
-@ref{f8,,Optimization and Strict Aliasing} for details.
+@ref{fb,,Optimization and Strict Aliasing} for details.
+@end table
+
+@geindex -fno-strict-overflow (gcc)
+
+
+@table @asis
+
+@item @code{-fno-strict-overflow}
+
+Causes the compiler to avoid assumptions regarding the rules of signed
+integer overflow. These rules specify that signed integer overflow will
+result in a Constraint_Error exception at run time and are enforced in
+default mode by the compiler, so this switch should not be necessary in
+normal operating mode. It might be useful in conjunction with @emph{-gnato0}
+for very peculiar cases of low-level programming.
@end table
@geindex -fstack-check (gcc)
@item @code{-fstack-check}
Activates stack checking.
-See @ref{f9,,Stack Overflow Checking} for details.
+See @ref{fc,,Stack Overflow Checking} for details.
@end table
@geindex -fstack-usage (gcc)
@item @code{-fstack-usage}
Makes the compiler output stack usage information for the program, on a
-per-subprogram basis. See @ref{fa,,Static Stack Usage Analysis} for details.
+per-subprogram basis. See @ref{fd,,Static Stack Usage Analysis} for details.
@end table
@geindex -g (gcc)
@item @code{-gnatB}
Assume no invalid (bad) values except for 'Valid attribute use
-(@ref{fb,,Validity Checking}).
+(@ref{fe,,Validity Checking}).
@end table
@geindex -gnatc (gcc)
@cite{Check_Float_Overflow} in GNAT RM.
@end table
+@geindex -gnateg (gcc)
+
+@code{-gnateg}
+@code{-gnatceg}
+
+@quotation
+
+The @cite{-gnatc} switch must always be specified before this switch, e.g.
+@cite{-gnatceg}. Generate a C header from the Ada input file. See
+@ref{d0,,Generating C Headers for Ada Specifications} for more
+information.
+@end quotation
+
@geindex -gnateG (gcc)
Specify a mapping file
(the equal sign is optional)
-(@ref{fc,,Units to Sources Mapping Files}).
+(@ref{ff,,Units to Sources Mapping Files}).
@end table
@geindex -gnatep (gcc)
@item @code{-gnateV}
Check that all actual parameters of a subprogram call are valid according to
-the rules of validity checking (@ref{fb,,Validity Checking}).
+the rules of validity checking (@ref{fe,,Validity Checking}).
@end table
@geindex -gnateY (gcc)
Note that division by zero is a separate check that is not
controlled by this switch (divide-by-zero checking is on by default).
-See also @ref{fd,,Specifying the Desired Mode}.
+See also @ref{100,,Specifying the Desired Mode}.
@end table
@geindex -gnatp (gcc)
@item @code{-gnatp}
-Suppress all checks. See @ref{fe,,Run-Time Checks} for details. This switch
+Suppress all checks. See @ref{101,,Run-Time Checks} for details. This switch
has no effect if cancelled by a subsequent @emph{-gnat-p} switch.
@end table
@item @code{-gnatV}
-Control level of validity checking (@ref{fb,,Validity Checking}).
+Control level of validity checking (@ref{fe,,Validity Checking}).
@end table
@geindex -gnatw (gcc)
Warning mode where
@cite{xxx} is a string of option letters that denotes
the exact warnings that
-are enabled or disabled (@ref{ff,,Warning Message Control}).
+are enabled or disabled (@ref{102,,Warning Message Control}).
@end table
@geindex -gnatW (gcc)
@item @code{-gnaty}
-Enable built-in style checks (@ref{100,,Style Checking}).
+Enable built-in style checks (@ref{103,,Style Checking}).
@end table
@geindex -gnatz (gcc)
@end multitable
-See also @ref{101,,Optimization Levels}.
+See also @ref{104,,Optimization Levels}.
@end table
@geindex -pass-exit-codes (gcc)
@item @code{--RTS=@emph{rts-path}}
Specifies the default location of the runtime library. Same meaning as the
-equivalent @emph{gnatmake} flag (@ref{df,,Switches for gnatmake}).
+equivalent @emph{gnatmake} flag (@ref{e2,,Switches for gnatmake}).
@end table
@geindex -S (gcc)
@item
Once a 'V' appears in the string (that is a use of the @emph{-gnatV}
switch), then all further characters in the switch are interpreted
-as validity checking options (@ref{fb,,Validity Checking}).
+as validity checking options (@ref{fe,,Validity Checking}).
@item
Option 'em', 'ec', 'ep', 'l=' and 'R' must be the last options in
@end itemize
@node Output and Error Message Control,Warning Message Control,Alphabetical List of All Switches,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat id14}@anchor{102}@anchor{gnat_ugn/building_executable_programs_with_gnat output-and-error-message-control}@anchor{103}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id14}@anchor{105}@anchor{gnat_ugn/building_executable_programs_with_gnat output-and-error-message-control}@anchor{106}
@subsection Output and Error Message Control
@end table
@node Warning Message Control,Debugging and Assertion Control,Output and Error Message Control,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat warning-message-control}@anchor{ff}@anchor{gnat_ugn/building_executable_programs_with_gnat id15}@anchor{104}
+@anchor{gnat_ugn/building_executable_programs_with_gnat warning-message-control}@anchor{102}@anchor{gnat_ugn/building_executable_programs_with_gnat id15}@anchor{107}
@subsection Warning Message Control
@item @code{-Wstack-usage=@emph{len}}
Warn if the stack usage of a subprogram might be larger than @cite{len} bytes.
-See @ref{fa,,Static Stack Usage Analysis} for details.
+See @ref{fd,,Static Stack Usage Analysis} for details.
@end table
@geindex -Wall (gcc)
@end quotation
@node Debugging and Assertion Control,Validity Checking,Warning Message Control,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat debugging-and-assertion-control}@anchor{105}@anchor{gnat_ugn/building_executable_programs_with_gnat id16}@anchor{106}
+@anchor{gnat_ugn/building_executable_programs_with_gnat debugging-and-assertion-control}@anchor{108}@anchor{gnat_ugn/building_executable_programs_with_gnat id16}@anchor{109}
@subsection Debugging and Assertion Control
@end table
@node Validity Checking,Style Checking,Debugging and Assertion Control,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat validity-checking}@anchor{fb}@anchor{gnat_ugn/building_executable_programs_with_gnat id17}@anchor{107}
+@anchor{gnat_ugn/building_executable_programs_with_gnat validity-checking}@anchor{fe}@anchor{gnat_ugn/building_executable_programs_with_gnat id17}@anchor{10a}
@subsection Validity Checking
temporary disabling of validity checks.
@node Style Checking,Run-Time Checks,Validity Checking,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat id18}@anchor{108}@anchor{gnat_ugn/building_executable_programs_with_gnat style-checking}@anchor{100}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id18}@anchor{10b}@anchor{gnat_ugn/building_executable_programs_with_gnat style-checking}@anchor{103}
@subsection Style Checking
The switch @code{-gnatyN} clears any previously set style checks.
@node Run-Time Checks,Using gcc for Syntax Checking,Style Checking,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat run-time-checks}@anchor{fe}@anchor{gnat_ugn/building_executable_programs_with_gnat id19}@anchor{109}
+@anchor{gnat_ugn/building_executable_programs_with_gnat run-time-checks}@anchor{101}@anchor{gnat_ugn/building_executable_programs_with_gnat id19}@anchor{10c}
@subsection Run-Time Checks
@item @code{-fstack-check}
Activates stack overflow checking. For full details of the effect and use of
-this switch see @ref{f9,,Stack Overflow Checking}.
+this switch see @ref{fc,,Stack Overflow Checking}.
@end table
@geindex Unsuppress
the program source.
@node Using gcc for Syntax Checking,Using gcc for Semantic Checking,Run-Time Checks,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat id20}@anchor{10a}@anchor{gnat_ugn/building_executable_programs_with_gnat using-gcc-for-syntax-checking}@anchor{10b}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id20}@anchor{10d}@anchor{gnat_ugn/building_executable_programs_with_gnat using-gcc-for-syntax-checking}@anchor{10e}
@subsection Using @emph{gcc} for Syntax Checking
@end table
@node Using gcc for Semantic Checking,Compiling Different Versions of Ada,Using gcc for Syntax Checking,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat id21}@anchor{10c}@anchor{gnat_ugn/building_executable_programs_with_gnat using-gcc-for-semantic-checking}@anchor{10d}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id21}@anchor{10f}@anchor{gnat_ugn/building_executable_programs_with_gnat using-gcc-for-semantic-checking}@anchor{110}
@subsection Using @emph{gcc} for Semantic Checking
@end table
@node Compiling Different Versions of Ada,Character Set Control,Using gcc for Semantic Checking,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat compiling-different-versions-of-ada}@anchor{6}@anchor{gnat_ugn/building_executable_programs_with_gnat id22}@anchor{10e}
+@anchor{gnat_ugn/building_executable_programs_with_gnat compiling-different-versions-of-ada}@anchor{6}@anchor{gnat_ugn/building_executable_programs_with_gnat id22}@anchor{111}
@subsection Compiling Different Versions of Ada
@end table
@node Character Set Control,File Naming Control,Compiling Different Versions of Ada,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat id23}@anchor{10f}@anchor{gnat_ugn/building_executable_programs_with_gnat character-set-control}@anchor{4a}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id23}@anchor{112}@anchor{gnat_ugn/building_executable_programs_with_gnat character-set-control}@anchor{4a}
@subsection Character Set Control
This is a common mode for many programs with foreign language comments.
@node File Naming Control,Subprogram Inlining Control,Character Set Control,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat file-naming-control}@anchor{110}@anchor{gnat_ugn/building_executable_programs_with_gnat id24}@anchor{111}
+@anchor{gnat_ugn/building_executable_programs_with_gnat file-naming-control}@anchor{113}@anchor{gnat_ugn/building_executable_programs_with_gnat id24}@anchor{114}
@subsection File Naming Control
@end table
@node Subprogram Inlining Control,Auxiliary Output Control,File Naming Control,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat subprogram-inlining-control}@anchor{112}@anchor{gnat_ugn/building_executable_programs_with_gnat id25}@anchor{113}
+@anchor{gnat_ugn/building_executable_programs_with_gnat subprogram-inlining-control}@anchor{115}@anchor{gnat_ugn/building_executable_programs_with_gnat id25}@anchor{116}
@subsection Subprogram Inlining Control
creating an extra source dependency for the resulting object file, and
where possible, the call will be inlined.
For further details on when inlining is possible
-see @ref{114,,Inlining of Subprograms}.
+see @ref{117,,Inlining of Subprograms}.
@end table
@geindex -gnatN (gcc)
@end table
@node Auxiliary Output Control,Debugging Control,Subprogram Inlining Control,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat auxiliary-output-control}@anchor{115}@anchor{gnat_ugn/building_executable_programs_with_gnat id26}@anchor{116}
+@anchor{gnat_ugn/building_executable_programs_with_gnat auxiliary-output-control}@anchor{118}@anchor{gnat_ugn/building_executable_programs_with_gnat id26}@anchor{119}
@subsection Auxiliary Output Control
@end table
@node Debugging Control,Exception Handling Control,Auxiliary Output Control,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat debugging-control}@anchor{117}@anchor{gnat_ugn/building_executable_programs_with_gnat id27}@anchor{118}
+@anchor{gnat_ugn/building_executable_programs_with_gnat debugging-control}@anchor{11a}@anchor{gnat_ugn/building_executable_programs_with_gnat id27}@anchor{11b}
@subsection Debugging Control
@end table
@node Exception Handling Control,Units to Sources Mapping Files,Debugging Control,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat id28}@anchor{119}@anchor{gnat_ugn/building_executable_programs_with_gnat exception-handling-control}@anchor{11a}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id28}@anchor{11c}@anchor{gnat_ugn/building_executable_programs_with_gnat exception-handling-control}@anchor{11d}
@subsection Exception Handling Control
The same option @emph{--RTS} must be used both for @emph{gcc}
and @emph{gnatbind}. Passing this option to @emph{gnatmake}
-(@ref{df,,Switches for gnatmake}) will ensure the required consistency
+(@ref{e2,,Switches for gnatmake}) will ensure the required consistency
through the compilation and binding steps.
@node Units to Sources Mapping Files,Code Generation Control,Exception Handling Control,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat id29}@anchor{11b}@anchor{gnat_ugn/building_executable_programs_with_gnat units-to-sources-mapping-files}@anchor{fc}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id29}@anchor{11e}@anchor{gnat_ugn/building_executable_programs_with_gnat units-to-sources-mapping-files}@anchor{ff}
@subsection Units to Sources Mapping Files
@end table
@node Code Generation Control,,Units to Sources Mapping Files,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat code-generation-control}@anchor{11c}@anchor{gnat_ugn/building_executable_programs_with_gnat id30}@anchor{11d}
+@anchor{gnat_ugn/building_executable_programs_with_gnat code-generation-control}@anchor{11f}@anchor{gnat_ugn/building_executable_programs_with_gnat id30}@anchor{120}
@subsection Code Generation Control
unless you actually see a performance improvement.
@node Binding with gnatbind,Linking with gnatlink,Compiler Switches,Building Executable Programs with GNAT
-@anchor{gnat_ugn/building_executable_programs_with_gnat binding-with-gnatbind}@anchor{1f}@anchor{gnat_ugn/building_executable_programs_with_gnat id31}@anchor{11e}
+@anchor{gnat_ugn/building_executable_programs_with_gnat binding-with-gnatbind}@anchor{1f}@anchor{gnat_ugn/building_executable_programs_with_gnat id31}@anchor{121}
@section Binding with @cite{gnatbind}
to bind compiled GNAT objects.
Note: to invoke @cite{gnatbind} with a project file, use the @cite{gnat}
-driver (see @ref{11f,,The GNAT Driver and Project Files}).
+driver (see @ref{122,,The GNAT Driver and Project Files}).
The @cite{gnatbind} program performs four separate functions:
@end menu
@node Running gnatbind,Switches for gnatbind,,Binding with gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat running-gnatbind}@anchor{120}@anchor{gnat_ugn/building_executable_programs_with_gnat id32}@anchor{121}
+@anchor{gnat_ugn/building_executable_programs_with_gnat running-gnatbind}@anchor{123}@anchor{gnat_ugn/building_executable_programs_with_gnat id32}@anchor{124}
@subsection Running @cite{gnatbind}
@emph{gnatbind} and @emph{gnatlink}.
@node Switches for gnatbind,Command-Line Access,Running gnatbind,Binding with gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat id33}@anchor{122}@anchor{gnat_ugn/building_executable_programs_with_gnat switches-for-gnatbind}@anchor{123}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id33}@anchor{125}@anchor{gnat_ugn/building_executable_programs_with_gnat switches-for-gnatbind}@anchor{126}
@subsection Switches for @emph{gnatbind}
@item @code{-H32}
Use 32-bit allocations for @cite{__gnat_malloc} (and thus for access types).
-For further details see @ref{124,,Dynamic Allocation Control}.
+For further details see @ref{127,,Dynamic Allocation Control}.
@geindex -H64 (gnatbind)
@item @code{-H64}
Use 64-bit allocations for @cite{__gnat_malloc} (and thus for access types).
-For further details see @ref{124,,Dynamic Allocation Control}.
+For further details see @ref{127,,Dynamic Allocation Control}.
@geindex -I (gnatbind)
@item @code{--RTS=@emph{rts-path}}
Specifies the default location of the runtime library. Same meaning as the
-equivalent @emph{gnatmake} flag (@ref{df,,Switches for gnatmake}).
+equivalent @emph{gnatmake} flag (@ref{e2,,Switches for gnatmake}).
@geindex -o (gnatbind)
at program termination. A result is generated when a task
terminates. Results that can't be stored are displayed on the fly, at
task termination. This option is currently not supported on Itanium
-platforms. (See @ref{125,,Dynamic Stack Usage Analysis} for details.)
+platforms. (See @ref{128,,Dynamic Stack Usage Analysis} for details.)
@geindex -v (gnatbind)
@end menu
@node Consistency-Checking Modes,Binder Error Message Control,,Switches for gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat consistency-checking-modes}@anchor{126}@anchor{gnat_ugn/building_executable_programs_with_gnat id34}@anchor{127}
+@anchor{gnat_ugn/building_executable_programs_with_gnat consistency-checking-modes}@anchor{129}@anchor{gnat_ugn/building_executable_programs_with_gnat id34}@anchor{12a}
@subsubsection Consistency-Checking Modes
@end table
@node Binder Error Message Control,Elaboration Control,Consistency-Checking Modes,Switches for gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat id35}@anchor{128}@anchor{gnat_ugn/building_executable_programs_with_gnat binder-error-message-control}@anchor{129}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id35}@anchor{12b}@anchor{gnat_ugn/building_executable_programs_with_gnat binder-error-message-control}@anchor{12c}
@subsubsection Binder Error Message Control
@end table
@node Elaboration Control,Output Control,Binder Error Message Control,Switches for gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat id36}@anchor{12a}@anchor{gnat_ugn/building_executable_programs_with_gnat elaboration-control}@anchor{12b}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id36}@anchor{12d}@anchor{gnat_ugn/building_executable_programs_with_gnat elaboration-control}@anchor{12e}
@subsubsection Elaboration Control
@end table
@node Output Control,Dynamic Allocation Control,Elaboration Control,Switches for gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat output-control}@anchor{12c}@anchor{gnat_ugn/building_executable_programs_with_gnat id37}@anchor{12d}
+@anchor{gnat_ugn/building_executable_programs_with_gnat output-control}@anchor{12f}@anchor{gnat_ugn/building_executable_programs_with_gnat id37}@anchor{130}
@subsubsection Output Control
@end table
@node Dynamic Allocation Control,Binding with Non-Ada Main Programs,Output Control,Switches for gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat dynamic-allocation-control}@anchor{124}@anchor{gnat_ugn/building_executable_programs_with_gnat id38}@anchor{12e}
+@anchor{gnat_ugn/building_executable_programs_with_gnat dynamic-allocation-control}@anchor{127}@anchor{gnat_ugn/building_executable_programs_with_gnat id38}@anchor{131}
@subsubsection Dynamic Allocation Control
These switches are only effective on VMS platforms.
@node Binding with Non-Ada Main Programs,Binding Programs with No Main Subprogram,Dynamic Allocation Control,Switches for gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat binding-with-non-ada-main-programs}@anchor{ba}@anchor{gnat_ugn/building_executable_programs_with_gnat id39}@anchor{12f}
+@anchor{gnat_ugn/building_executable_programs_with_gnat binding-with-non-ada-main-programs}@anchor{ba}@anchor{gnat_ugn/building_executable_programs_with_gnat id39}@anchor{132}
@subsubsection Binding with Non-Ada Main Programs
where floating point computation could be broken after this call.
@node Binding Programs with No Main Subprogram,,Binding with Non-Ada Main Programs,Switches for gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat binding-programs-with-no-main-subprogram}@anchor{130}@anchor{gnat_ugn/building_executable_programs_with_gnat id40}@anchor{131}
+@anchor{gnat_ugn/building_executable_programs_with_gnat binding-programs-with-no-main-subprogram}@anchor{133}@anchor{gnat_ugn/building_executable_programs_with_gnat id40}@anchor{134}
@subsubsection Binding Programs with No Main Subprogram
@end table
@node Command-Line Access,Search Paths for gnatbind,Switches for gnatbind,Binding with gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat id41}@anchor{132}@anchor{gnat_ugn/building_executable_programs_with_gnat command-line-access}@anchor{133}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id41}@anchor{135}@anchor{gnat_ugn/building_executable_programs_with_gnat command-line-access}@anchor{136}
@subsection Command-Line Access
it.
@node Search Paths for gnatbind,Examples of gnatbind Usage,Command-Line Access,Binding with gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat search-paths-for-gnatbind}@anchor{91}@anchor{gnat_ugn/building_executable_programs_with_gnat id42}@anchor{134}
+@anchor{gnat_ugn/building_executable_programs_with_gnat search-paths-for-gnatbind}@anchor{91}@anchor{gnat_ugn/building_executable_programs_with_gnat id42}@anchor{137}
@subsection Search Paths for @cite{gnatbind}
development environments much more flexible.
@node Examples of gnatbind Usage,,Search Paths for gnatbind,Binding with gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat examples-of-gnatbind-usage}@anchor{135}@anchor{gnat_ugn/building_executable_programs_with_gnat id43}@anchor{136}
+@anchor{gnat_ugn/building_executable_programs_with_gnat examples-of-gnatbind-usage}@anchor{138}@anchor{gnat_ugn/building_executable_programs_with_gnat id43}@anchor{139}
@subsection Examples of @cite{gnatbind} Usage
@end quotation
@node Linking with gnatlink,Using the GNU make Utility,Binding with gnatbind,Building Executable Programs with GNAT
-@anchor{gnat_ugn/building_executable_programs_with_gnat id44}@anchor{137}@anchor{gnat_ugn/building_executable_programs_with_gnat linking-with-gnatlink}@anchor{20}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id44}@anchor{13a}@anchor{gnat_ugn/building_executable_programs_with_gnat linking-with-gnatlink}@anchor{20}
@section Linking with @emph{gnatlink}
generated by the @emph{gnatbind} to determine this list.
Note: to invoke @cite{gnatlink} with a project file, use the @cite{gnat}
-driver (see @ref{11f,,The GNAT Driver and Project Files}).
+driver (see @ref{122,,The GNAT Driver and Project Files}).
@menu
* Running gnatlink::
@end menu
@node Running gnatlink,Switches for gnatlink,,Linking with gnatlink
-@anchor{gnat_ugn/building_executable_programs_with_gnat id45}@anchor{138}@anchor{gnat_ugn/building_executable_programs_with_gnat running-gnatlink}@anchor{139}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id45}@anchor{13b}@anchor{gnat_ugn/building_executable_programs_with_gnat running-gnatlink}@anchor{13c}
@subsection Running @emph{gnatlink}
Using @cite{linker options} it is possible to set the program stack and
heap size.
-See @ref{13a,,Setting Stack Size from gnatlink} and
-@ref{13b,,Setting Heap Size from gnatlink}.
+See @ref{13d,,Setting Stack Size from gnatlink} and
+@ref{13e,,Setting Heap Size from gnatlink}.
@emph{gnatlink} determines the list of objects required by the Ada
program and prepends them to the list of objects passed to the linker.
presented to the linker.
@node Switches for gnatlink,,Running gnatlink,Linking with gnatlink
-@anchor{gnat_ugn/building_executable_programs_with_gnat id46}@anchor{13c}@anchor{gnat_ugn/building_executable_programs_with_gnat switches-for-gnatlink}@anchor{13d}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id46}@anchor{13f}@anchor{gnat_ugn/building_executable_programs_with_gnat switches-for-gnatlink}@anchor{140}
@subsection Switches for @emph{gnatlink}
@end table
@node Using the GNU make Utility,,Linking with gnatlink,Building Executable Programs with GNAT
-@anchor{gnat_ugn/building_executable_programs_with_gnat id47}@anchor{13e}@anchor{gnat_ugn/building_executable_programs_with_gnat using-the-gnu-make-utility}@anchor{21}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id47}@anchor{141}@anchor{gnat_ugn/building_executable_programs_with_gnat using-the-gnu-make-utility}@anchor{21}
@section Using the GNU @cite{make} Utility
@end menu
@node Using gnatmake in a Makefile,Automatically Creating a List of Directories,,Using the GNU make Utility
-@anchor{gnat_ugn/building_executable_programs_with_gnat using-gnatmake-in-a-makefile}@anchor{13f}@anchor{gnat_ugn/building_executable_programs_with_gnat id48}@anchor{140}
+@anchor{gnat_ugn/building_executable_programs_with_gnat using-gnatmake-in-a-makefile}@anchor{142}@anchor{gnat_ugn/building_executable_programs_with_gnat id48}@anchor{143}
@subsection Using gnatmake in a Makefile
Note that you should also read the example on how to automatically
create the list of directories
-(@ref{141,,Automatically Creating a List of Directories})
+(@ref{144,,Automatically Creating a List of Directories})
which might help you in case your project has a lot of subdirectories.
@example
@end example
@node Automatically Creating a List of Directories,Generating the Command Line Switches,Using gnatmake in a Makefile,Using the GNU make Utility
-@anchor{gnat_ugn/building_executable_programs_with_gnat automatically-creating-a-list-of-directories}@anchor{141}@anchor{gnat_ugn/building_executable_programs_with_gnat id49}@anchor{142}
+@anchor{gnat_ugn/building_executable_programs_with_gnat automatically-creating-a-list-of-directories}@anchor{144}@anchor{gnat_ugn/building_executable_programs_with_gnat id49}@anchor{145}
@subsection Automatically Creating a List of Directories
@end example
@node Generating the Command Line Switches,Overcoming Command Line Length Limits,Automatically Creating a List of Directories,Using the GNU make Utility
-@anchor{gnat_ugn/building_executable_programs_with_gnat id50}@anchor{143}@anchor{gnat_ugn/building_executable_programs_with_gnat generating-the-command-line-switches}@anchor{144}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id50}@anchor{146}@anchor{gnat_ugn/building_executable_programs_with_gnat generating-the-command-line-switches}@anchor{147}
@subsection Generating the Command Line Switches
Once you have created the list of directories as explained in the
-previous section (@ref{141,,Automatically Creating a List of Directories}),
+previous section (@ref{144,,Automatically Creating a List of Directories}),
you can easily generate the command line arguments to pass to gnatmake.
For the sake of completeness, this example assumes that the source path
@end example
@node Overcoming Command Line Length Limits,,Generating the Command Line Switches,Using the GNU make Utility
-@anchor{gnat_ugn/building_executable_programs_with_gnat overcoming-command-line-length-limits}@anchor{145}@anchor{gnat_ugn/building_executable_programs_with_gnat id51}@anchor{146}
+@anchor{gnat_ugn/building_executable_programs_with_gnat overcoming-command-line-length-limits}@anchor{148}@anchor{gnat_ugn/building_executable_programs_with_gnat id51}@anchor{149}
@subsection Overcoming Command Line Length Limits
It assumes that you have created a list of directories in your Makefile,
using one of the methods presented in
-@ref{141,,Automatically Creating a List of Directories}.
+@ref{144,,Automatically Creating a List of Directories}.
For the sake of completeness, we assume that the object
path (where the ALI files are found) is different from the sources patch.
@c -- Example: A |withing| unit has a |with| clause, it |withs| a |withed| unit
@node GNAT Project Manager,Tools Supporting Project Files,Building Executable Programs with GNAT,Top
-@anchor{gnat_ugn/gnat_project_manager doc}@anchor{147}@anchor{gnat_ugn/gnat_project_manager gnat-project-manager}@anchor{b}@anchor{gnat_ugn/gnat_project_manager id1}@anchor{148}
+@anchor{gnat_ugn/gnat_project_manager doc}@anchor{14a}@anchor{gnat_ugn/gnat_project_manager gnat-project-manager}@anchor{b}@anchor{gnat_ugn/gnat_project_manager id1}@anchor{14b}
@chapter GNAT Project Manager
@end menu
@node Introduction,Building With Projects,,GNAT Project Manager
-@anchor{gnat_ugn/gnat_project_manager introduction}@anchor{149}@anchor{gnat_ugn/gnat_project_manager gnat-project-manager-introduction}@anchor{14a}
+@anchor{gnat_ugn/gnat_project_manager introduction}@anchor{14c}@anchor{gnat_ugn/gnat_project_manager gnat-project-manager-introduction}@anchor{14d}
@section Introduction
@item
Source file naming conventions; you can specify these either globally or for
-individual compilation units (see @ref{14b,,Naming Schemes}).
+individual compilation units (see @ref{14e,,Naming Schemes}).
@item
Change any of the above settings depending on external values, thus enabling
-the reuse of the projects in various @strong{scenarios} (see @ref{14c,,Scenarios in Projects}).
+the reuse of the projects in various @strong{scenarios} (see @ref{14f,,Scenarios in Projects}).
@item
Automatically build libraries as part of the build process
Project files are written in a syntax close to that of Ada, using familiar
notions such as packages, context clauses, declarations, default values,
-assignments, and inheritance (see @ref{14d,,Project File Reference}).
+assignments, and inheritance (see @ref{150,,Project File Reference}).
Project files can be built hierarchically from other project files, simplifying
-complex system integration and project reuse (see @ref{14e,,Organizing Projects into Subsystems}).
+complex system integration and project reuse (see @ref{151,,Organizing Projects into Subsystems}).
@itemize *
You can organize GNAT projects in a hierarchy: a child project
can extend a parent project, inheriting the parent's source files and
optionally overriding any of them with alternative versions
-(see @ref{14f,,Project Extension}).
+(see @ref{152,,Project Extension}).
@end itemize
Several tools support project files, generally in addition to specifying
the details of related project file capabilities.
@node Building With Projects,Organizing Projects into Subsystems,Introduction,GNAT Project Manager
-@anchor{gnat_ugn/gnat_project_manager building-with-projects}@anchor{150}@anchor{gnat_ugn/gnat_project_manager id2}@anchor{151}
+@anchor{gnat_ugn/gnat_project_manager building-with-projects}@anchor{153}@anchor{gnat_ugn/gnat_project_manager id2}@anchor{154}
@section Building With Projects
A specific project characteristic is defined by an attribute clause. Its
value is a string or a sequence of strings. All settings in a project
are defined through a list of predefined attributes with precise
-semantics. See @ref{152,,Attributes}.
+semantics. See @ref{155,,Attributes}.
@item @strong{Package in a project}:
Attributes affecting specific tools are grouped in a
package whose name is related to tool's function. The most common
packages are @cite{Builder}, @cite{Compiler}, @cite{Binder},
-and @cite{Linker}. See @ref{153,,Packages}.
+and @cite{Linker}. See @ref{156,,Packages}.
@item @strong{Project variables}:
values and avoid duplication in complex expressions. It can be initialized
with a value coming from the environment.
A frequent use of variables is to define scenarios.
-See @ref{154,,External Values}, @ref{14c,,Scenarios in Projects}, and @ref{155,,Variables}.
+See @ref{157,,External Values}, @ref{14f,,Scenarios in Projects}, and @ref{158,,Variables}.
@item @strong{Source files} and @strong{source directories}:
@cite{bar.ads} or @cite{bar.1.ada} are two common naming conventions for a
file containing an Ada spec. A compilation unit is often composed of a main
source file and potentially several auxiliary ones, such as header files in C.
-The naming conventions can be user defined @ref{14b,,Naming Schemes}, and will
+The naming conventions can be user defined @ref{14e,,Naming Schemes}, and will
drive the builder to call the appropriate compiler for the given source file.
Source files are searched for in the source directories associated with the
project through the @strong{Source_Dirs} attribute. By default, all the files (in
@end menu
@node Source Files and Directories,Duplicate Sources in Projects,,Building With Projects
-@anchor{gnat_ugn/gnat_project_manager id3}@anchor{156}@anchor{gnat_ugn/gnat_project_manager source-files-and-directories}@anchor{157}
+@anchor{gnat_ugn/gnat_project_manager id3}@anchor{159}@anchor{gnat_ugn/gnat_project_manager source-files-and-directories}@anchor{15a}
@subsection Source Files and Directories
Even when using only Ada, the default naming might not be suitable. Indeed,
how does the project manager recognizes an "Ada file" from any other
file? Project files can describe the naming scheme used for source files,
-and override the default (see @ref{14b,,Naming Schemes}). The default is the
+and override the default (see @ref{14e,,Naming Schemes}). The default is the
standard GNAT extension (@code{.adb} for bodies and @code{.ads} for
specs), which is what is used in our example, explaining why no naming scheme
is explicitly specified.
-See @ref{14b,,Naming Schemes}.
+See @ref{14e,,Naming Schemes}.
@geindex Source_Files (GNAT Project Manager)
For various reasons, it is sometimes useful to have a project with no
sources (most of the time because the attributes defined in the project
file will be reused in other projects, as explained in
-@ref{14e,,Organizing Projects into Subsystems}. To do this, the attribute
+@ref{151,,Organizing Projects into Subsystems}. To do this, the attribute
@emph{Source_Files} is set to the empty list, i.e. @cite{()}. Alternatively,
@emph{Source_Dirs} can be set to the empty list, with the same
result.
(or its synonym @strong{Locally_Removed_Files}).
Its value is the list of file names that should not be taken into account.
This attribute is often used when extending a project,
-see @ref{14f,,Project Extension}. A similar attribute
+see @ref{152,,Project Extension}. A similar attribute
@strong{Excluded_Source_List_File} plays the same
role but takes the name of file containing file names similarly to
@cite{Source_List_File}.
to it and this is not explicitly indicated in the project file.
@node Duplicate Sources in Projects,Object and Exec Directory,Source Files and Directories,Building With Projects
-@anchor{gnat_ugn/gnat_project_manager duplicate-sources-in-projects}@anchor{158}@anchor{gnat_ugn/gnat_project_manager id4}@anchor{159}
+@anchor{gnat_ugn/gnat_project_manager duplicate-sources-in-projects}@anchor{15b}@anchor{gnat_ugn/gnat_project_manager id4}@anchor{15c}
@subsection Duplicate Sources in Projects
file that should not be used as a source of the project.
@node Object and Exec Directory,Main Subprograms,Duplicate Sources in Projects,Building With Projects
-@anchor{gnat_ugn/gnat_project_manager object-and-exec-directory}@anchor{15a}@anchor{gnat_ugn/gnat_project_manager id5}@anchor{15b}
+@anchor{gnat_ugn/gnat_project_manager object-and-exec-directory}@anchor{15d}@anchor{gnat_ugn/gnat_project_manager id5}@anchor{15e}
@subsection Object and Exec Directory
result, if you have an existing system where the object files are spread across
several directories, you can either move all of them into the same directory if
you want to build it with a single project file, or study the section on
-subsystems (see @ref{14e,,Organizing Projects into Subsystems}) to see how each
+subsystems (see @ref{151,,Organizing Projects into Subsystems}) to see how each
separate object directory can be associated with one of the subsystems
constituting the application.
@end example
@node Main Subprograms,Tools Options in Project Files,Object and Exec Directory,Building With Projects
-@anchor{gnat_ugn/gnat_project_manager id6}@anchor{15c}@anchor{gnat_ugn/gnat_project_manager main-subprograms}@anchor{15d}
+@anchor{gnat_ugn/gnat_project_manager id6}@anchor{15f}@anchor{gnat_ugn/gnat_project_manager main-subprograms}@anchor{160}
@subsection Main Subprograms
or more executables on the command line to build a subset of them.
@node Tools Options in Project Files,Compiling with Project Files,Main Subprograms,Building With Projects
-@anchor{gnat_ugn/gnat_project_manager tools-options-in-project-files}@anchor{15e}@anchor{gnat_ugn/gnat_project_manager id7}@anchor{15f}
+@anchor{gnat_ugn/gnat_project_manager tools-options-in-project-files}@anchor{161}@anchor{gnat_ugn/gnat_project_manager id7}@anchor{162}
@subsection Tools Options in Project Files
A project file is subdivided into zero or more @strong{packages}, each of which
contains the attributes specific to one tool (or one set of tools). Project
files use an Ada-like syntax for packages. Package names permitted in project
-files are restricted to a predefined set (see @ref{153,,Packages}), and the contents
+files are restricted to a predefined set (see @ref{156,,Packages}), and the contents
of packages are limited to a small set of constructs and attributes
-(see @ref{152,,Attributes}).
+(see @ref{155,,Attributes}).
Our example project file can be extended with the following empty packages. At
this stage, they could all be omitted since they are empty, but they show which
package (for linking executables).
@node Compiling with Project Files,Executable File Names,Tools Options in Project Files,Building With Projects
-@anchor{gnat_ugn/gnat_project_manager compiling-with-project-files}@anchor{160}@anchor{gnat_ugn/gnat_project_manager id8}@anchor{161}
+@anchor{gnat_ugn/gnat_project_manager compiling-with-project-files}@anchor{163}@anchor{gnat_ugn/gnat_project_manager id8}@anchor{164}
@subsection Compiling with Project Files
commands.
@node Executable File Names,Avoid Duplication With Variables,Compiling with Project Files,Building With Projects
-@anchor{gnat_ugn/gnat_project_manager executable-file-names}@anchor{162}@anchor{gnat_ugn/gnat_project_manager id9}@anchor{163}
+@anchor{gnat_ugn/gnat_project_manager executable-file-names}@anchor{165}@anchor{gnat_ugn/gnat_project_manager id9}@anchor{166}
@subsection Executable File Names
@cite{Executable_Suffix}.
@node Avoid Duplication With Variables,Naming Schemes,Executable File Names,Building With Projects
-@anchor{gnat_ugn/gnat_project_manager id10}@anchor{164}@anchor{gnat_ugn/gnat_project_manager avoid-duplication-with-variables}@anchor{165}
+@anchor{gnat_ugn/gnat_project_manager id10}@anchor{167}@anchor{gnat_ugn/gnat_project_manager avoid-duplication-with-variables}@anchor{168}
@subsection Avoid Duplication With Variables
@emph{Compiler} package to store settings used in several attributes.
This avoids text duplication, and eases maintenance (a single place to
modify if we want to add new switches for C files). We will revisit
-the use of variables in the context of scenarios (see @ref{14c,,Scenarios in Projects}).
+the use of variables in the context of scenarios (see @ref{14f,,Scenarios in Projects}).
In this example, we see how the file @code{main.c} can be compiled with
the switches used for all the other C files, plus @emph{-g}.
account.
@node Naming Schemes,Installation,Avoid Duplication With Variables,Building With Projects
-@anchor{gnat_ugn/gnat_project_manager id11}@anchor{166}@anchor{gnat_ugn/gnat_project_manager naming-schemes}@anchor{14b}
+@anchor{gnat_ugn/gnat_project_manager id11}@anchor{169}@anchor{gnat_ugn/gnat_project_manager naming-schemes}@anchor{14e}
@subsection Naming Schemes
@end example
@node Installation,Distributed support,Naming Schemes,Building With Projects
-@anchor{gnat_ugn/gnat_project_manager id12}@anchor{167}@anchor{gnat_ugn/gnat_project_manager installation}@anchor{168}
+@anchor{gnat_ugn/gnat_project_manager id12}@anchor{16a}@anchor{gnat_ugn/gnat_project_manager installation}@anchor{16b}
@subsection Installation
@end quotation
@node Distributed support,,Installation,Building With Projects
-@anchor{gnat_ugn/gnat_project_manager id13}@anchor{169}@anchor{gnat_ugn/gnat_project_manager distributed-support}@anchor{16a}
+@anchor{gnat_ugn/gnat_project_manager id13}@anchor{16c}@anchor{gnat_ugn/gnat_project_manager distributed-support}@anchor{16d}
@subsection Distributed support
@end quotation
@node Organizing Projects into Subsystems,Scenarios in Projects,Building With Projects,GNAT Project Manager
-@anchor{gnat_ugn/gnat_project_manager organizing-projects-into-subsystems}@anchor{14e}@anchor{gnat_ugn/gnat_project_manager id14}@anchor{16b}
+@anchor{gnat_ugn/gnat_project_manager organizing-projects-into-subsystems}@anchor{151}@anchor{gnat_ugn/gnat_project_manager id14}@anchor{16e}
@section Organizing Projects into Subsystems
@end menu
@node Project Dependencies,Cyclic Project Dependencies,,Organizing Projects into Subsystems
-@anchor{gnat_ugn/gnat_project_manager project-dependencies}@anchor{16c}@anchor{gnat_ugn/gnat_project_manager id15}@anchor{16d}
+@anchor{gnat_ugn/gnat_project_manager project-dependencies}@anchor{16f}@anchor{gnat_ugn/gnat_project_manager id15}@anchor{170}
@subsection Project Dependencies
string, and you cannot use concatenation, or lookup the value of external
variables to change the directories from which a project is loaded.
A solution if you need something like this is to use aggregate projects
-(see @ref{16e,,Aggregate Projects}).
+(see @ref{171,,Aggregate Projects}).
@geindex project path (GNAT Project Manager)
@end cartouche
@node Cyclic Project Dependencies,Sharing Between Projects,Project Dependencies,Organizing Projects into Subsystems
-@anchor{gnat_ugn/gnat_project_manager id16}@anchor{16f}@anchor{gnat_ugn/gnat_project_manager cyclic-project-dependencies}@anchor{170}
+@anchor{gnat_ugn/gnat_project_manager id16}@anchor{172}@anchor{gnat_ugn/gnat_project_manager cyclic-project-dependencies}@anchor{173}
@subsection Cyclic Project Dependencies
@end example
@node Sharing Between Projects,Global Attributes,Cyclic Project Dependencies,Organizing Projects into Subsystems
-@anchor{gnat_ugn/gnat_project_manager sharing-between-projects}@anchor{171}@anchor{gnat_ugn/gnat_project_manager id17}@anchor{172}
+@anchor{gnat_ugn/gnat_project_manager sharing-between-projects}@anchor{174}@anchor{gnat_ugn/gnat_project_manager id17}@anchor{175}
@subsection Sharing Between Projects
the projects corresponding to the subsystems under construction. For instance,
they will all have the same compilation switches.
-As seen before (see @ref{15e,,Tools Options in Project Files}), setting compilation
+As seen before (see @ref{161,,Tools Options in Project Files}), setting compilation
switches for all sources of a subsystem is simple: it is just a matter of
adding a @cite{Compiler.Default_Switches} attribute to each project files with
the same value. Of course, that means duplication of data, and both places need
Note the additional use of the @strong{abstract} qualifier in @code{shared.gpr}.
This qualifier is optional, but helps convey the message that we do not
-intend this project to have sources (see @ref{173,,Qualified Projects} for
+intend this project to have sources (see @ref{176,,Qualified Projects} for
more qualifiers).
@end itemize
@node Global Attributes,,Sharing Between Projects,Organizing Projects into Subsystems
-@anchor{gnat_ugn/gnat_project_manager global-attributes}@anchor{174}@anchor{gnat_ugn/gnat_project_manager id18}@anchor{175}
+@anchor{gnat_ugn/gnat_project_manager global-attributes}@anchor{177}@anchor{gnat_ugn/gnat_project_manager id18}@anchor{178}
@subsection Global Attributes
replacement to global attributes.
@node Scenarios in Projects,Library Projects,Organizing Projects into Subsystems,GNAT Project Manager
-@anchor{gnat_ugn/gnat_project_manager id19}@anchor{176}@anchor{gnat_ugn/gnat_project_manager scenarios-in-projects}@anchor{14c}
+@anchor{gnat_ugn/gnat_project_manager id19}@anchor{179}@anchor{gnat_ugn/gnat_project_manager scenarios-in-projects}@anchor{14f}
@section Scenarios in Projects
duplicate a variable similar to @cite{Mode} in each of the project (as long
as the first argument to @cite{external} is always the same and the type is
the same), or simply set the variable in the @code{shared.gpr} project
-(see @ref{171,,Sharing Between Projects}).
+(see @ref{174,,Sharing Between Projects}).
@node Library Projects,Project Extension,Scenarios in Projects,GNAT Project Manager
-@anchor{gnat_ugn/gnat_project_manager library-projects}@anchor{8a}@anchor{gnat_ugn/gnat_project_manager id20}@anchor{177}
+@anchor{gnat_ugn/gnat_project_manager library-projects}@anchor{8a}@anchor{gnat_ugn/gnat_project_manager id20}@anchor{17a}
@section Library Projects
@end menu
@node Building Libraries,Using Library Projects,,Library Projects
-@anchor{gnat_ugn/gnat_project_manager id21}@anchor{178}@anchor{gnat_ugn/gnat_project_manager building-libraries}@anchor{179}
+@anchor{gnat_ugn/gnat_project_manager id21}@anchor{17b}@anchor{gnat_ugn/gnat_project_manager building-libraries}@anchor{17c}
@subsection Building Libraries
@end quotation
@node Using Library Projects,Stand-alone Library Projects,Building Libraries,Library Projects
-@anchor{gnat_ugn/gnat_project_manager id22}@anchor{17a}@anchor{gnat_ugn/gnat_project_manager using-library-projects}@anchor{17b}
+@anchor{gnat_ugn/gnat_project_manager id22}@anchor{17d}@anchor{gnat_ugn/gnat_project_manager using-library-projects}@anchor{17e}
@subsection Using Library Projects
the proper order of libraries in the final link command.
@node Stand-alone Library Projects,Installing a library with project files,Using Library Projects,Library Projects
-@anchor{gnat_ugn/gnat_project_manager id23}@anchor{17c}@anchor{gnat_ugn/gnat_project_manager stand-alone-library-projects}@anchor{97}
+@anchor{gnat_ugn/gnat_project_manager id23}@anchor{17f}@anchor{gnat_ugn/gnat_project_manager stand-alone-library-projects}@anchor{97}
@subsection Stand-alone Library Projects
@end quotation
@node Installing a library with project files,,Stand-alone Library Projects,Library Projects
-@anchor{gnat_ugn/gnat_project_manager installing-a-library-with-project-files}@anchor{8d}@anchor{gnat_ugn/gnat_project_manager id24}@anchor{17d}
+@anchor{gnat_ugn/gnat_project_manager installing-a-library-with-project-files}@anchor{8d}@anchor{gnat_ugn/gnat_project_manager id24}@anchor{180}
@subsection Installing a library with project files
to distribute a library in binary form where the user is not expected to be
able to recompile the library. The simplest option in this case is to provide
a project file slightly different from the one used to build the library, by
-using the @cite{externally_built} attribute. See @ref{17b,,Using Library Projects}
+using the @cite{externally_built} attribute. See @ref{17e,,Using Library Projects}
Another option is to use @emph{gprinstall} to install the library in a
different context than the build location. @emph{gprinstall} automatically
generates a project to use this library, and also copies the minimum set of
sources needed to use the library to the install location.
-@ref{168,,Installation}
+@ref{16b,,Installation}
@node Project Extension,Aggregate Projects,Library Projects,GNAT Project Manager
-@anchor{gnat_ugn/gnat_project_manager id25}@anchor{17e}@anchor{gnat_ugn/gnat_project_manager project-extension}@anchor{14f}
+@anchor{gnat_ugn/gnat_project_manager id25}@anchor{181}@anchor{gnat_ugn/gnat_project_manager project-extension}@anchor{152}
@section Project Extension
The project after @strong{extends} is the one being extended. As usual, it can be
specified using an absolute path, or a path relative to any of the directories
-in the project path (see @ref{16c,,Project Dependencies}). This project does not
+in the project path (see @ref{16f,,Project Dependencies}). This project does not
specify source or object directories, so the default values for these
attributes will be used that is to say the current directory (where project
@cite{Work} is placed). We can compile that project with
@end menu
@node Project Hierarchy Extension,,,Project Extension
-@anchor{gnat_ugn/gnat_project_manager project-hierarchy-extension}@anchor{17f}@anchor{gnat_ugn/gnat_project_manager id26}@anchor{180}
+@anchor{gnat_ugn/gnat_project_manager project-hierarchy-extension}@anchor{182}@anchor{gnat_ugn/gnat_project_manager id26}@anchor{183}
@subsection Project Hierarchy Extension
impacted by the changes in @cite{A1} and @cite{C1}.
@node Aggregate Projects,Aggregate Library Projects,Project Extension,GNAT Project Manager
-@anchor{gnat_ugn/gnat_project_manager aggregate-projects}@anchor{16e}@anchor{gnat_ugn/gnat_project_manager id27}@anchor{181}
+@anchor{gnat_ugn/gnat_project_manager aggregate-projects}@anchor{171}@anchor{gnat_ugn/gnat_project_manager id27}@anchor{184}
@section Aggregate Projects
@end menu
@node Building all main programs from a single project tree,Building a set of projects with a single command,,Aggregate Projects
-@anchor{gnat_ugn/gnat_project_manager id28}@anchor{182}@anchor{gnat_ugn/gnat_project_manager building-all-main-programs-from-a-single-project-tree}@anchor{183}
+@anchor{gnat_ugn/gnat_project_manager id28}@anchor{185}@anchor{gnat_ugn/gnat_project_manager building-all-main-programs-from-a-single-project-tree}@anchor{186}
@subsection Building all main programs from a single project tree
building the aggregate project.
@node Building a set of projects with a single command,Define a build environment,Building all main programs from a single project tree,Aggregate Projects
-@anchor{gnat_ugn/gnat_project_manager building-a-set-of-projects-with-a-single-command}@anchor{184}@anchor{gnat_ugn/gnat_project_manager id29}@anchor{185}
+@anchor{gnat_ugn/gnat_project_manager building-a-set-of-projects-with-a-single-command}@anchor{187}@anchor{gnat_ugn/gnat_project_manager id29}@anchor{188}
@subsection Building a set of projects with a single command
with Annex E.
@node Define a build environment,Performance improvements in builder,Building a set of projects with a single command,Aggregate Projects
-@anchor{gnat_ugn/gnat_project_manager id30}@anchor{186}@anchor{gnat_ugn/gnat_project_manager define-a-build-environment}@anchor{187}
+@anchor{gnat_ugn/gnat_project_manager id30}@anchor{189}@anchor{gnat_ugn/gnat_project_manager define-a-build-environment}@anchor{18a}
@subsection Define a build environment
for External ("BUILD") use "PRODUCTION";
package Builder is
- for Switches ("Ada") use ("-q");
+ for Global_Compilation_Switches ("Ada") use ("-g");
end Builder;
end Agg;
@end example
@end example
@node Performance improvements in builder,Syntax of aggregate projects,Define a build environment,Aggregate Projects
-@anchor{gnat_ugn/gnat_project_manager performance-improvements-in-builder}@anchor{188}@anchor{gnat_ugn/gnat_project_manager id31}@anchor{189}
+@anchor{gnat_ugn/gnat_project_manager performance-improvements-in-builder}@anchor{18b}@anchor{gnat_ugn/gnat_project_manager id31}@anchor{18c}
@subsection Performance improvements in builder
multiple @emph{gprbuild} commands in parallel).
@node Syntax of aggregate projects,package Builder in aggregate projects,Performance improvements in builder,Aggregate Projects
-@anchor{gnat_ugn/gnat_project_manager id32}@anchor{18a}@anchor{gnat_ugn/gnat_project_manager syntax-of-aggregate-projects}@anchor{18b}
+@anchor{gnat_ugn/gnat_project_manager id32}@anchor{18d}@anchor{gnat_ugn/gnat_project_manager syntax-of-aggregate-projects}@anchor{18e}
@subsection Syntax of aggregate projects
@end quotation
@node package Builder in aggregate projects,,Syntax of aggregate projects,Aggregate Projects
-@anchor{gnat_ugn/gnat_project_manager package-builder-in-aggregate-projects}@anchor{18c}@anchor{gnat_ugn/gnat_project_manager id33}@anchor{18d}
+@anchor{gnat_ugn/gnat_project_manager package-builder-in-aggregate-projects}@anchor{18f}@anchor{gnat_ugn/gnat_project_manager id33}@anchor{190}
@subsection package Builder in aggregate projects
for the Executable_Suffix.
@node Aggregate Library Projects,Project File Reference,Aggregate Projects,GNAT Project Manager
-@anchor{gnat_ugn/gnat_project_manager id34}@anchor{18e}@anchor{gnat_ugn/gnat_project_manager aggregate-library-projects}@anchor{18f}
+@anchor{gnat_ugn/gnat_project_manager id34}@anchor{191}@anchor{gnat_ugn/gnat_project_manager aggregate-library-projects}@anchor{192}
@section Aggregate Library Projects
@end menu
@node Building aggregate library projects,Syntax of aggregate library projects,,Aggregate Library Projects
-@anchor{gnat_ugn/gnat_project_manager building-aggregate-library-projects}@anchor{190}@anchor{gnat_ugn/gnat_project_manager id35}@anchor{191}
+@anchor{gnat_ugn/gnat_project_manager building-aggregate-library-projects}@anchor{193}@anchor{gnat_ugn/gnat_project_manager id35}@anchor{194}
@subsection Building aggregate library projects
from projects @code{a.gpr}, @code{b.gpr} and @code{c.gpr}.
@node Syntax of aggregate library projects,,Building aggregate library projects,Aggregate Library Projects
-@anchor{gnat_ugn/gnat_project_manager syntax-of-aggregate-library-projects}@anchor{192}@anchor{gnat_ugn/gnat_project_manager id36}@anchor{193}
+@anchor{gnat_ugn/gnat_project_manager syntax-of-aggregate-library-projects}@anchor{195}@anchor{gnat_ugn/gnat_project_manager id36}@anchor{196}
@subsection Syntax of aggregate library projects
The only package that is authorized (albeit optional) is Builder.
-The Project_Files attribute (See @ref{16e,,Aggregate Projects}) is used to
+The Project_Files attribute (See @ref{171,,Aggregate Projects}) is used to
described the aggregated projects whose object files have to be
included into the aggregate library. The environment variables
@cite{ADA_PROJECT_PATH}, @cite{GPR_PROJECT_PATH} and
@cite{GPR_PROJECT_PATH_FILE} are not used to find the project files.
@node Project File Reference,,Aggregate Library Projects,GNAT Project Manager
-@anchor{gnat_ugn/gnat_project_manager id37}@anchor{194}@anchor{gnat_ugn/gnat_project_manager project-file-reference}@anchor{14d}
+@anchor{gnat_ugn/gnat_project_manager id37}@anchor{197}@anchor{gnat_ugn/gnat_project_manager project-file-reference}@anchor{150}
@section Project File Reference
@end menu
@node Project Declaration,Qualified Projects,,Project File Reference
-@anchor{gnat_ugn/gnat_project_manager id38}@anchor{195}@anchor{gnat_ugn/gnat_project_manager project-declaration}@anchor{196}
+@anchor{gnat_ugn/gnat_project_manager id38}@anchor{198}@anchor{gnat_ugn/gnat_project_manager project-declaration}@anchor{199}
@subsection Project Declaration
@end example
@node Qualified Projects,Declarations,Project Declaration,Project File Reference
-@anchor{gnat_ugn/gnat_project_manager qualified-projects}@anchor{173}@anchor{gnat_ugn/gnat_project_manager id39}@anchor{197}
+@anchor{gnat_ugn/gnat_project_manager qualified-projects}@anchor{176}@anchor{gnat_ugn/gnat_project_manager id39}@anchor{19a}
@subsection Qualified Projects
@end table
@node Declarations,Packages,Qualified Projects,Project File Reference
-@anchor{gnat_ugn/gnat_project_manager declarations}@anchor{198}@anchor{gnat_ugn/gnat_project_manager id40}@anchor{199}
+@anchor{gnat_ugn/gnat_project_manager declarations}@anchor{19b}@anchor{gnat_ugn/gnat_project_manager id40}@anchor{19c}
@subsection Declarations
no effect.
@node Packages,Expressions,Declarations,Project File Reference
-@anchor{gnat_ugn/gnat_project_manager packages}@anchor{153}@anchor{gnat_ugn/gnat_project_manager id41}@anchor{19a}
+@anchor{gnat_ugn/gnat_project_manager packages}@anchor{156}@anchor{gnat_ugn/gnat_project_manager id41}@anchor{19d}
@subsection Packages
A package with a given name may only appear once in a project file.
The following packages are currently supported in project files
-(See @ref{152,,Attributes} for the list of attributes that each can contain).
+(See @ref{155,,Attributes} for the list of attributes that each can contain).
@table @asis
This package specifies characteristics useful when invoking the binder either
directly via the @emph{gnat} driver or when using @emph{gprbuild}.
-See @ref{15d,,Main Subprograms}.
+See @ref{160,,Main Subprograms}.
@item @emph{Builder}
executable or a library for a project. Most of the options should be
set in one of @cite{Compiler}, @cite{Binder} or @cite{Linker} packages,
but there are some general options that should be defined in this
-package. See @ref{15d,,Main Subprograms}, and @ref{162,,Executable File Names} in
+package. See @ref{160,,Main Subprograms}, and @ref{165,,Executable File Names} in
particular.
@end table
@item @emph{Compiler}
This package specifies the compilation options used by the compiler for
-each languages. See @ref{15e,,Tools Options in Project Files}.
+each languages. See @ref{161,,Tools Options in Project Files}.
@item @emph{Cross_Reference}
@item @emph{Install}
This package specifies the options used when installing a project
-with @emph{gprinstall}. See @ref{168,,Installation}.
+with @emph{gprinstall}. See @ref{16b,,Installation}.
@item @emph{Linker}
This package specifies the options used by the linker.
-See @ref{15d,,Main Subprograms}.
+See @ref{160,,Main Subprograms}.
@end table
to the source files in a project. In particular, these conventions are
used to automatically find all source files in the source directories,
or given a file name to find out its language for proper processing.
-See @ref{14b,,Naming Schemes}.
+See @ref{14e,,Naming Schemes}.
@end quotation
@end example
@node Expressions,External Values,Packages,Project File Reference
-@anchor{gnat_ugn/gnat_project_manager expressions}@anchor{19b}@anchor{gnat_ugn/gnat_project_manager id42}@anchor{19c}
+@anchor{gnat_ugn/gnat_project_manager expressions}@anchor{19e}@anchor{gnat_ugn/gnat_project_manager id42}@anchor{19f}
@subsection Expressions
A literal string, for instance @cite{"comm/my_proj.gpr"}
@item
-The name of a variable that evaluates to a string (see @ref{155,,Variables})
+The name of a variable that evaluates to a string (see @ref{158,,Variables})
@item
-The name of an attribute that evaluates to a string (see @ref{152,,Attributes})
+The name of an attribute that evaluates to a string (see @ref{155,,Attributes})
@item
-An external reference (see @ref{154,,External Values})
+An external reference (see @ref{157,,External Values})
@item
A concatenation of the above, as in @cite{"prefix_" & Var}.
@end example
@node External Values,Typed String Declaration,Expressions,Project File Reference
-@anchor{gnat_ugn/gnat_project_manager external-values}@anchor{154}@anchor{gnat_ugn/gnat_project_manager id43}@anchor{19d}
+@anchor{gnat_ugn/gnat_project_manager external-values}@anchor{157}@anchor{gnat_ugn/gnat_project_manager id43}@anchor{1a0}
@subsection External Values
If the external value is ",", the result is (), the empty string list.
@node Typed String Declaration,Variables,External Values,Project File Reference
-@anchor{gnat_ugn/gnat_project_manager id44}@anchor{19e}@anchor{gnat_ugn/gnat_project_manager typed-string-declaration}@anchor{19f}
+@anchor{gnat_ugn/gnat_project_manager id44}@anchor{1a1}@anchor{gnat_ugn/gnat_project_manager typed-string-declaration}@anchor{1a2}
@subsection Typed String Declaration
Variables of a string type are called @strong{typed variables}; all other
variables are called @strong{untyped variables}. Typed variables are
particularly useful in @cite{case} constructions, to support conditional
-attribute declarations. (See @ref{1a0,,Case Constructions}).
+attribute declarations. (See @ref{1a3,,Case Constructions}).
A string type may be referenced by its name if it has been declared in the same
project file, or by an expanded name whose prefix is the name of the project
in which it is declared.
@node Variables,Case Constructions,Typed String Declaration,Project File Reference
-@anchor{gnat_ugn/gnat_project_manager variables}@anchor{155}@anchor{gnat_ugn/gnat_project_manager id45}@anchor{1a1}
+@anchor{gnat_ugn/gnat_project_manager variables}@anchor{158}@anchor{gnat_ugn/gnat_project_manager id45}@anchor{1a4}
@subsection Variables
@end itemize
@node Case Constructions,Attributes,Variables,Project File Reference
-@anchor{gnat_ugn/gnat_project_manager id46}@anchor{1a2}@anchor{gnat_ugn/gnat_project_manager case-constructions}@anchor{1a0}
+@anchor{gnat_ugn/gnat_project_manager id46}@anchor{1a5}@anchor{gnat_ugn/gnat_project_manager case-constructions}@anchor{1a3}
@subsection Case Constructions
(although the @cite{null} declaration for empty alternatives is optional).
The case expression must be a string variable, either typed or not, whose value
-is often given by an external reference (see @ref{154,,External Values}).
+is often given by an external reference (see @ref{157,,External Values}).
Each alternative starts with the reserved word @cite{when}, either a list of
literal strings separated by the @cite{"|"} character or the reserved word
@end example
@node Attributes,,Case Constructions,Project File Reference
-@anchor{gnat_ugn/gnat_project_manager id47}@anchor{1a3}@anchor{gnat_ugn/gnat_project_manager attributes}@anchor{152}
+@anchor{gnat_ugn/gnat_project_manager id47}@anchor{1a6}@anchor{gnat_ugn/gnat_project_manager attributes}@anchor{155}
@subsection Attributes
@end menu
@node Project Level Attributes,Package Binder Attributes,,Attributes
-@anchor{gnat_ugn/gnat_project_manager project-level-attributes}@anchor{1a4}@anchor{gnat_ugn/gnat_project_manager id48}@anchor{1a5}
+@anchor{gnat_ugn/gnat_project_manager project-level-attributes}@anchor{1a7}@anchor{gnat_ugn/gnat_project_manager id48}@anchor{1a8}
@subsubsection Project Level Attributes
@end itemize
@node Package Binder Attributes,Package Builder Attributes,Project Level Attributes,Attributes
-@anchor{gnat_ugn/gnat_project_manager package-binder-attributes}@anchor{1a6}@anchor{gnat_ugn/gnat_project_manager id49}@anchor{1a7}
+@anchor{gnat_ugn/gnat_project_manager package-binder-attributes}@anchor{1a9}@anchor{gnat_ugn/gnat_project_manager id49}@anchor{1aa}
@subsubsection Package Binder Attributes
@end itemize
@node Package Builder Attributes,Package Clean Attributes,Package Binder Attributes,Attributes
-@anchor{gnat_ugn/gnat_project_manager package-builder-attributes}@anchor{1a8}@anchor{gnat_ugn/gnat_project_manager id50}@anchor{1a9}
+@anchor{gnat_ugn/gnat_project_manager package-builder-attributes}@anchor{1ab}@anchor{gnat_ugn/gnat_project_manager id50}@anchor{1ac}
@subsubsection Package Builder Attributes
@node Package Clean Attributes,Package Compiler Attributes,Package Builder Attributes,Attributes
-@anchor{gnat_ugn/gnat_project_manager package-clean-attributes}@anchor{1aa}@anchor{gnat_ugn/gnat_project_manager id52}@anchor{1ab}
+@anchor{gnat_ugn/gnat_project_manager package-clean-attributes}@anchor{1ad}@anchor{gnat_ugn/gnat_project_manager id52}@anchor{1ae}
@subsubsection Package Clean Attributes
@end itemize
@node Package Compiler Attributes,Package Cross_Reference Attributes,Package Clean Attributes,Attributes
-@anchor{gnat_ugn/gnat_project_manager id53}@anchor{1ac}@anchor{gnat_ugn/gnat_project_manager package-compiler-attributes}@anchor{1ad}
+@anchor{gnat_ugn/gnat_project_manager id53}@anchor{1af}@anchor{gnat_ugn/gnat_project_manager package-compiler-attributes}@anchor{1b0}
@subsubsection Package Compiler Attributes
@end itemize
@node Package Cross_Reference Attributes,Package Finder Attributes,Package Compiler Attributes,Attributes
-@anchor{gnat_ugn/gnat_project_manager id54}@anchor{1ae}@anchor{gnat_ugn/gnat_project_manager package-cross-reference-attributes}@anchor{1af}
+@anchor{gnat_ugn/gnat_project_manager id54}@anchor{1b1}@anchor{gnat_ugn/gnat_project_manager package-cross-reference-attributes}@anchor{1b2}
@subsubsection Package Cross_Reference Attributes
@node Package Finder Attributes,Package gnatls Attributes,Package Cross_Reference Attributes,Attributes
-@anchor{gnat_ugn/gnat_project_manager id56}@anchor{1b0}@anchor{gnat_ugn/gnat_project_manager package-finder-attributes}@anchor{1b1}
+@anchor{gnat_ugn/gnat_project_manager id56}@anchor{1b3}@anchor{gnat_ugn/gnat_project_manager package-finder-attributes}@anchor{1b4}
@subsubsection Package Finder Attributes
@end itemize
@node Package gnatls Attributes,Package IDE Attributes,Package Finder Attributes,Attributes
-@anchor{gnat_ugn/gnat_project_manager package-gnatls-attributes}@anchor{1b2}@anchor{gnat_ugn/gnat_project_manager id57}@anchor{1b3}
+@anchor{gnat_ugn/gnat_project_manager package-gnatls-attributes}@anchor{1b5}@anchor{gnat_ugn/gnat_project_manager id57}@anchor{1b6}
@subsubsection Package gnatls Attributes
@node Package IDE Attributes,Package Install Attributes,Package gnatls Attributes,Attributes
-@anchor{gnat_ugn/gnat_project_manager id58}@anchor{1b4}@anchor{gnat_ugn/gnat_project_manager package-ide-attributes}@anchor{1b5}
+@anchor{gnat_ugn/gnat_project_manager id58}@anchor{1b7}@anchor{gnat_ugn/gnat_project_manager package-ide-attributes}@anchor{1b8}
@subsubsection Package IDE Attributes
@end itemize
@node Package Install Attributes,Package Linker Attributes,Package IDE Attributes,Attributes
-@anchor{gnat_ugn/gnat_project_manager package-install-attributes}@anchor{1b6}@anchor{gnat_ugn/gnat_project_manager id59}@anchor{1b7}
+@anchor{gnat_ugn/gnat_project_manager package-install-attributes}@anchor{1b9}@anchor{gnat_ugn/gnat_project_manager id59}@anchor{1ba}
@subsubsection Package Install Attributes
@end itemize
@node Package Linker Attributes,Package Naming Attributes,Package Install Attributes,Attributes
-@anchor{gnat_ugn/gnat_project_manager id60}@anchor{1b8}@anchor{gnat_ugn/gnat_project_manager package-linker-attributes}@anchor{1b9}
+@anchor{gnat_ugn/gnat_project_manager id60}@anchor{1bb}@anchor{gnat_ugn/gnat_project_manager package-linker-attributes}@anchor{1bc}
@subsubsection Package Linker Attributes
@c invoking `gnatmetric` for the source.
@node Package Naming Attributes,Package Remote Attributes,Package Linker Attributes,Attributes
-@anchor{gnat_ugn/gnat_project_manager package-naming-attributes}@anchor{1ba}@anchor{gnat_ugn/gnat_project_manager id61}@anchor{1bb}
+@anchor{gnat_ugn/gnat_project_manager package-naming-attributes}@anchor{1bd}@anchor{gnat_ugn/gnat_project_manager id61}@anchor{1be}
@subsubsection Package Naming Attributes
@node Package Remote Attributes,Package Stack Attributes,Package Naming Attributes,Attributes
-@anchor{gnat_ugn/gnat_project_manager package-remote-attributes}@anchor{1bc}@anchor{gnat_ugn/gnat_project_manager id63}@anchor{1bd}
+@anchor{gnat_ugn/gnat_project_manager package-remote-attributes}@anchor{1bf}@anchor{gnat_ugn/gnat_project_manager id63}@anchor{1c0}
@subsubsection Package Remote Attributes
@end itemize
@node Package Stack Attributes,Package Synchronize Attributes,Package Remote Attributes,Attributes
-@anchor{gnat_ugn/gnat_project_manager id64}@anchor{1be}@anchor{gnat_ugn/gnat_project_manager package-stack-attributes}@anchor{1bf}
+@anchor{gnat_ugn/gnat_project_manager id64}@anchor{1c1}@anchor{gnat_ugn/gnat_project_manager package-stack-attributes}@anchor{1c2}
@subsubsection Package Stack Attributes
@end itemize
@node Package Synchronize Attributes,,Package Stack Attributes,Attributes
-@anchor{gnat_ugn/gnat_project_manager package-synchronize-attributes}@anchor{1c0}
+@anchor{gnat_ugn/gnat_project_manager package-synchronize-attributes}@anchor{1c3}
@subsubsection Package Synchronize Attributes
@end itemize
@node Tools Supporting Project Files,GNAT Utility Programs,GNAT Project Manager,Top
-@anchor{gnat_ugn/tools_supporting_project_files doc}@anchor{1c1}@anchor{gnat_ugn/tools_supporting_project_files tools-supporting-project-files}@anchor{c}@anchor{gnat_ugn/tools_supporting_project_files id1}@anchor{1c2}
+@anchor{gnat_ugn/tools_supporting_project_files doc}@anchor{1c4}@anchor{gnat_ugn/tools_supporting_project_files tools-supporting-project-files}@anchor{c}@anchor{gnat_ugn/tools_supporting_project_files id1}@anchor{1c5}
@chapter Tools Supporting Project Files
@end menu
@node gnatmake and Project Files,The GNAT Driver and Project Files,,Tools Supporting Project Files
-@anchor{gnat_ugn/tools_supporting_project_files id2}@anchor{1c3}@anchor{gnat_ugn/tools_supporting_project_files gnatmake-and-project-files}@anchor{e1}
+@anchor{gnat_ugn/tools_supporting_project_files id2}@anchor{1c6}@anchor{gnat_ugn/tools_supporting_project_files gnatmake-and-project-files}@anchor{e4}
@section gnatmake and Project Files
@end menu
@node Switches Related to Project Files,Switches and Project Files,,gnatmake and Project Files
-@anchor{gnat_ugn/tools_supporting_project_files switches-related-to-project-files}@anchor{e3}@anchor{gnat_ugn/tools_supporting_project_files id3}@anchor{1c4}
+@anchor{gnat_ugn/tools_supporting_project_files switches-related-to-project-files}@anchor{e6}@anchor{gnat_ugn/tools_supporting_project_files id3}@anchor{1c7}
@subsection Switches Related to Project Files
@end table
@node Switches and Project Files,Specifying Configuration Pragmas,Switches Related to Project Files,gnatmake and Project Files
-@anchor{gnat_ugn/tools_supporting_project_files id4}@anchor{1c5}@anchor{gnat_ugn/tools_supporting_project_files switches-and-project-files}@anchor{1c6}
+@anchor{gnat_ugn/tools_supporting_project_files id4}@anchor{1c8}@anchor{gnat_ugn/tools_supporting_project_files switches-and-project-files}@anchor{1c9}
@subsection Switches and Project Files
--RTS= for which a relative path argument is never converted.
@node Specifying Configuration Pragmas,Project Files and Main Subprograms,Switches and Project Files,gnatmake and Project Files
-@anchor{gnat_ugn/tools_supporting_project_files id5}@anchor{1c7}@anchor{gnat_ugn/tools_supporting_project_files specifying-configuration-pragmas}@anchor{7d}
+@anchor{gnat_ugn/tools_supporting_project_files id5}@anchor{1ca}@anchor{gnat_ugn/tools_supporting_project_files specifying-configuration-pragmas}@anchor{7d}
@subsection Specifying Configuration Pragmas
the project file of the source, if it exists.
@node Project Files and Main Subprograms,Library Project Files,Specifying Configuration Pragmas,gnatmake and Project Files
-@anchor{gnat_ugn/tools_supporting_project_files id6}@anchor{1c8}@anchor{gnat_ugn/tools_supporting_project_files project-files-and-main-subprograms}@anchor{e2}
+@anchor{gnat_ugn/tools_supporting_project_files id6}@anchor{1cb}@anchor{gnat_ugn/tools_supporting_project_files project-files-and-main-subprograms}@anchor{e5}
@subsection Project Files and Main Subprograms
the specific switches for each main, if they are specified.
@node Library Project Files,,Project Files and Main Subprograms,gnatmake and Project Files
-@anchor{gnat_ugn/tools_supporting_project_files id7}@anchor{1c9}@anchor{gnat_ugn/tools_supporting_project_files library-project-files}@anchor{1ca}
+@anchor{gnat_ugn/tools_supporting_project_files id7}@anchor{1cc}@anchor{gnat_ugn/tools_supporting_project_files library-project-files}@anchor{1cd}
@subsection Library Project Files
@end itemize
@node The GNAT Driver and Project Files,,gnatmake and Project Files,Tools Supporting Project Files
-@anchor{gnat_ugn/tools_supporting_project_files id8}@anchor{1cb}@anchor{gnat_ugn/tools_supporting_project_files the-gnat-driver-and-project-files}@anchor{11f}
+@anchor{gnat_ugn/tools_supporting_project_files id8}@anchor{1ce}@anchor{gnat_ugn/tools_supporting_project_files the-gnat-driver-and-project-files}@anchor{122}
@section The GNAT Driver and Project Files
@node GNAT Utility Programs,GNAT and Program Execution,Tools Supporting Project Files,Top
-@anchor{gnat_ugn/gnat_utility_programs doc}@anchor{1cc}@anchor{gnat_ugn/gnat_utility_programs gnat-utility-programs}@anchor{d}@anchor{gnat_ugn/gnat_utility_programs id1}@anchor{1cd}
+@anchor{gnat_ugn/gnat_utility_programs doc}@anchor{1cf}@anchor{gnat_ugn/gnat_utility_programs gnat-utility-programs}@anchor{d}@anchor{gnat_ugn/gnat_utility_programs id1}@anchor{1d0}
@chapter GNAT Utility Programs
@end menu
@node The File Cleanup Utility gnatclean,The GNAT Library Browser gnatls,,GNAT Utility Programs
-@anchor{gnat_ugn/gnat_utility_programs id2}@anchor{1ce}@anchor{gnat_ugn/gnat_utility_programs the-file-cleanup-utility-gnatclean}@anchor{22}
+@anchor{gnat_ugn/gnat_utility_programs id2}@anchor{1d1}@anchor{gnat_ugn/gnat_utility_programs the-file-cleanup-utility-gnatclean}@anchor{22}
@section The File Cleanup Utility @emph{gnatclean}
@end menu
@node Running gnatclean,Switches for gnatclean,,The File Cleanup Utility gnatclean
-@anchor{gnat_ugn/gnat_utility_programs running-gnatclean}@anchor{1cf}@anchor{gnat_ugn/gnat_utility_programs id3}@anchor{1d0}
+@anchor{gnat_ugn/gnat_utility_programs running-gnatclean}@anchor{1d2}@anchor{gnat_ugn/gnat_utility_programs id3}@anchor{1d3}
@subsection Running @cite{gnatclean}
normal mode is listed, but no file is actually deleted.
@node Switches for gnatclean,,Running gnatclean,The File Cleanup Utility gnatclean
-@anchor{gnat_ugn/gnat_utility_programs id4}@anchor{1d1}@anchor{gnat_ugn/gnat_utility_programs switches-for-gnatclean}@anchor{1d2}
+@anchor{gnat_ugn/gnat_utility_programs id4}@anchor{1d4}@anchor{gnat_ugn/gnat_utility_programs switches-for-gnatclean}@anchor{1d5}
@subsection Switches for @cite{gnatclean}
@item @code{-vP@emph{x}}
Indicates the verbosity of the parsing of GNAT project files.
-@ref{e3,,Switches Related to Project Files}.
+@ref{e6,,Switches Related to Project Files}.
@end table
@geindex -X (gnatclean)
Indicates that external variable @cite{name} has the value @cite{value}.
The Project Manager will use this value for occurrences of
@cite{external(name)} when parsing the project file.
-@ref{e3,,Switches Related to Project Files}.
+@ref{e6,,Switches Related to Project Files}.
@end table
@geindex -aO (gnatclean)
@end table
@node The GNAT Library Browser gnatls,The Cross-Referencing Tools gnatxref and gnatfind,The File Cleanup Utility gnatclean,GNAT Utility Programs
-@anchor{gnat_ugn/gnat_utility_programs the-gnat-library-browser-gnatls}@anchor{23}@anchor{gnat_ugn/gnat_utility_programs id5}@anchor{1d3}
+@anchor{gnat_ugn/gnat_utility_programs the-gnat-library-browser-gnatls}@anchor{23}@anchor{gnat_ugn/gnat_utility_programs id5}@anchor{1d6}
@section The GNAT Library Browser @cite{gnatls}
as well as various characteristics.
Note: to invoke @cite{gnatls} with a project file, use the @cite{gnat}
-driver (see @ref{11f,,The GNAT Driver and Project Files}).
+driver (see @ref{122,,The GNAT Driver and Project Files}).
@menu
* Running gnatls::
@end menu
@node Running gnatls,Switches for gnatls,,The GNAT Library Browser gnatls
-@anchor{gnat_ugn/gnat_utility_programs id6}@anchor{1d4}@anchor{gnat_ugn/gnat_utility_programs running-gnatls}@anchor{1d5}
+@anchor{gnat_ugn/gnat_utility_programs id6}@anchor{1d7}@anchor{gnat_ugn/gnat_utility_programs running-gnatls}@anchor{1d8}
@subsection Running @cite{gnatls}
@end table
@node Switches for gnatls,Example of gnatls Usage,Running gnatls,The GNAT Library Browser gnatls
-@anchor{gnat_ugn/gnat_utility_programs id7}@anchor{1d6}@anchor{gnat_ugn/gnat_utility_programs switches-for-gnatls}@anchor{1d7}
+@anchor{gnat_ugn/gnat_utility_programs id7}@anchor{1d9}@anchor{gnat_ugn/gnat_utility_programs switches-for-gnatls}@anchor{1da}
@subsection Switches for @cite{gnatls}
@item @code{-aO@emph{dir}}, @code{-aI@emph{dir}}, @code{-I@emph{dir}}, @code{-I-}, @code{-nostdinc}
Source path manipulation. Same meaning as the equivalent @emph{gnatmake}
-flags (@ref{df,,Switches for gnatmake}).
+flags (@ref{e2,,Switches for gnatmake}).
@end table
@geindex -aP (gnatls)
@item @code{--RTS=@emph{rts-path}`}
Specifies the default location of the runtime library. Same meaning as the
-equivalent @emph{gnatmake} flag (@ref{df,,Switches for gnatmake}).
+equivalent @emph{gnatmake} flag (@ref{e2,,Switches for gnatmake}).
@end table
@geindex -v (gnatls)
@end table
@node Example of gnatls Usage,,Switches for gnatls,The GNAT Library Browser gnatls
-@anchor{gnat_ugn/gnat_utility_programs id8}@anchor{1d8}@anchor{gnat_ugn/gnat_utility_programs example-of-gnatls-usage}@anchor{1d9}
+@anchor{gnat_ugn/gnat_utility_programs id8}@anchor{1db}@anchor{gnat_ugn/gnat_utility_programs example-of-gnatls-usage}@anchor{1dc}
@subsection Example of @cite{gnatls} Usage
@end quotation
@node The Cross-Referencing Tools gnatxref and gnatfind,The Ada to HTML Converter gnathtml,The GNAT Library Browser gnatls,GNAT Utility Programs
-@anchor{gnat_ugn/gnat_utility_programs the-cross-referencing-tools-gnatxref-and-gnatfind}@anchor{24}@anchor{gnat_ugn/gnat_utility_programs id9}@anchor{1da}
+@anchor{gnat_ugn/gnat_utility_programs the-cross-referencing-tools-gnatxref-and-gnatfind}@anchor{24}@anchor{gnat_ugn/gnat_utility_programs id9}@anchor{1dd}
@section The Cross-Referencing Tools @cite{gnatxref} and @cite{gnatfind}
information will not be generated.
Note: to invoke @cite{gnatxref} or @cite{gnatfind} with a project file,
-use the @cite{gnat} driver (see @ref{11f,,The GNAT Driver and Project Files}).
+use the @cite{gnat} driver (see @ref{122,,The GNAT Driver and Project Files}).
@menu
* gnatxref Switches::
@end menu
@node gnatxref Switches,gnatfind Switches,,The Cross-Referencing Tools gnatxref and gnatfind
-@anchor{gnat_ugn/gnat_utility_programs id10}@anchor{1db}@anchor{gnat_ugn/gnat_utility_programs gnatxref-switches}@anchor{1dc}
+@anchor{gnat_ugn/gnat_utility_programs id10}@anchor{1de}@anchor{gnat_ugn/gnat_utility_programs gnatxref-switches}@anchor{1df}
@subsection @cite{gnatxref} Switches
@item @code{-RTS=@emph{rts-path}}
Specifies the default location of the runtime library. Same meaning as the
-equivalent @emph{gnatmake} flag (@ref{df,,Switches for gnatmake}).
+equivalent @emph{gnatmake} flag (@ref{e2,,Switches for gnatmake}).
@end table
@geindex -d (gnatxref)
Instead of producing the default output, @cite{gnatxref} will generate a
@code{tags} file that can be used by vi. For examples how to use this
-feature, see @ref{1dd,,Examples of gnatxref Usage}. The tags file is output
+feature, see @ref{1e0,,Examples of gnatxref Usage}. The tags file is output
to the standard output, thus you will have to redirect it to a file.
@end table
you can say @code{gnatxref -ag} instead of @code{gnatxref -a -g}.
@node gnatfind Switches,Project Files for gnatxref and gnatfind,gnatxref Switches,The Cross-Referencing Tools gnatxref and gnatfind
-@anchor{gnat_ugn/gnat_utility_programs id11}@anchor{1de}@anchor{gnat_ugn/gnat_utility_programs gnatfind-switches}@anchor{1df}
+@anchor{gnat_ugn/gnat_utility_programs id11}@anchor{1e1}@anchor{gnat_ugn/gnat_utility_programs gnatfind-switches}@anchor{1e2}
@subsection @cite{gnatfind} Switches
@item @emph{pattern}
An entity will be output only if it matches the regular expression found
-in @cite{pattern}, see @ref{1e0,,Regular Expressions in gnatfind and gnatxref}.
+in @cite{pattern}, see @ref{1e3,,Regular Expressions in gnatfind and gnatxref}.
Omitting the pattern is equivalent to specifying @code{*}, which
will match any entity. Note that if you do not provide a pattern, you
@cite{gnatfind} will look for references, bodies or declarations
of symbols referenced in @code{sourcefile}, at line @cite{line}
-and column @cite{column}. See @ref{1e1,,Examples of gnatfind Usage}
+and column @cite{column}. See @ref{1e4,,Examples of gnatfind Usage}
for syntax examples.
@item @emph{line}
@item @code{-RTS=@emph{rts-path}}
Specifies the default location of the runtime library. Same meaning as the
-equivalent @emph{gnatmake} flag (@ref{df,,Switches for gnatmake}).
+equivalent @emph{gnatmake} flag (@ref{e2,,Switches for gnatmake}).
@end table
@geindex -d (gnatfind)
you specify @cite{*} at the end of the command line.
@node Project Files for gnatxref and gnatfind,Regular Expressions in gnatfind and gnatxref,gnatfind Switches,The Cross-Referencing Tools gnatxref and gnatfind
-@anchor{gnat_ugn/gnat_utility_programs project-files-for-gnatxref-and-gnatfind}@anchor{1e2}@anchor{gnat_ugn/gnat_utility_programs id12}@anchor{1e3}
+@anchor{gnat_ugn/gnat_utility_programs project-files-for-gnatxref-and-gnatfind}@anchor{1e5}@anchor{gnat_ugn/gnat_utility_programs id12}@anchor{1e6}
@subsection Project Files for @emph{gnatxref} and @emph{gnatfind}
@cite{src_dir} and @cite{obj_dir} lines, and ignore the others.
@node Regular Expressions in gnatfind and gnatxref,Examples of gnatxref Usage,Project Files for gnatxref and gnatfind,The Cross-Referencing Tools gnatxref and gnatfind
-@anchor{gnat_ugn/gnat_utility_programs id13}@anchor{1e4}@anchor{gnat_ugn/gnat_utility_programs regular-expressions-in-gnatfind-and-gnatxref}@anchor{1e0}
+@anchor{gnat_ugn/gnat_utility_programs id13}@anchor{1e7}@anchor{gnat_ugn/gnat_utility_programs regular-expressions-in-gnatfind-and-gnatxref}@anchor{1e3}
@subsection Regular Expressions in @cite{gnatfind} and @cite{gnatxref}
@end itemize
@node Examples of gnatxref Usage,Examples of gnatfind Usage,Regular Expressions in gnatfind and gnatxref,The Cross-Referencing Tools gnatxref and gnatfind
-@anchor{gnat_ugn/gnat_utility_programs examples-of-gnatxref-usage}@anchor{1dd}@anchor{gnat_ugn/gnat_utility_programs id14}@anchor{1e5}
+@anchor{gnat_ugn/gnat_utility_programs examples-of-gnatxref-usage}@anchor{1e0}@anchor{gnat_ugn/gnat_utility_programs id14}@anchor{1e8}
@subsection Examples of @cite{gnatxref} Usage
@end menu
@node General Usage,Using gnatxref with vi,,Examples of gnatxref Usage
-@anchor{gnat_ugn/gnat_utility_programs general-usage}@anchor{1e6}
+@anchor{gnat_ugn/gnat_utility_programs general-usage}@anchor{1e9}
@subsubsection General Usage
@end quotation
@node Using gnatxref with vi,,General Usage,Examples of gnatxref Usage
-@anchor{gnat_ugn/gnat_utility_programs using-gnatxref-with-vi}@anchor{1e7}
+@anchor{gnat_ugn/gnat_utility_programs using-gnatxref-with-vi}@anchor{1ea}
@subsubsection Using gnatxref with vi
display a new file with the corresponding declaration of entity.
@node Examples of gnatfind Usage,,Examples of gnatxref Usage,The Cross-Referencing Tools gnatxref and gnatfind
-@anchor{gnat_ugn/gnat_utility_programs id15}@anchor{1e8}@anchor{gnat_ugn/gnat_utility_programs examples-of-gnatfind-usage}@anchor{1e1}
+@anchor{gnat_ugn/gnat_utility_programs id15}@anchor{1eb}@anchor{gnat_ugn/gnat_utility_programs examples-of-gnatfind-usage}@anchor{1e4}
@subsection Examples of @cite{gnatfind} Usage
@end itemize
@node The Ada to HTML Converter gnathtml,,The Cross-Referencing Tools gnatxref and gnatfind,GNAT Utility Programs
-@anchor{gnat_ugn/gnat_utility_programs the-ada-to-html-converter-gnathtml}@anchor{25}@anchor{gnat_ugn/gnat_utility_programs id16}@anchor{1e9}
+@anchor{gnat_ugn/gnat_utility_programs the-ada-to-html-converter-gnathtml}@anchor{25}@anchor{gnat_ugn/gnat_utility_programs id16}@anchor{1ec}
@section The Ada to HTML Converter @cite{gnathtml}
@geindex gnathtml
@emph{gnathtml} is a Perl script that allows Ada source files to be browsed using
-standard Web browsers. For installation information, see @ref{1ea,,Installing gnathtml}.
+standard Web browsers. For installation information, see @ref{1ed,,Installing gnathtml}.
Ada reserved keywords are highlighted in a bold font and Ada comments in
a blue font. Unless your program was compiled with the gcc @emph{-gnatx}
@end menu
@node Invoking gnathtml,Installing gnathtml,,The Ada to HTML Converter gnathtml
-@anchor{gnat_ugn/gnat_utility_programs invoking-gnathtml}@anchor{1eb}@anchor{gnat_ugn/gnat_utility_programs id17}@anchor{1ec}
+@anchor{gnat_ugn/gnat_utility_programs invoking-gnathtml}@anchor{1ee}@anchor{gnat_ugn/gnat_utility_programs id17}@anchor{1ef}
@subsection Invoking @emph{gnathtml}
@end table
@node Installing gnathtml,,Invoking gnathtml,The Ada to HTML Converter gnathtml
-@anchor{gnat_ugn/gnat_utility_programs installing-gnathtml}@anchor{1ea}@anchor{gnat_ugn/gnat_utility_programs id18}@anchor{1ed}
+@anchor{gnat_ugn/gnat_utility_programs installing-gnathtml}@anchor{1ed}@anchor{gnat_ugn/gnat_utility_programs id18}@anchor{1f0}
@subsection Installing @cite{gnathtml}
@c -- Example: A |withing| unit has a |with| clause, it |withs| a |withed| unit
@node GNAT and Program Execution,Platform-Specific Information,GNAT Utility Programs,Top
-@anchor{gnat_ugn/gnat_and_program_execution gnat-and-program-execution}@anchor{e}@anchor{gnat_ugn/gnat_and_program_execution doc}@anchor{1ee}@anchor{gnat_ugn/gnat_and_program_execution id1}@anchor{1ef}
+@anchor{gnat_ugn/gnat_and_program_execution gnat-and-program-execution}@anchor{e}@anchor{gnat_ugn/gnat_and_program_execution doc}@anchor{1f1}@anchor{gnat_ugn/gnat_and_program_execution id1}@anchor{1f2}
@chapter GNAT and Program Execution
@itemize *
@item
-@ref{1f0,,Running and Debugging Ada Programs}
+@ref{1f3,,Running and Debugging Ada Programs}
@item
-@ref{1f1,,Code Coverage and Profiling}
+@ref{1f4,,Code Coverage and Profiling}
@item
-@ref{1f2,,Improving Performance}
+@ref{1f5,,Improving Performance}
@item
-@ref{1f3,,Overflow Check Handling in GNAT}
+@ref{1f6,,Overflow Check Handling in GNAT}
@item
-@ref{1f4,,Performing Dimensionality Analysis in GNAT}
+@ref{1f7,,Performing Dimensionality Analysis in GNAT}
@item
-@ref{1f5,,Stack Related Facilities}
+@ref{1f8,,Stack Related Facilities}
@item
-@ref{1f6,,Memory Management Issues}
+@ref{1f9,,Memory Management Issues}
@end itemize
@menu
@end menu
@node Running and Debugging Ada Programs,Code Coverage and Profiling,,GNAT and Program Execution
-@anchor{gnat_ugn/gnat_and_program_execution id2}@anchor{1f0}@anchor{gnat_ugn/gnat_and_program_execution running-and-debugging-ada-programs}@anchor{26}
+@anchor{gnat_ugn/gnat_and_program_execution id2}@anchor{1f3}@anchor{gnat_ugn/gnat_and_program_execution running-and-debugging-ada-programs}@anchor{26}
@section Running and Debugging Ada Programs
@end menu
@node The GNAT Debugger GDB,Running GDB,,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution the-gnat-debugger-gdb}@anchor{1f7}@anchor{gnat_ugn/gnat_and_program_execution id3}@anchor{1f8}
+@anchor{gnat_ugn/gnat_and_program_execution the-gnat-debugger-gdb}@anchor{1fa}@anchor{gnat_ugn/gnat_and_program_execution id3}@anchor{1fb}
@subsection The GNAT Debugger GDB
variables, and more generally to report on the state of execution.
@node Running GDB,Introduction to GDB Commands,The GNAT Debugger GDB,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution id4}@anchor{1f9}@anchor{gnat_ugn/gnat_and_program_execution running-gdb}@anchor{1fa}
+@anchor{gnat_ugn/gnat_and_program_execution id4}@anchor{1fc}@anchor{gnat_ugn/gnat_and_program_execution running-gdb}@anchor{1fd}
@subsection Running GDB
describes some of the additional commands that can be given to @cite{GDB}.
@node Introduction to GDB Commands,Using Ada Expressions,Running GDB,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution introduction-to-gdb-commands}@anchor{1fb}@anchor{gnat_ugn/gnat_and_program_execution id5}@anchor{1fc}
+@anchor{gnat_ugn/gnat_and_program_execution introduction-to-gdb-commands}@anchor{1fe}@anchor{gnat_ugn/gnat_and_program_execution id5}@anchor{1ff}
@subsection Introduction to GDB Commands
(for example, c for continue, bt for backtrace).
@node Using Ada Expressions,Calling User-Defined Subprograms,Introduction to GDB Commands,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution id6}@anchor{1fd}@anchor{gnat_ugn/gnat_and_program_execution using-ada-expressions}@anchor{1fe}
+@anchor{gnat_ugn/gnat_and_program_execution id6}@anchor{200}@anchor{gnat_ugn/gnat_and_program_execution using-ada-expressions}@anchor{201}
@subsection Using Ada Expressions
For details on the supported Ada syntax, see @cite{Debugging with GDB}.
@node Calling User-Defined Subprograms,Using the next Command in a Function,Using Ada Expressions,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution id7}@anchor{1ff}@anchor{gnat_ugn/gnat_and_program_execution calling-user-defined-subprograms}@anchor{200}
+@anchor{gnat_ugn/gnat_and_program_execution id7}@anchor{202}@anchor{gnat_ugn/gnat_and_program_execution calling-user-defined-subprograms}@anchor{203}
@subsection Calling User-Defined Subprograms
the elements in the desired format.
@node Using the next Command in a Function,Stopping When Ada Exceptions Are Raised,Calling User-Defined Subprograms,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution using-the-next-command-in-a-function}@anchor{201}@anchor{gnat_ugn/gnat_and_program_execution id8}@anchor{202}
+@anchor{gnat_ugn/gnat_and_program_execution using-the-next-command-in-a-function}@anchor{204}@anchor{gnat_ugn/gnat_and_program_execution id8}@anchor{205}
@subsection Using the @emph{next} Command in a Function
that was stepped through.
@node Stopping When Ada Exceptions Are Raised,Ada Tasks,Using the next Command in a Function,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution stopping-when-ada-exceptions-are-raised}@anchor{203}@anchor{gnat_ugn/gnat_and_program_execution id9}@anchor{204}
+@anchor{gnat_ugn/gnat_and_program_execution stopping-when-ada-exceptions-are-raised}@anchor{206}@anchor{gnat_ugn/gnat_and_program_execution id9}@anchor{207}
@subsection Stopping When Ada Exceptions Are Raised
@geindex Tasks (in gdb)
@node Ada Tasks,Debugging Generic Units,Stopping When Ada Exceptions Are Raised,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution ada-tasks}@anchor{205}@anchor{gnat_ugn/gnat_and_program_execution id10}@anchor{206}
+@anchor{gnat_ugn/gnat_and_program_execution ada-tasks}@anchor{208}@anchor{gnat_ugn/gnat_and_program_execution id10}@anchor{209}
@subsection Ada Tasks
@geindex Generics
@node Debugging Generic Units,Remote Debugging with gdbserver,Ada Tasks,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution debugging-generic-units}@anchor{207}@anchor{gnat_ugn/gnat_and_program_execution id11}@anchor{208}
+@anchor{gnat_ugn/gnat_and_program_execution debugging-generic-units}@anchor{20a}@anchor{gnat_ugn/gnat_and_program_execution id11}@anchor{20b}
@subsection Debugging Generic Units
@geindex Remote Debugging with gdbserver
@node Remote Debugging with gdbserver,GNAT Abnormal Termination or Failure to Terminate,Debugging Generic Units,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution remote-debugging-with-gdbserver}@anchor{209}@anchor{gnat_ugn/gnat_and_program_execution id12}@anchor{20a}
+@anchor{gnat_ugn/gnat_and_program_execution remote-debugging-with-gdbserver}@anchor{20c}@anchor{gnat_ugn/gnat_and_program_execution id12}@anchor{20d}
@subsection Remote Debugging with gdbserver
@geindex Abnormal Termination or Failure to Terminate
@node GNAT Abnormal Termination or Failure to Terminate,Naming Conventions for GNAT Source Files,Remote Debugging with gdbserver,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution gnat-abnormal-termination-or-failure-to-terminate}@anchor{20b}@anchor{gnat_ugn/gnat_and_program_execution id13}@anchor{20c}
+@anchor{gnat_ugn/gnat_and_program_execution gnat-abnormal-termination-or-failure-to-terminate}@anchor{20e}@anchor{gnat_ugn/gnat_and_program_execution id13}@anchor{20f}
@subsection GNAT Abnormal Termination or Failure to Terminate
@cite{gdb} directly on the @cite{gnat1} executable. @cite{gnat1} is the
front-end of GNAT, and can be run independently (normally it is just
called from @emph{gcc}). You can use @cite{gdb} on @cite{gnat1} as you
-would on a C program (but @ref{1f7,,The GNAT Debugger GDB} for caveats). The
+would on a C program (but @ref{1fa,,The GNAT Debugger GDB} for caveats). The
@cite{where} command is the first line of attack; the variable
@cite{lineno} (seen by @cite{print lineno}), used by the second phase of
@cite{gnat1} and by the @emph{gcc} backend, indicates the source line at
@end itemize
@node Naming Conventions for GNAT Source Files,Getting Internal Debugging Information,GNAT Abnormal Termination or Failure to Terminate,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution naming-conventions-for-gnat-source-files}@anchor{20d}@anchor{gnat_ugn/gnat_and_program_execution id14}@anchor{20e}
+@anchor{gnat_ugn/gnat_and_program_execution naming-conventions-for-gnat-source-files}@anchor{210}@anchor{gnat_ugn/gnat_and_program_execution id14}@anchor{211}
@subsection Naming Conventions for GNAT Source Files
@end itemize
@node Getting Internal Debugging Information,Stack Traceback,Naming Conventions for GNAT Source Files,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution id15}@anchor{20f}@anchor{gnat_ugn/gnat_and_program_execution getting-internal-debugging-information}@anchor{210}
+@anchor{gnat_ugn/gnat_and_program_execution id15}@anchor{212}@anchor{gnat_ugn/gnat_and_program_execution getting-internal-debugging-information}@anchor{213}
@subsection Getting Internal Debugging Information
@geindex stack unwinding
@node Stack Traceback,,Getting Internal Debugging Information,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution stack-traceback}@anchor{211}@anchor{gnat_ugn/gnat_and_program_execution id16}@anchor{212}
+@anchor{gnat_ugn/gnat_and_program_execution stack-traceback}@anchor{214}@anchor{gnat_ugn/gnat_and_program_execution id16}@anchor{215}
@subsection Stack Traceback
@end menu
@node Non-Symbolic Traceback,Symbolic Traceback,,Stack Traceback
-@anchor{gnat_ugn/gnat_and_program_execution non-symbolic-traceback}@anchor{213}@anchor{gnat_ugn/gnat_and_program_execution id17}@anchor{214}
+@anchor{gnat_ugn/gnat_and_program_execution non-symbolic-traceback}@anchor{216}@anchor{gnat_ugn/gnat_and_program_execution id17}@anchor{217}
@subsubsection Non-Symbolic Traceback
@code{stb.adb} at line 5, which was reached from a procedure call in
@code{stb.adb} at line 10, and so on. The @code{b~std.adb} is the binder file,
which contains the call to the main program.
-@ref{120,,Running gnatbind}. The remaining entries are assorted runtime routines,
+@ref{123,,Running gnatbind}. The remaining entries are assorted runtime routines,
and the output will vary from platform to platform.
It is also possible to use @cite{GDB} with these traceback addresses to debug
@geindex symbolic
@node Symbolic Traceback,,Non-Symbolic Traceback,Stack Traceback
-@anchor{gnat_ugn/gnat_and_program_execution id18}@anchor{215}@anchor{gnat_ugn/gnat_and_program_execution symbolic-traceback}@anchor{216}
+@anchor{gnat_ugn/gnat_and_program_execution id18}@anchor{218}@anchor{gnat_ugn/gnat_and_program_execution symbolic-traceback}@anchor{219}
@subsubsection Symbolic Traceback
@geindex Profiling
@node Code Coverage and Profiling,Improving Performance,Running and Debugging Ada Programs,GNAT and Program Execution
-@anchor{gnat_ugn/gnat_and_program_execution id19}@anchor{1f1}@anchor{gnat_ugn/gnat_and_program_execution code-coverage-and-profiling}@anchor{27}
+@anchor{gnat_ugn/gnat_and_program_execution id19}@anchor{1f4}@anchor{gnat_ugn/gnat_and_program_execution code-coverage-and-profiling}@anchor{27}
@section Code Coverage and Profiling
@end menu
@node Code Coverage of Ada Programs with gcov,Profiling an Ada Program with gprof,,Code Coverage and Profiling
-@anchor{gnat_ugn/gnat_and_program_execution id20}@anchor{217}@anchor{gnat_ugn/gnat_and_program_execution code-coverage-of-ada-programs-with-gcov}@anchor{218}
+@anchor{gnat_ugn/gnat_and_program_execution id20}@anchor{21a}@anchor{gnat_ugn/gnat_and_program_execution code-coverage-of-ada-programs-with-gcov}@anchor{21b}
@subsection Code Coverage of Ada Programs with gcov
@end menu
@node Quick startup guide,GNAT specifics,,Code Coverage of Ada Programs with gcov
-@anchor{gnat_ugn/gnat_and_program_execution id21}@anchor{219}@anchor{gnat_ugn/gnat_and_program_execution quick-startup-guide}@anchor{21a}
+@anchor{gnat_ugn/gnat_and_program_execution id21}@anchor{21c}@anchor{gnat_ugn/gnat_and_program_execution quick-startup-guide}@anchor{21d}
@subsubsection Quick startup guide
@code{my_main.adb} file will be analyzed in @code{my_main.adb.gcov}.
@node GNAT specifics,,Quick startup guide,Code Coverage of Ada Programs with gcov
-@anchor{gnat_ugn/gnat_and_program_execution gnat-specifics}@anchor{21b}@anchor{gnat_ugn/gnat_and_program_execution id22}@anchor{21c}
+@anchor{gnat_ugn/gnat_and_program_execution gnat-specifics}@anchor{21e}@anchor{gnat_ugn/gnat_and_program_execution id22}@anchor{21f}
@subsubsection GNAT specifics
@geindex Profiling
@node Profiling an Ada Program with gprof,,Code Coverage of Ada Programs with gcov,Code Coverage and Profiling
-@anchor{gnat_ugn/gnat_and_program_execution profiling-an-ada-program-with-gprof}@anchor{21d}@anchor{gnat_ugn/gnat_and_program_execution id23}@anchor{21e}
+@anchor{gnat_ugn/gnat_and_program_execution profiling-an-ada-program-with-gprof}@anchor{220}@anchor{gnat_ugn/gnat_and_program_execution id23}@anchor{221}
@subsection Profiling an Ada Program with gprof
@end menu
@node Compilation for profiling,Program execution,,Profiling an Ada Program with gprof
-@anchor{gnat_ugn/gnat_and_program_execution id24}@anchor{21f}@anchor{gnat_ugn/gnat_and_program_execution compilation-for-profiling}@anchor{220}
+@anchor{gnat_ugn/gnat_and_program_execution id24}@anchor{222}@anchor{gnat_ugn/gnat_and_program_execution compilation-for-profiling}@anchor{223}
@subsubsection Compilation for profiling
gnatmake switch to force full recompilation.
@node Program execution,Running gprof,Compilation for profiling,Profiling an Ada Program with gprof
-@anchor{gnat_ugn/gnat_and_program_execution program-execution}@anchor{221}@anchor{gnat_ugn/gnat_and_program_execution id25}@anchor{222}
+@anchor{gnat_ugn/gnat_and_program_execution program-execution}@anchor{224}@anchor{gnat_ugn/gnat_and_program_execution id25}@anchor{225}
@subsubsection Program execution
already exists, it will be overwritten.
@node Running gprof,Interpretation of profiling results,Program execution,Profiling an Ada Program with gprof
-@anchor{gnat_ugn/gnat_and_program_execution running-gprof}@anchor{223}@anchor{gnat_ugn/gnat_and_program_execution id26}@anchor{224}
+@anchor{gnat_ugn/gnat_and_program_execution running-gprof}@anchor{226}@anchor{gnat_ugn/gnat_and_program_execution id26}@anchor{227}
@subsubsection Running gprof
@end table
@node Interpretation of profiling results,,Running gprof,Profiling an Ada Program with gprof
-@anchor{gnat_ugn/gnat_and_program_execution id27}@anchor{225}@anchor{gnat_ugn/gnat_and_program_execution interpretation-of-profiling-results}@anchor{226}
+@anchor{gnat_ugn/gnat_and_program_execution id27}@anchor{228}@anchor{gnat_ugn/gnat_and_program_execution interpretation-of-profiling-results}@anchor{229}
@subsubsection Interpretation of profiling results
spent in each of those callers/called subprograms.
@node Improving Performance,Overflow Check Handling in GNAT,Code Coverage and Profiling,GNAT and Program Execution
-@anchor{gnat_ugn/gnat_and_program_execution improving-performance}@anchor{28}@anchor{gnat_ugn/gnat_and_program_execution id28}@anchor{1f2}
+@anchor{gnat_ugn/gnat_and_program_execution improving-performance}@anchor{28}@anchor{gnat_ugn/gnat_and_program_execution id28}@anchor{1f5}
@section Improving Performance
@end menu
@node Performance Considerations,Text_IO Suggestions,,Improving Performance
-@anchor{gnat_ugn/gnat_and_program_execution id29}@anchor{227}@anchor{gnat_ugn/gnat_and_program_execution performance-considerations}@anchor{228}
+@anchor{gnat_ugn/gnat_and_program_execution id29}@anchor{22a}@anchor{gnat_ugn/gnat_and_program_execution performance-considerations}@anchor{22b}
@subsection Performance Considerations
@end menu
@node Controlling Run-Time Checks,Use of Restrictions,,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution controlling-run-time-checks}@anchor{229}@anchor{gnat_ugn/gnat_and_program_execution id30}@anchor{22a}
+@anchor{gnat_ugn/gnat_and_program_execution controlling-run-time-checks}@anchor{22c}@anchor{gnat_ugn/gnat_and_program_execution id30}@anchor{22d}
@subsubsection Controlling Run-Time Checks
@geindex -gnato (gcc)
The gnat switch, @emph{-gnatp} allows this default to be modified. See
-@ref{fe,,Run-Time Checks}.
+@ref{101,,Run-Time Checks}.
Our experience is that the default is suitable for most development
purposes.
checks) in the program source.
@node Use of Restrictions,Optimization Levels,Controlling Run-Time Checks,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution use-of-restrictions}@anchor{22b}@anchor{gnat_ugn/gnat_and_program_execution id31}@anchor{22c}
+@anchor{gnat_ugn/gnat_and_program_execution use-of-restrictions}@anchor{22e}@anchor{gnat_ugn/gnat_and_program_execution id31}@anchor{22f}
@subsubsection Use of Restrictions
possibility of an immediate abort at any point.
@node Optimization Levels,Debugging Optimized Code,Use of Restrictions,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution id32}@anchor{22d}@anchor{gnat_ugn/gnat_and_program_execution optimization-levels}@anchor{101}
+@anchor{gnat_ugn/gnat_and_program_execution id32}@anchor{230}@anchor{gnat_ugn/gnat_and_program_execution optimization-levels}@anchor{104}
@subsubsection Optimization Levels
Full optimization as in @emph{-O2};
also uses more aggressive automatic inlining of subprograms within a unit
-(@ref{114,,Inlining of Subprograms}) and attempts to vectorize loops.
+(@ref{117,,Inlining of Subprograms}) and attempts to vectorize loops.
@end table
@item
Note regarding the use of @emph{-O3}: The use of this optimization level
is generally discouraged with GNAT, since it often results in larger
executables which may run more slowly. See further discussion of this point
-in @ref{114,,Inlining of Subprograms}.
+in @ref{117,,Inlining of Subprograms}.
@node Debugging Optimized Code,Inlining of Subprograms,Optimization Levels,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution id33}@anchor{22e}@anchor{gnat_ugn/gnat_and_program_execution debugging-optimized-code}@anchor{22f}
+@anchor{gnat_ugn/gnat_and_program_execution id33}@anchor{231}@anchor{gnat_ugn/gnat_and_program_execution debugging-optimized-code}@anchor{232}
@subsubsection Debugging Optimized Code
which removes both debugging information and global symbols.
@node Inlining of Subprograms,Floating_Point_Operations,Debugging Optimized Code,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution id34}@anchor{230}@anchor{gnat_ugn/gnat_and_program_execution inlining-of-subprograms}@anchor{114}
+@anchor{gnat_ugn/gnat_and_program_execution id34}@anchor{233}@anchor{gnat_ugn/gnat_and_program_execution inlining-of-subprograms}@anchor{117}
@subsubsection Inlining of Subprograms
improves performance for your program.
@node Floating_Point_Operations,Vectorization of loops,Inlining of Subprograms,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution floating-point-operations}@anchor{231}@anchor{gnat_ugn/gnat_and_program_execution id35}@anchor{232}
+@anchor{gnat_ugn/gnat_and_program_execution floating-point-operations}@anchor{234}@anchor{gnat_ugn/gnat_and_program_execution id35}@anchor{235}
@subsubsection Floating_Point_Operations
switches.
@node Vectorization of loops,Other Optimization Switches,Floating_Point_Operations,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution id36}@anchor{233}@anchor{gnat_ugn/gnat_and_program_execution vectorization-of-loops}@anchor{234}
+@anchor{gnat_ugn/gnat_and_program_execution id36}@anchor{236}@anchor{gnat_ugn/gnat_and_program_execution vectorization-of-loops}@anchor{237}
@subsubsection Vectorization of loops
omit the non-vectorized version of the loop as well as the run-time test.
@node Other Optimization Switches,Optimization and Strict Aliasing,Vectorization of loops,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution id37}@anchor{235}@anchor{gnat_ugn/gnat_and_program_execution other-optimization-switches}@anchor{236}
+@anchor{gnat_ugn/gnat_and_program_execution id37}@anchor{238}@anchor{gnat_ugn/gnat_and_program_execution other-optimization-switches}@anchor{239}
@subsubsection Other Optimization Switches
chapter of @cite{Using the GNU Compiler Collection (GCC)}.
@node Optimization and Strict Aliasing,Aliased Variables and Optimization,Other Optimization Switches,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution optimization-and-strict-aliasing}@anchor{f8}@anchor{gnat_ugn/gnat_and_program_execution id38}@anchor{237}
+@anchor{gnat_ugn/gnat_and_program_execution optimization-and-strict-aliasing}@anchor{fb}@anchor{gnat_ugn/gnat_and_program_execution id38}@anchor{23a}
@subsubsection Optimization and Strict Aliasing
particularly if you are getting the warnings described above.
@node Aliased Variables and Optimization,Atomic Variables and Optimization,Optimization and Strict Aliasing,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution aliased-variables-and-optimization}@anchor{238}@anchor{gnat_ugn/gnat_and_program_execution id39}@anchor{239}
+@anchor{gnat_ugn/gnat_and_program_execution aliased-variables-and-optimization}@anchor{23b}@anchor{gnat_ugn/gnat_and_program_execution id39}@anchor{23c}
@subsubsection Aliased Variables and Optimization
that is, it will produce the expected results.
@node Atomic Variables and Optimization,Passive Task Optimization,Aliased Variables and Optimization,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution atomic-variables-and-optimization}@anchor{23a}@anchor{gnat_ugn/gnat_and_program_execution id40}@anchor{23b}
+@anchor{gnat_ugn/gnat_and_program_execution atomic-variables-and-optimization}@anchor{23d}@anchor{gnat_ugn/gnat_and_program_execution id40}@anchor{23e}
@subsubsection Atomic Variables and Optimization
useful to disable it.
@node Passive Task Optimization,,Atomic Variables and Optimization,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution id41}@anchor{23c}@anchor{gnat_ugn/gnat_and_program_execution passive-task-optimization}@anchor{23d}
+@anchor{gnat_ugn/gnat_and_program_execution id41}@anchor{23f}@anchor{gnat_ugn/gnat_and_program_execution passive-task-optimization}@anchor{240}
@subsubsection Passive Task Optimization
to be modified, only the task definition itself.
@node Text_IO Suggestions,Reducing Size of Executables with Unused Subprogram/Data Elimination,Performance Considerations,Improving Performance
-@anchor{gnat_ugn/gnat_and_program_execution text-io-suggestions}@anchor{23e}@anchor{gnat_ugn/gnat_and_program_execution id42}@anchor{23f}
+@anchor{gnat_ugn/gnat_and_program_execution text-io-suggestions}@anchor{241}@anchor{gnat_ugn/gnat_and_program_execution id42}@anchor{242}
@subsection @cite{Text_IO} Suggestions
be buffered using @cite{Interfaces.C_Streams.setvbuf}.
@node Reducing Size of Executables with Unused Subprogram/Data Elimination,,Text_IO Suggestions,Improving Performance
-@anchor{gnat_ugn/gnat_and_program_execution id43}@anchor{240}@anchor{gnat_ugn/gnat_and_program_execution reducing-size-of-executables-with-unused-subprogram-data-elimination}@anchor{241}
+@anchor{gnat_ugn/gnat_and_program_execution id43}@anchor{243}@anchor{gnat_ugn/gnat_and_program_execution reducing-size-of-executables-with-unused-subprogram-data-elimination}@anchor{244}
@subsection Reducing Size of Executables with Unused Subprogram/Data Elimination
@end menu
@node About unused subprogram/data elimination,Compilation options,,Reducing Size of Executables with Unused Subprogram/Data Elimination
-@anchor{gnat_ugn/gnat_and_program_execution id44}@anchor{242}@anchor{gnat_ugn/gnat_and_program_execution about-unused-subprogram-data-elimination}@anchor{243}
+@anchor{gnat_ugn/gnat_and_program_execution id44}@anchor{245}@anchor{gnat_ugn/gnat_and_program_execution about-unused-subprogram-data-elimination}@anchor{246}
@subsubsection About unused subprogram/data elimination
In both cases GNU binutils version 2.16 or later are required to enable it.
@node Compilation options,Example of unused subprogram/data elimination,About unused subprogram/data elimination,Reducing Size of Executables with Unused Subprogram/Data Elimination
-@anchor{gnat_ugn/gnat_and_program_execution id45}@anchor{244}@anchor{gnat_ugn/gnat_and_program_execution compilation-options}@anchor{245}
+@anchor{gnat_ugn/gnat_and_program_execution id45}@anchor{247}@anchor{gnat_ugn/gnat_and_program_execution compilation-options}@anchor{248}
@subsubsection Compilation options
and data of the GNAT library from your executable.
@node Example of unused subprogram/data elimination,,Compilation options,Reducing Size of Executables with Unused Subprogram/Data Elimination
-@anchor{gnat_ugn/gnat_and_program_execution id46}@anchor{246}@anchor{gnat_ugn/gnat_and_program_execution example-of-unused-subprogram-data-elimination}@anchor{247}
+@anchor{gnat_ugn/gnat_and_program_execution id46}@anchor{249}@anchor{gnat_ugn/gnat_and_program_execution example-of-unused-subprogram-data-elimination}@anchor{24a}
@subsubsection Example of unused subprogram/data elimination
@node Overflow Check Handling in GNAT,Performing Dimensionality Analysis in GNAT,Improving Performance,GNAT and Program Execution
-@anchor{gnat_ugn/gnat_and_program_execution id54}@anchor{1f3}@anchor{gnat_ugn/gnat_and_program_execution overflow-check-handling-in-gnat}@anchor{29}
+@anchor{gnat_ugn/gnat_and_program_execution id54}@anchor{1f6}@anchor{gnat_ugn/gnat_and_program_execution overflow-check-handling-in-gnat}@anchor{29}
@section Overflow Check Handling in GNAT
@menu
* Background::
-* Overflow Checking Modes in GNAT::
+* Management of Overflows in GNAT::
* Specifying the Desired Mode::
* Default Settings::
* Implementation Notes::
@end menu
-@node Background,Overflow Checking Modes in GNAT,,Overflow Check Handling in GNAT
-@anchor{gnat_ugn/gnat_and_program_execution id55}@anchor{248}@anchor{gnat_ugn/gnat_and_program_execution background}@anchor{249}
+@node Background,Management of Overflows in GNAT,,Overflow Check Handling in GNAT
+@anchor{gnat_ugn/gnat_and_program_execution id55}@anchor{24b}@anchor{gnat_ugn/gnat_and_program_execution background}@anchor{24c}
@subsection Background
exception raised because of the intermediate overflow (and we really
would prefer this precondition to be considered True at run time).
-@node Overflow Checking Modes in GNAT,Specifying the Desired Mode,Background,Overflow Check Handling in GNAT
-@anchor{gnat_ugn/gnat_and_program_execution id56}@anchor{24a}@anchor{gnat_ugn/gnat_and_program_execution overflow-checking-modes-in-gnat}@anchor{24b}
-@subsection Overflow Checking Modes in GNAT
+@node Management of Overflows in GNAT,Specifying the Desired Mode,Background,Overflow Check Handling in GNAT
+@anchor{gnat_ugn/gnat_and_program_execution id56}@anchor{24d}@anchor{gnat_ugn/gnat_and_program_execution management-of-overflows-in-gnat}@anchor{24e}
+@subsection Management of Overflows in GNAT
To deal with the portability issue, and with the problem of
out in the normal manner (with infinite values always failing all
range checks).
-@node Specifying the Desired Mode,Default Settings,Overflow Checking Modes in GNAT,Overflow Check Handling in GNAT
-@anchor{gnat_ugn/gnat_and_program_execution specifying-the-desired-mode}@anchor{fd}@anchor{gnat_ugn/gnat_and_program_execution id57}@anchor{24c}
+@node Specifying the Desired Mode,Default Settings,Management of Overflows in GNAT,Overflow Check Handling in GNAT
+@anchor{gnat_ugn/gnat_and_program_execution specifying-the-desired-mode}@anchor{100}@anchor{gnat_ugn/gnat_and_program_execution id57}@anchor{24f}
@subsection Specifying the Desired Mode
type (@cite{STRICT} mode).
@node Default Settings,Implementation Notes,Specifying the Desired Mode,Overflow Check Handling in GNAT
-@anchor{gnat_ugn/gnat_and_program_execution id58}@anchor{24d}@anchor{gnat_ugn/gnat_and_program_execution default-settings}@anchor{24e}
+@anchor{gnat_ugn/gnat_and_program_execution id58}@anchor{250}@anchor{gnat_ugn/gnat_and_program_execution default-settings}@anchor{251}
@subsection Default Settings
@end quotation
which causes all computations both inside and outside assertions to use
-the base type. In addition overflow checks are suppressed.
+the base type.
This retains compatibility with previous versions of
GNAT which suppressed overflow checks by default and always
which causes overflow checking of all intermediate overflows
both inside and outside assertions against the base type.
-This provides compatibility
-with this switch as implemented in previous versions of GNAT.
The pragma @cite{Suppress (Overflow_Check)} disables overflow
checking, but it has no effect on the method used for computing
intermediate results.
@node Implementation Notes,,Default Settings,Overflow Check Handling in GNAT
-@anchor{gnat_ugn/gnat_and_program_execution implementation-notes}@anchor{24f}@anchor{gnat_ugn/gnat_and_program_execution id59}@anchor{250}
+@anchor{gnat_ugn/gnat_and_program_execution implementation-notes}@anchor{252}@anchor{gnat_ugn/gnat_and_program_execution id59}@anchor{253}
@subsection Implementation Notes
platforms).
@node Performing Dimensionality Analysis in GNAT,Stack Related Facilities,Overflow Check Handling in GNAT,GNAT and Program Execution
-@anchor{gnat_ugn/gnat_and_program_execution performing-dimensionality-analysis-in-gnat}@anchor{2a}@anchor{gnat_ugn/gnat_and_program_execution id60}@anchor{1f4}
+@anchor{gnat_ugn/gnat_and_program_execution performing-dimensionality-analysis-in-gnat}@anchor{2a}@anchor{gnat_ugn/gnat_and_program_execution id60}@anchor{1f7}
@section Performing Dimensionality Analysis in GNAT
@end quotation
@node Stack Related Facilities,Memory Management Issues,Performing Dimensionality Analysis in GNAT,GNAT and Program Execution
-@anchor{gnat_ugn/gnat_and_program_execution id61}@anchor{1f5}@anchor{gnat_ugn/gnat_and_program_execution stack-related-facilities}@anchor{2b}
+@anchor{gnat_ugn/gnat_and_program_execution id61}@anchor{1f8}@anchor{gnat_ugn/gnat_and_program_execution stack-related-facilities}@anchor{2b}
@section Stack Related Facilities
@end menu
@node Stack Overflow Checking,Static Stack Usage Analysis,,Stack Related Facilities
-@anchor{gnat_ugn/gnat_and_program_execution id62}@anchor{251}@anchor{gnat_ugn/gnat_and_program_execution stack-overflow-checking}@anchor{f9}
+@anchor{gnat_ugn/gnat_and_program_execution id62}@anchor{254}@anchor{gnat_ugn/gnat_and_program_execution stack-overflow-checking}@anchor{fc}
@subsection Stack Overflow Checking
For declared tasks, the stack size is controlled by the size
given in an applicable @cite{Storage_Size} pragma or by the value specified
-at bind time with @code{-d} (@ref{123,,Switches for gnatbind}) or is set to
+at bind time with @code{-d} (@ref{126,,Switches for gnatbind}) or is set to
the default size as defined in the GNAT runtime otherwise.
@geindex GNAT_STACK_LIMIT
appropriate operating systems commands.
@node Static Stack Usage Analysis,Dynamic Stack Usage Analysis,Stack Overflow Checking,Stack Related Facilities
-@anchor{gnat_ugn/gnat_and_program_execution static-stack-usage-analysis}@anchor{fa}@anchor{gnat_ugn/gnat_and_program_execution id63}@anchor{252}
+@anchor{gnat_ugn/gnat_and_program_execution static-stack-usage-analysis}@anchor{fd}@anchor{gnat_ugn/gnat_and_program_execution id63}@anchor{255}
@subsection Static Stack Usage Analysis
bytes. The wording is in keeping with the qualifier documented above.
@node Dynamic Stack Usage Analysis,,Static Stack Usage Analysis,Stack Related Facilities
-@anchor{gnat_ugn/gnat_and_program_execution id64}@anchor{253}@anchor{gnat_ugn/gnat_and_program_execution dynamic-stack-usage-analysis}@anchor{125}
+@anchor{gnat_ugn/gnat_and_program_execution id64}@anchor{256}@anchor{gnat_ugn/gnat_and_program_execution dynamic-stack-usage-analysis}@anchor{128}
@subsection Dynamic Stack Usage Analysis
stack usage reports at run-time. See its body for the details.
@node Memory Management Issues,,Stack Related Facilities,GNAT and Program Execution
-@anchor{gnat_ugn/gnat_and_program_execution id65}@anchor{1f6}@anchor{gnat_ugn/gnat_and_program_execution memory-management-issues}@anchor{2c}
+@anchor{gnat_ugn/gnat_and_program_execution id65}@anchor{1f9}@anchor{gnat_ugn/gnat_and_program_execution memory-management-issues}@anchor{2c}
@section Memory Management Issues
@end menu
@node Some Useful Memory Pools,The GNAT Debug Pool Facility,,Memory Management Issues
-@anchor{gnat_ugn/gnat_and_program_execution id66}@anchor{254}@anchor{gnat_ugn/gnat_and_program_execution some-useful-memory-pools}@anchor{255}
+@anchor{gnat_ugn/gnat_and_program_execution id66}@anchor{257}@anchor{gnat_ugn/gnat_and_program_execution some-useful-memory-pools}@anchor{258}
@subsection Some Useful Memory Pools
@end quotation
@node The GNAT Debug Pool Facility,,Some Useful Memory Pools,Memory Management Issues
-@anchor{gnat_ugn/gnat_and_program_execution id67}@anchor{256}@anchor{gnat_ugn/gnat_and_program_execution the-gnat-debug-pool-facility}@anchor{257}
+@anchor{gnat_ugn/gnat_and_program_execution id67}@anchor{259}@anchor{gnat_ugn/gnat_and_program_execution the-gnat-debug-pool-facility}@anchor{25a}
@subsection The GNAT Debug Pool Facility
@c -- E.g. Ada |nbsp| 95
@node Platform-Specific Information,Example of Binder Output File,GNAT and Program Execution,Top
-@anchor{gnat_ugn/platform_specific_information platform-specific-information}@anchor{f}@anchor{gnat_ugn/platform_specific_information doc}@anchor{258}@anchor{gnat_ugn/platform_specific_information id1}@anchor{259}
+@anchor{gnat_ugn/platform_specific_information platform-specific-information}@anchor{f}@anchor{gnat_ugn/platform_specific_information doc}@anchor{25b}@anchor{gnat_ugn/platform_specific_information id1}@anchor{25c}
@chapter Platform-Specific Information
@end menu
@node Run-Time Libraries,Specifying a Run-Time Library,,Platform-Specific Information
-@anchor{gnat_ugn/platform_specific_information id2}@anchor{25a}@anchor{gnat_ugn/platform_specific_information run-time-libraries}@anchor{2d}
+@anchor{gnat_ugn/platform_specific_information id2}@anchor{25d}@anchor{gnat_ugn/platform_specific_information run-time-libraries}@anchor{2d}
@section Run-Time Libraries
@end menu
@node Summary of Run-Time Configurations,,,Run-Time Libraries
-@anchor{gnat_ugn/platform_specific_information summary-of-run-time-configurations}@anchor{25b}@anchor{gnat_ugn/platform_specific_information id3}@anchor{25c}
+@anchor{gnat_ugn/platform_specific_information summary-of-run-time-configurations}@anchor{25e}@anchor{gnat_ugn/platform_specific_information id3}@anchor{25f}
@subsection Summary of Run-Time Configurations
@node Specifying a Run-Time Library,Microsoft Windows Topics,Run-Time Libraries,Platform-Specific Information
-@anchor{gnat_ugn/platform_specific_information specifying-a-run-time-library}@anchor{25d}@anchor{gnat_ugn/platform_specific_information id4}@anchor{25e}
+@anchor{gnat_ugn/platform_specific_information specifying-a-run-time-library}@anchor{260}@anchor{gnat_ugn/platform_specific_information id4}@anchor{261}
@section Specifying a Run-Time Library
Selecting another run-time library temporarily can be
achieved by using the @emph{--RTS} switch, e.g., @emph{--RTS=sjlj}
-@anchor{gnat_ugn/platform_specific_information choosing-the-scheduling-policy}@anchor{25f}
+@anchor{gnat_ugn/platform_specific_information choosing-the-scheduling-policy}@anchor{262}
@geindex SCHED_FIFO scheduling policy
@geindex SCHED_RR scheduling policy
@end menu
@node Choosing the Scheduling Policy,Solaris-Specific Considerations,,Specifying a Run-Time Library
-@anchor{gnat_ugn/platform_specific_information id5}@anchor{260}
+@anchor{gnat_ugn/platform_specific_information id5}@anchor{263}
@subsection Choosing the Scheduling Policy
@geindex Solaris Sparc threads libraries
@node Solaris-Specific Considerations,Solaris Threads Issues,Choosing the Scheduling Policy,Specifying a Run-Time Library
-@anchor{gnat_ugn/platform_specific_information id6}@anchor{261}@anchor{gnat_ugn/platform_specific_information solaris-specific-considerations}@anchor{262}
+@anchor{gnat_ugn/platform_specific_information id6}@anchor{264}@anchor{gnat_ugn/platform_specific_information solaris-specific-considerations}@anchor{265}
@subsection Solaris-Specific Considerations
@geindex rts-pthread threads library
@node Solaris Threads Issues,AIX-Specific Considerations,Solaris-Specific Considerations,Specifying a Run-Time Library
-@anchor{gnat_ugn/platform_specific_information id7}@anchor{263}@anchor{gnat_ugn/platform_specific_information solaris-threads-issues}@anchor{264}
+@anchor{gnat_ugn/platform_specific_information id7}@anchor{266}@anchor{gnat_ugn/platform_specific_information solaris-threads-issues}@anchor{267}
@subsection Solaris Threads Issues
@end quotation
@node AIX-Specific Considerations,,Solaris Threads Issues,Specifying a Run-Time Library
-@anchor{gnat_ugn/platform_specific_information aix-specific-considerations}@anchor{265}@anchor{gnat_ugn/platform_specific_information id8}@anchor{266}
+@anchor{gnat_ugn/platform_specific_information aix-specific-considerations}@anchor{268}@anchor{gnat_ugn/platform_specific_information id8}@anchor{269}
@subsection AIX-Specific Considerations
@geindex Windows 98
@node Microsoft Windows Topics,Mac OS Topics,Specifying a Run-Time Library,Platform-Specific Information
-@anchor{gnat_ugn/platform_specific_information microsoft-windows-topics}@anchor{2e}@anchor{gnat_ugn/platform_specific_information id9}@anchor{267}
+@anchor{gnat_ugn/platform_specific_information microsoft-windows-topics}@anchor{2e}@anchor{gnat_ugn/platform_specific_information id9}@anchor{26a}
@section Microsoft Windows Topics
@end menu
@node Using GNAT on Windows,Using a network installation of GNAT,,Microsoft Windows Topics
-@anchor{gnat_ugn/platform_specific_information using-gnat-on-windows}@anchor{268}@anchor{gnat_ugn/platform_specific_information id10}@anchor{269}
+@anchor{gnat_ugn/platform_specific_information using-gnat-on-windows}@anchor{26b}@anchor{gnat_ugn/platform_specific_information id10}@anchor{26c}
@subsection Using GNAT on Windows
@end itemize
@node Using a network installation of GNAT,CONSOLE and WINDOWS subsystems,Using GNAT on Windows,Microsoft Windows Topics
-@anchor{gnat_ugn/platform_specific_information id11}@anchor{26a}@anchor{gnat_ugn/platform_specific_information using-a-network-installation-of-gnat}@anchor{26b}
+@anchor{gnat_ugn/platform_specific_information id11}@anchor{26d}@anchor{gnat_ugn/platform_specific_information using-a-network-installation-of-gnat}@anchor{26e}
@subsection Using a network installation of GNAT
serious performance penalty.
@node CONSOLE and WINDOWS subsystems,Temporary Files,Using a network installation of GNAT,Microsoft Windows Topics
-@anchor{gnat_ugn/platform_specific_information id12}@anchor{26c}@anchor{gnat_ugn/platform_specific_information console-and-windows-subsystems}@anchor{26d}
+@anchor{gnat_ugn/platform_specific_information id12}@anchor{26f}@anchor{gnat_ugn/platform_specific_information console-and-windows-subsystems}@anchor{270}
@subsection CONSOLE and WINDOWS subsystems
@end quotation
@node Temporary Files,Mixed-Language Programming on Windows,CONSOLE and WINDOWS subsystems,Microsoft Windows Topics
-@anchor{gnat_ugn/platform_specific_information id13}@anchor{26e}@anchor{gnat_ugn/platform_specific_information temporary-files}@anchor{26f}
+@anchor{gnat_ugn/platform_specific_information id13}@anchor{271}@anchor{gnat_ugn/platform_specific_information temporary-files}@anchor{272}
@subsection Temporary Files
directories.
@node Mixed-Language Programming on Windows,Windows Specific Add-Ons,Temporary Files,Microsoft Windows Topics
-@anchor{gnat_ugn/platform_specific_information mixed-language-programming-on-windows}@anchor{270}@anchor{gnat_ugn/platform_specific_information id14}@anchor{271}
+@anchor{gnat_ugn/platform_specific_information mixed-language-programming-on-windows}@anchor{273}@anchor{gnat_ugn/platform_specific_information id14}@anchor{274}
@subsection Mixed-Language Programming on Windows
Encapsulate your C++ code in a DLL to be linked with your Ada
application. In this case, use the Microsoft or whatever environment to
build the DLL and use GNAT to build your executable
-(@ref{272,,Using DLLs with GNAT}).
+(@ref{275,,Using DLLs with GNAT}).
@item
Or you can encapsulate your Ada code in a DLL to be linked with the
other part of your application. In this case, use GNAT to build the DLL
-(@ref{273,,Building DLLs with GNAT Project files}) and use the Microsoft
+(@ref{276,,Building DLLs with GNAT Project files}) and use the Microsoft
or whatever environment to build your executable.
@end itemize
@end menu
@node Windows Calling Conventions,Introduction to Dynamic Link Libraries DLLs,,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information windows-calling-conventions}@anchor{274}@anchor{gnat_ugn/platform_specific_information id15}@anchor{275}
+@anchor{gnat_ugn/platform_specific_information windows-calling-conventions}@anchor{277}@anchor{gnat_ugn/platform_specific_information id15}@anchor{278}
@subsubsection Windows Calling Conventions
@end menu
@node C Calling Convention,Stdcall Calling Convention,,Windows Calling Conventions
-@anchor{gnat_ugn/platform_specific_information c-calling-convention}@anchor{276}@anchor{gnat_ugn/platform_specific_information id16}@anchor{277}
+@anchor{gnat_ugn/platform_specific_information c-calling-convention}@anchor{279}@anchor{gnat_ugn/platform_specific_information id16}@anchor{27a}
@subsubsection @cite{C} Calling Convention
When importing a variable defined in C, you should always use the @cite{C}
calling convention unless the object containing the variable is part of a
DLL (in which case you should use the @cite{Stdcall} calling
-convention, @ref{278,,Stdcall Calling Convention}).
+convention, @ref{27b,,Stdcall Calling Convention}).
@node Stdcall Calling Convention,Win32 Calling Convention,C Calling Convention,Windows Calling Conventions
-@anchor{gnat_ugn/platform_specific_information stdcall-calling-convention}@anchor{278}@anchor{gnat_ugn/platform_specific_information id17}@anchor{279}
+@anchor{gnat_ugn/platform_specific_information stdcall-calling-convention}@anchor{27b}@anchor{gnat_ugn/platform_specific_information id17}@anchor{27c}
@subsubsection @cite{Stdcall} Calling Convention
will be handled as a @cite{C} calling convention on non-Windows platforms.
@node Win32 Calling Convention,DLL Calling Convention,Stdcall Calling Convention,Windows Calling Conventions
-@anchor{gnat_ugn/platform_specific_information id18}@anchor{27a}@anchor{gnat_ugn/platform_specific_information win32-calling-convention}@anchor{27b}
+@anchor{gnat_ugn/platform_specific_information id18}@anchor{27d}@anchor{gnat_ugn/platform_specific_information win32-calling-convention}@anchor{27e}
@subsubsection @cite{Win32} Calling Convention
@cite{Stdcall} calling convention described above.
@node DLL Calling Convention,,Win32 Calling Convention,Windows Calling Conventions
-@anchor{gnat_ugn/platform_specific_information id19}@anchor{27c}@anchor{gnat_ugn/platform_specific_information dll-calling-convention}@anchor{27d}
+@anchor{gnat_ugn/platform_specific_information id19}@anchor{27f}@anchor{gnat_ugn/platform_specific_information dll-calling-convention}@anchor{280}
@subsubsection @cite{DLL} Calling Convention
@cite{Stdcall} calling convention described above.
@node Introduction to Dynamic Link Libraries DLLs,Using DLLs with GNAT,Windows Calling Conventions,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information id20}@anchor{27e}@anchor{gnat_ugn/platform_specific_information introduction-to-dynamic-link-libraries-dlls}@anchor{27f}
+@anchor{gnat_ugn/platform_specific_information id20}@anchor{281}@anchor{gnat_ugn/platform_specific_information introduction-to-dynamic-link-libraries-dlls}@anchor{282}
@subsubsection Introduction to Dynamic Link Libraries (DLLs)
Unix shared libraries, is the fact that on most Unix systems all public
routines are exported by default in a Unix shared library, while under
Windows it is possible (but not required) to list exported routines in
-a definition file (see @ref{280,,The Definition File}).
+a definition file (see @ref{283,,The Definition File}).
@node Using DLLs with GNAT,Building DLLs with GNAT Project files,Introduction to Dynamic Link Libraries DLLs,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information id21}@anchor{281}@anchor{gnat_ugn/platform_specific_information using-dlls-with-gnat}@anchor{272}
+@anchor{gnat_ugn/platform_specific_information id21}@anchor{284}@anchor{gnat_ugn/platform_specific_information using-dlls-with-gnat}@anchor{275}
@subsubsection Using DLLs with GNAT
@end menu
@node Creating an Ada Spec for the DLL Services,Creating an Import Library,,Using DLLs with GNAT
-@anchor{gnat_ugn/platform_specific_information creating-an-ada-spec-for-the-dll-services}@anchor{282}@anchor{gnat_ugn/platform_specific_information id22}@anchor{283}
+@anchor{gnat_ugn/platform_specific_information creating-an-ada-spec-for-the-dll-services}@anchor{285}@anchor{gnat_ugn/platform_specific_information id22}@anchor{286}
@subsubsection Creating an Ada Spec for the DLL Services
@end quotation
@node Creating an Import Library,,Creating an Ada Spec for the DLL Services,Using DLLs with GNAT
-@anchor{gnat_ugn/platform_specific_information id23}@anchor{284}@anchor{gnat_ugn/platform_specific_information creating-an-import-library}@anchor{285}
+@anchor{gnat_ugn/platform_specific_information id23}@anchor{287}@anchor{gnat_ugn/platform_specific_information creating-an-import-library}@anchor{288}
@subsubsection Creating an Import Library
DLL. Otherwise read on.
@geindex Definition file
-@anchor{gnat_ugn/platform_specific_information the-definition-file}@anchor{280}
+@anchor{gnat_ugn/platform_specific_information the-definition-file}@anchor{283}
@subsubheading The Definition File
@end table
Note that you must specify the correct suffix (@code{@@@emph{nn}})
-(see @ref{274,,Windows Calling Conventions}) for a Stdcall
+(see @ref{277,,Windows Calling Conventions}) for a Stdcall
calling convention function in the exported symbols list.
There can actually be other sections in a definition file, but these
sections are not relevant to the discussion at hand.
-@anchor{gnat_ugn/platform_specific_information create-def-file-automatically}@anchor{286}
+@anchor{gnat_ugn/platform_specific_information create-def-file-automatically}@anchor{289}
@subsubheading Creating a Definition File Automatically
You can automatically create the definition file @code{API.def}
-(see @ref{280,,The Definition File}) from a DLL.
+(see @ref{283,,The Definition File}) from a DLL.
For that use the @cite{dlltool} program as follows:
@quotation
@end example
Note that if some routines in the DLL have the @cite{Stdcall} convention
-(@ref{274,,Windows Calling Conventions}) with stripped @code{@@@emph{nn}}
+(@ref{277,,Windows Calling Conventions}) with stripped @code{@@@emph{nn}}
suffix then you'll have to edit @code{api.def} to add it, and specify
@emph{-k} to @emph{gnatdll} when creating the import library.
definition file and add the right suffix.
@end itemize
@end quotation
-@anchor{gnat_ugn/platform_specific_information gnat-style-import-library}@anchor{287}
+@anchor{gnat_ugn/platform_specific_information gnat-style-import-library}@anchor{28a}
@subsubheading GNAT-Style Import Library
To create a static import library from @code{API.dll} with the GNAT tools
you should create the .def file, then use @cite{gnatdll} tool
-(see @ref{288,,Using gnatdll}) as follows:
+(see @ref{28b,,Using gnatdll}) as follows:
@quotation
be @cite{lib`@w{`}xyz`}.a`. Note that in the previous example option
@emph{-e} could have been removed because the name of the definition
file (before the '@cite{.def}' suffix) is the same as the name of the
-DLL (@ref{288,,Using gnatdll} for more information about @cite{gnatdll}).
+DLL (@ref{28b,,Using gnatdll} for more information about @cite{gnatdll}).
@end quotation
-@anchor{gnat_ugn/platform_specific_information msvs-style-import-library}@anchor{289}
+@anchor{gnat_ugn/platform_specific_information msvs-style-import-library}@anchor{28c}
@subsubheading Microsoft-Style Import Library
A Microsoft import library is needed only if you plan to make an
Ada DLL available to applications developed with Microsoft
-tools (@ref{270,,Mixed-Language Programming on Windows}).
+tools (@ref{273,,Mixed-Language Programming on Windows}).
To create a Microsoft-style import library for @code{API.dll} you
should create the .def file, then build the actual import library using
@end quotation
@node Building DLLs with GNAT Project files,Building DLLs with GNAT,Using DLLs with GNAT,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information id24}@anchor{28a}@anchor{gnat_ugn/platform_specific_information building-dlls-with-gnat-project-files}@anchor{273}
+@anchor{gnat_ugn/platform_specific_information id24}@anchor{28d}@anchor{gnat_ugn/platform_specific_information building-dlls-with-gnat-project-files}@anchor{276}
@subsubsection Building DLLs with GNAT Project files
of shared libraries, so it is not possible to have library level tasks in SALs.
@node Building DLLs with GNAT,Building DLLs with gnatdll,Building DLLs with GNAT Project files,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information building-dlls-with-gnat}@anchor{28b}@anchor{gnat_ugn/platform_specific_information id25}@anchor{28c}
+@anchor{gnat_ugn/platform_specific_information building-dlls-with-gnat}@anchor{28e}@anchor{gnat_ugn/platform_specific_information id25}@anchor{28f}
@subsubsection Building DLLs with GNAT
It is important to note that in this case all symbols found in the
object files are automatically exported. It is possible to restrict
the set of symbols to export by passing to @emph{gcc} a definition
-file (see @ref{280,,The Definition File}).
+file (see @ref{283,,The Definition File}).
For example:
@example
@end quotation
@node Building DLLs with gnatdll,Ada DLLs and Finalization,Building DLLs with GNAT,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information building-dlls-with-gnatdll}@anchor{28d}@anchor{gnat_ugn/platform_specific_information id26}@anchor{28e}
+@anchor{gnat_ugn/platform_specific_information building-dlls-with-gnatdll}@anchor{290}@anchor{gnat_ugn/platform_specific_information id26}@anchor{291}
@subsubsection Building DLLs with gnatdll
@geindex building
Note that it is preferred to use GNAT Project files
-(@ref{273,,Building DLLs with GNAT Project files}) or the built-in GNAT
-DLL support (@ref{28b,,Building DLLs with GNAT}) or to build DLLs.
+(@ref{276,,Building DLLs with GNAT Project files}) or the built-in GNAT
+DLL support (@ref{28e,,Building DLLs with GNAT}) or to build DLLs.
This section explains how to build DLLs containing Ada code using
@cite{gnatdll}. These DLLs will be referred to as Ada DLLs in the
You need to mark each Ada @emph{entity} exported by the DLL with a @cite{C} or
@cite{Stdcall} calling convention to avoid any Ada name mangling for the
entities exported by the DLL
-(see @ref{28f,,Exporting Ada Entities}). You can
+(see @ref{292,,Exporting Ada Entities}). You can
skip this step if you plan to use the Ada DLL only from Ada applications.
@item
Your Ada code must export an initialization routine which calls the routine
@cite{adainit} generated by @emph{gnatbind} to perform the elaboration of
-the Ada code in the DLL (@ref{290,,Ada DLLs and Elaboration}). The initialization
+the Ada code in the DLL (@ref{293,,Ada DLLs and Elaboration}). The initialization
routine exported by the Ada DLL must be invoked by the clients of the DLL
to initialize the DLL.
@item
When useful, the DLL should also export a finalization routine which calls
routine @cite{adafinal} generated by @emph{gnatbind} to perform the
-finalization of the Ada code in the DLL (@ref{291,,Ada DLLs and Finalization}).
+finalization of the Ada code in the DLL (@ref{294,,Ada DLLs and Finalization}).
The finalization routine exported by the Ada DLL must be invoked by the
clients of the DLL when the DLL services are no further needed.
@item
You must provide a definition file listing the exported entities
-(@ref{280,,The Definition File}).
+(@ref{283,,The Definition File}).
@item
Finally you must use @cite{gnatdll} to produce the DLL and the import
-library (@ref{288,,Using gnatdll}).
+library (@ref{28b,,Using gnatdll}).
@end itemize
Note that a relocatable DLL stripped using the @cite{strip}
@end menu
@node Limitations When Using Ada DLLs from Ada,Exporting Ada Entities,,Building DLLs with gnatdll
-@anchor{gnat_ugn/platform_specific_information limitations-when-using-ada-dlls-from-ada}@anchor{292}
+@anchor{gnat_ugn/platform_specific_information limitations-when-using-ada-dlls-from-ada}@anchor{295}
@subsubsection Limitations When Using Ada DLLs from Ada
Windows object handles, etc.
@node Exporting Ada Entities,Ada DLLs and Elaboration,Limitations When Using Ada DLLs from Ada,Building DLLs with gnatdll
-@anchor{gnat_ugn/platform_specific_information exporting-ada-entities}@anchor{28f}@anchor{gnat_ugn/platform_specific_information id27}@anchor{293}
+@anchor{gnat_ugn/platform_specific_information exporting-ada-entities}@anchor{292}@anchor{gnat_ugn/platform_specific_information id27}@anchor{296}
@subsubsection Exporting Ada Entities
Note that if you do not export the Ada entities with a @cite{C} or
@cite{Stdcall} convention you will have to provide the mangled Ada names
in the definition file of the Ada DLL
-(@ref{294,,Creating the Definition File}).
+(@ref{297,,Creating the Definition File}).
@node Ada DLLs and Elaboration,,Exporting Ada Entities,Building DLLs with gnatdll
-@anchor{gnat_ugn/platform_specific_information ada-dlls-and-elaboration}@anchor{290}@anchor{gnat_ugn/platform_specific_information id28}@anchor{295}
+@anchor{gnat_ugn/platform_specific_information ada-dlls-and-elaboration}@anchor{293}@anchor{gnat_ugn/platform_specific_information id28}@anchor{298}
@subsubsection Ada DLLs and Elaboration
(@ref{ba,,Binding with Non-Ada Main Programs}). See the body of
@cite{Initialize_Api} for an example. Note that the GNAT binder is
automatically invoked during the DLL build process by the @cite{gnatdll}
-tool (@ref{288,,Using gnatdll}).
+tool (@ref{28b,,Using gnatdll}).
When a DLL is loaded, Windows systematically invokes a routine called
@cite{DllMain}. It would therefore be possible to call @cite{adainit}
newly created task to complete its initialization.
@node Ada DLLs and Finalization,Creating a Spec for Ada DLLs,Building DLLs with gnatdll,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information id29}@anchor{296}@anchor{gnat_ugn/platform_specific_information ada-dlls-and-finalization}@anchor{291}
+@anchor{gnat_ugn/platform_specific_information id29}@anchor{299}@anchor{gnat_ugn/platform_specific_information ada-dlls-and-finalization}@anchor{294}
@subsubsection Ada DLLs and Finalization
See the body of @cite{Finalize_Api} for an
example. As already pointed out the GNAT binder is automatically invoked
during the DLL build process by the @cite{gnatdll} tool
-(@ref{288,,Using gnatdll}).
+(@ref{28b,,Using gnatdll}).
@node Creating a Spec for Ada DLLs,GNAT and Windows Resources,Ada DLLs and Finalization,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information id30}@anchor{297}@anchor{gnat_ugn/platform_specific_information creating-a-spec-for-ada-dlls}@anchor{298}
+@anchor{gnat_ugn/platform_specific_information id30}@anchor{29a}@anchor{gnat_ugn/platform_specific_information creating-a-spec-for-ada-dlls}@anchor{29b}
@subsubsection Creating a Spec for Ada DLLs
@end menu
@node Creating the Definition File,Using gnatdll,,Creating a Spec for Ada DLLs
-@anchor{gnat_ugn/platform_specific_information creating-the-definition-file}@anchor{294}@anchor{gnat_ugn/platform_specific_information id31}@anchor{299}
+@anchor{gnat_ugn/platform_specific_information creating-the-definition-file}@anchor{297}@anchor{gnat_ugn/platform_specific_information id31}@anchor{29c}
@subsubsection Creating the Definition File
@end quotation
@node Using gnatdll,,Creating the Definition File,Creating a Spec for Ada DLLs
-@anchor{gnat_ugn/platform_specific_information using-gnatdll}@anchor{288}@anchor{gnat_ugn/platform_specific_information id32}@anchor{29a}
+@anchor{gnat_ugn/platform_specific_information using-gnatdll}@anchor{28b}@anchor{gnat_ugn/platform_specific_information id32}@anchor{29d}
@subsubsection Using @cite{gnatdll}
is loaded into memory.
@item
-@cite{gnatdll} uses @cite{dlltool} (see @ref{29b,,Using dlltool}) to build the
+@cite{gnatdll} uses @cite{dlltool} (see @ref{29e,,Using dlltool}) to build the
export table (@code{api.exp}). The export table contains the relocation
information in a form which can be used during the final link to ensure
that the Windows loader is able to place the DLL anywhere in memory.
$ gnatlink api api.exp -o api.dll -mdll
@end example
@end itemize
-@anchor{gnat_ugn/platform_specific_information using-dlltool}@anchor{29b}
+@anchor{gnat_ugn/platform_specific_information using-dlltool}@anchor{29e}
@subsubheading Using @cite{dlltool}
@item @code{-k}
Kill @code{@@@emph{nn}} from exported names
-(@ref{274,,Windows Calling Conventions}
+(@ref{277,,Windows Calling Conventions}
for a discussion about @cite{Stdcall}-style symbols.
@end table
@end table
@node GNAT and Windows Resources,Using GNAT DLLs from Microsoft Visual Studio Applications,Creating a Spec for Ada DLLs,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information gnat-and-windows-resources}@anchor{29c}@anchor{gnat_ugn/platform_specific_information id33}@anchor{29d}
+@anchor{gnat_ugn/platform_specific_information gnat-and-windows-resources}@anchor{29f}@anchor{gnat_ugn/platform_specific_information id33}@anchor{2a0}
@subsubsection GNAT and Windows Resources
@end menu
@node Building Resources,Compiling Resources,,GNAT and Windows Resources
-@anchor{gnat_ugn/platform_specific_information building-resources}@anchor{29e}@anchor{gnat_ugn/platform_specific_information id34}@anchor{29f}
+@anchor{gnat_ugn/platform_specific_information building-resources}@anchor{2a1}@anchor{gnat_ugn/platform_specific_information id34}@anchor{2a2}
@subsubsection Building Resources
Microsoft documentation.
@node Compiling Resources,Using Resources,Building Resources,GNAT and Windows Resources
-@anchor{gnat_ugn/platform_specific_information compiling-resources}@anchor{2a0}@anchor{gnat_ugn/platform_specific_information id35}@anchor{2a1}
+@anchor{gnat_ugn/platform_specific_information compiling-resources}@anchor{2a3}@anchor{gnat_ugn/platform_specific_information id35}@anchor{2a4}
@subsubsection Compiling Resources
@end quotation
@node Using Resources,,Compiling Resources,GNAT and Windows Resources
-@anchor{gnat_ugn/platform_specific_information id36}@anchor{2a2}@anchor{gnat_ugn/platform_specific_information using-resources}@anchor{2a3}
+@anchor{gnat_ugn/platform_specific_information id36}@anchor{2a5}@anchor{gnat_ugn/platform_specific_information using-resources}@anchor{2a6}
@subsubsection Using Resources
@end quotation
@node Using GNAT DLLs from Microsoft Visual Studio Applications,Debugging a DLL,GNAT and Windows Resources,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information using-gnat-dll-from-msvs}@anchor{2a4}@anchor{gnat_ugn/platform_specific_information using-gnat-dlls-from-microsoft-visual-studio-applications}@anchor{2a5}
+@anchor{gnat_ugn/platform_specific_information using-gnat-dll-from-msvs}@anchor{2a7}@anchor{gnat_ugn/platform_specific_information using-gnat-dlls-from-microsoft-visual-studio-applications}@anchor{2a8}
@subsubsection Using GNAT DLLs from Microsoft Visual Studio Applications
@item
Produce a .def file for the symbols you need to interface with, either by
hand or automatically with possibly some manual adjustments
-(see @ref{286,,Creating Definition File Automatically}):
+(see @ref{289,,Creating Definition File Automatically}):
@end enumerate
@quotation
Make sure that MSVS command-line tools are accessible on the path.
@item
-Create the Microsoft-style import library (see @ref{289,,MSVS-Style Import Library}):
+Create the Microsoft-style import library (see @ref{28c,,MSVS-Style Import Library}):
@end enumerate
@quotation
@end enumerate
@node Debugging a DLL,Setting Stack Size from gnatlink,Using GNAT DLLs from Microsoft Visual Studio Applications,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information id37}@anchor{2a6}@anchor{gnat_ugn/platform_specific_information debugging-a-dll}@anchor{2a7}
+@anchor{gnat_ugn/platform_specific_information id37}@anchor{2a9}@anchor{gnat_ugn/platform_specific_information debugging-a-dll}@anchor{2aa}
@subsubsection Debugging a DLL
@end menu
@node Program and DLL Both Built with GCC/GNAT,Program Built with Foreign Tools and DLL Built with GCC/GNAT,,Debugging a DLL
-@anchor{gnat_ugn/platform_specific_information program-and-dll-both-built-with-gcc-gnat}@anchor{2a8}@anchor{gnat_ugn/platform_specific_information id38}@anchor{2a9}
+@anchor{gnat_ugn/platform_specific_information program-and-dll-both-built-with-gcc-gnat}@anchor{2ab}@anchor{gnat_ugn/platform_specific_information id38}@anchor{2ac}
@subsubsection Program and DLL Both Built with GCC/GNAT
@cite{ada_main} and that in the DLL there is an entry point named
@cite{ada_dll}.
-The DLL (@ref{27f,,Introduction to Dynamic Link Libraries (DLLs)}) and
+The DLL (@ref{282,,Introduction to Dynamic Link Libraries (DLLs)}) and
program must have been built with the debugging information (see GNAT -g
switch). Here are the step-by-step instructions for debugging it:
(@ref{26,,Running and Debugging Ada Programs}).
@node Program Built with Foreign Tools and DLL Built with GCC/GNAT,,Program and DLL Both Built with GCC/GNAT,Debugging a DLL
-@anchor{gnat_ugn/platform_specific_information program-built-with-foreign-tools-and-dll-built-with-gcc-gnat}@anchor{2aa}@anchor{gnat_ugn/platform_specific_information id39}@anchor{2ab}
+@anchor{gnat_ugn/platform_specific_information program-built-with-foreign-tools-and-dll-built-with-gcc-gnat}@anchor{2ad}@anchor{gnat_ugn/platform_specific_information id39}@anchor{2ae}
@subsubsection Program Built with Foreign Tools and DLL Built with GCC/GNAT
DLL named @cite{test.dll} containing an Ada entry point named
@cite{ada_dll}.
-The DLL (see @ref{27f,,Introduction to Dynamic Link Libraries (DLLs)}) must have
+The DLL (see @ref{282,,Introduction to Dynamic Link Libraries (DLLs)}) must have
been built with debugging information (see GNAT @cite{-g} option).
@subsubheading Debugging the DLL Directly
@ref{26,,Running and Debugging Ada Programs}.
@node Setting Stack Size from gnatlink,Setting Heap Size from gnatlink,Debugging a DLL,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information setting-stack-size-from-gnatlink}@anchor{13a}@anchor{gnat_ugn/platform_specific_information id40}@anchor{2ac}
+@anchor{gnat_ugn/platform_specific_information setting-stack-size-from-gnatlink}@anchor{13d}@anchor{gnat_ugn/platform_specific_information id40}@anchor{2af}
@subsubsection Setting Stack Size from @emph{gnatlink}
@end itemize
@node Setting Heap Size from gnatlink,,Setting Stack Size from gnatlink,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information setting-heap-size-from-gnatlink}@anchor{13b}@anchor{gnat_ugn/platform_specific_information id41}@anchor{2ad}
+@anchor{gnat_ugn/platform_specific_information setting-heap-size-from-gnatlink}@anchor{13e}@anchor{gnat_ugn/platform_specific_information id41}@anchor{2b0}
@subsubsection Setting Heap Size from @emph{gnatlink}
@end itemize
@node Windows Specific Add-Ons,,Mixed-Language Programming on Windows,Microsoft Windows Topics
-@anchor{gnat_ugn/platform_specific_information windows-specific-add-ons}@anchor{2ae}@anchor{gnat_ugn/platform_specific_information win32-specific-addons}@anchor{2af}
+@anchor{gnat_ugn/platform_specific_information windows-specific-add-ons}@anchor{2b1}@anchor{gnat_ugn/platform_specific_information win32-specific-addons}@anchor{2b2}
@subsection Windows Specific Add-Ons
@end menu
@node Win32Ada,wPOSIX,,Windows Specific Add-Ons
-@anchor{gnat_ugn/platform_specific_information win32ada}@anchor{2b0}@anchor{gnat_ugn/platform_specific_information id42}@anchor{2b1}
+@anchor{gnat_ugn/platform_specific_information win32ada}@anchor{2b3}@anchor{gnat_ugn/platform_specific_information id42}@anchor{2b4}
@subsubsection Win32Ada
@end quotation
@node wPOSIX,,Win32Ada,Windows Specific Add-Ons
-@anchor{gnat_ugn/platform_specific_information id43}@anchor{2b2}@anchor{gnat_ugn/platform_specific_information wposix}@anchor{2b3}
+@anchor{gnat_ugn/platform_specific_information id43}@anchor{2b5}@anchor{gnat_ugn/platform_specific_information wposix}@anchor{2b6}
@subsubsection wPOSIX
@end quotation
@node Mac OS Topics,,Microsoft Windows Topics,Platform-Specific Information
-@anchor{gnat_ugn/platform_specific_information mac-os-topics}@anchor{2f}@anchor{gnat_ugn/platform_specific_information id44}@anchor{2b4}
+@anchor{gnat_ugn/platform_specific_information mac-os-topics}@anchor{2f}@anchor{gnat_ugn/platform_specific_information id44}@anchor{2b7}
@section Mac OS Topics
@end menu
@node Codesigning the Debugger,,,Mac OS Topics
-@anchor{gnat_ugn/platform_specific_information codesigning-the-debugger}@anchor{2b5}
+@anchor{gnat_ugn/platform_specific_information codesigning-the-debugger}@anchor{2b8}
@subsection Codesigning the Debugger
in the Unix group @code{_developer}.
@node Example of Binder Output File,Elaboration Order Handling in GNAT,Platform-Specific Information,Top
-@anchor{gnat_ugn/example_of_binder_output example-of-binder-output-file}@anchor{10}@anchor{gnat_ugn/example_of_binder_output doc}@anchor{2b6}@anchor{gnat_ugn/example_of_binder_output id1}@anchor{2b7}
+@anchor{gnat_ugn/example_of_binder_output example-of-binder-output-file}@anchor{10}@anchor{gnat_ugn/example_of_binder_output doc}@anchor{2b9}@anchor{gnat_ugn/example_of_binder_output id1}@anchor{2ba}
@chapter Example of Binder Output File
@c -- Example: A |withing| unit has a |with| clause, it |withs| a |withed| unit
@node Elaboration Order Handling in GNAT,Inline Assembler,Example of Binder Output File,Top
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-order-handling-in-gnat}@anchor{11}@anchor{gnat_ugn/elaboration_order_handling_in_gnat doc}@anchor{2b8}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id1}@anchor{2b9}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-order-handling-in-gnat}@anchor{11}@anchor{gnat_ugn/elaboration_order_handling_in_gnat doc}@anchor{2bb}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id1}@anchor{2bc}
@chapter Elaboration Order Handling in GNAT
@end menu
@node Elaboration Code,Checking the Elaboration Order,,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-code}@anchor{2ba}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id2}@anchor{2bb}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-code}@anchor{2bd}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id2}@anchor{2be}
@section Elaboration Code
is impossible to guarantee a safe order of elaboration at run time.
@node Checking the Elaboration Order,Controlling the Elaboration Order,Elaboration Code,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat checking-the-elaboration-order}@anchor{2bc}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id3}@anchor{2bd}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat checking-the-elaboration-order}@anchor{2bf}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id3}@anchor{2c0}
@section Checking the Elaboration Order
think of there being one variable per subprogram.
@node Controlling the Elaboration Order,Controlling Elaboration in GNAT - Internal Calls,Checking the Elaboration Order,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat id4}@anchor{2be}@anchor{gnat_ugn/elaboration_order_handling_in_gnat controlling-the-elaboration-order}@anchor{2bf}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat id4}@anchor{2c1}@anchor{gnat_ugn/elaboration_order_handling_in_gnat controlling-the-elaboration-order}@anchor{2c2}
@section Controlling the Elaboration Order
to use @cite{Elaborate_All} on such units.
@node Controlling Elaboration in GNAT - Internal Calls,Controlling Elaboration in GNAT - External Calls,Controlling the Elaboration Order,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat id5}@anchor{2c0}@anchor{gnat_ugn/elaboration_order_handling_in_gnat controlling-elaboration-in-gnat-internal-calls}@anchor{2c1}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat id5}@anchor{2c3}@anchor{gnat_ugn/elaboration_order_handling_in_gnat controlling-elaboration-in-gnat-internal-calls}@anchor{2c4}
@section Controlling Elaboration in GNAT - Internal Calls
is not yet elaborated, without raising a @cite{Program_Error} exception.
@node Controlling Elaboration in GNAT - External Calls,Default Behavior in GNAT - Ensuring Safety,Controlling Elaboration in GNAT - Internal Calls,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat id6}@anchor{2c2}@anchor{gnat_ugn/elaboration_order_handling_in_gnat controlling-elaboration-in-gnat-external-calls}@anchor{2c3}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat id6}@anchor{2c5}@anchor{gnat_ugn/elaboration_order_handling_in_gnat controlling-elaboration-in-gnat-external-calls}@anchor{2c6}
@section Controlling Elaboration in GNAT - External Calls
developing programs that are robust with respect to elaboration order.
@node Default Behavior in GNAT - Ensuring Safety,Treatment of Pragma Elaborate,Controlling Elaboration in GNAT - External Calls,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat id7}@anchor{2c4}@anchor{gnat_ugn/elaboration_order_handling_in_gnat default-behavior-in-gnat-ensuring-safety}@anchor{2c5}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat id7}@anchor{2c7}@anchor{gnat_ugn/elaboration_order_handling_in_gnat default-behavior-in-gnat-ensuring-safety}@anchor{2c8}
@section Default Behavior in GNAT - Ensuring Safety
run-time checks. However, in the case of legacy code, it may be
difficult to meet the requirements of the static model. This
issue is further discussed in
-@ref{2c6,,What to Do If the Default Elaboration Behavior Fails}.
+@ref{2c9,,What to Do If the Default Elaboration Behavior Fails}.
Note that the static model provides a strict subset of the allowed
behavior and programs of the Ada Reference Manual, so if you do
pragma Elaborate statements from the source.
@node Treatment of Pragma Elaborate,Elaboration Issues for Library Tasks,Default Behavior in GNAT - Ensuring Safety,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat treatment-of-pragma-elaborate}@anchor{2c7}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id8}@anchor{2c8}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat treatment-of-pragma-elaborate}@anchor{2ca}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id8}@anchor{2cb}
@section Treatment of Pragma Elaborate
problems.
@node Elaboration Issues for Library Tasks,Mixing Elaboration Models,Treatment of Pragma Elaborate,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-issues-for-library-tasks}@anchor{2c9}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id9}@anchor{2ca}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-issues-for-library-tasks}@anchor{2cc}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id9}@anchor{2cd}
@section Elaboration Issues for Library Tasks
@end itemize
@node Mixing Elaboration Models,What to Do If the Default Elaboration Behavior Fails,Elaboration Issues for Library Tasks,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat id10}@anchor{2cb}@anchor{gnat_ugn/elaboration_order_handling_in_gnat mixing-elaboration-models}@anchor{2cc}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat id10}@anchor{2ce}@anchor{gnat_ugn/elaboration_order_handling_in_gnat mixing-elaboration-models}@anchor{2cf}
@section Mixing Elaboration Models
using the more reliable default static model.
@node What to Do If the Default Elaboration Behavior Fails,Elaboration for Indirect Calls,Mixing Elaboration Models,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat id11}@anchor{2cd}@anchor{gnat_ugn/elaboration_order_handling_in_gnat what-to-do-if-the-default-elaboration-behavior-fails}@anchor{2c6}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat id11}@anchor{2d0}@anchor{gnat_ugn/elaboration_order_handling_in_gnat what-to-do-if-the-default-elaboration-behavior-fails}@anchor{2c9}
@section What to Do If the Default Elaboration Behavior Fails
@item
Use Pragma Elaborate.
-As previously described in section @ref{2c7,,Treatment of Pragma Elaborate},
+As previously described in section @ref{2ca,,Treatment of Pragma Elaborate},
GNAT in static mode assumes that a @cite{pragma} Elaborate indicates correctly
that no elaboration checks are required on calls to the designated unit.
There may be cases in which the caller knows that no transitive calls
not a factor in running the ACATS tests.)
@node Elaboration for Indirect Calls,Summary of Procedures for Elaboration Control,What to Do If the Default Elaboration Behavior Fails,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat id12}@anchor{2ce}@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-for-indirect-calls}@anchor{2cf}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat id12}@anchor{2d1}@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-for-indirect-calls}@anchor{2d2}
@section Elaboration for Indirect Calls
of @emph{-gnatd.U}.
@node Summary of Procedures for Elaboration Control,Other Elaboration Order Considerations,Elaboration for Indirect Calls,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat id13}@anchor{2d0}@anchor{gnat_ugn/elaboration_order_handling_in_gnat summary-of-procedures-for-elaboration-control}@anchor{2d1}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat id13}@anchor{2d3}@anchor{gnat_ugn/elaboration_order_handling_in_gnat summary-of-procedures-for-elaboration-control}@anchor{2d4}
@section Summary of Procedures for Elaboration Control
use a global pragma @cite{Suppress (Elaboration_Check)}.
@node Other Elaboration Order Considerations,Determining the Chosen Elaboration Order,Summary of Procedures for Elaboration Control,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat id14}@anchor{2d2}@anchor{gnat_ugn/elaboration_order_handling_in_gnat other-elaboration-order-considerations}@anchor{2d3}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat id14}@anchor{2d5}@anchor{gnat_ugn/elaboration_order_handling_in_gnat other-elaboration-order-considerations}@anchor{2d6}
@section Other Elaboration Order Considerations
@cite{Elaborate} or @cite{Elaborate_All} pragmas to ensure the desired order.
@node Determining the Chosen Elaboration Order,,Other Elaboration Order Considerations,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat determining-the-chosen-elaboration-order}@anchor{2d4}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id15}@anchor{2d5}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat determining-the-chosen-elaboration-order}@anchor{2d7}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id15}@anchor{2d8}
@section Determining the Chosen Elaboration Order
@end example
@node Inline Assembler,GNU Free Documentation License,Elaboration Order Handling in GNAT,Top
-@anchor{gnat_ugn/inline_assembler inline-assembler}@anchor{12}@anchor{gnat_ugn/inline_assembler doc}@anchor{2d6}@anchor{gnat_ugn/inline_assembler id1}@anchor{2d7}
+@anchor{gnat_ugn/inline_assembler inline-assembler}@anchor{12}@anchor{gnat_ugn/inline_assembler doc}@anchor{2d9}@anchor{gnat_ugn/inline_assembler id1}@anchor{2da}
@chapter Inline Assembler
@end menu
@node Basic Assembler Syntax,A Simple Example of Inline Assembler,,Inline Assembler
-@anchor{gnat_ugn/inline_assembler id2}@anchor{2d8}@anchor{gnat_ugn/inline_assembler basic-assembler-syntax}@anchor{2d9}
+@anchor{gnat_ugn/inline_assembler id2}@anchor{2db}@anchor{gnat_ugn/inline_assembler basic-assembler-syntax}@anchor{2dc}
@section Basic Assembler Syntax
@node A Simple Example of Inline Assembler,Output Variables in Inline Assembler,Basic Assembler Syntax,Inline Assembler
-@anchor{gnat_ugn/inline_assembler a-simple-example-of-inline-assembler}@anchor{2da}@anchor{gnat_ugn/inline_assembler id3}@anchor{2db}
+@anchor{gnat_ugn/inline_assembler a-simple-example-of-inline-assembler}@anchor{2dd}@anchor{gnat_ugn/inline_assembler id3}@anchor{2de}
@section A Simple Example of Inline Assembler
@code{nothing.out}.
@node Output Variables in Inline Assembler,Input Variables in Inline Assembler,A Simple Example of Inline Assembler,Inline Assembler
-@anchor{gnat_ugn/inline_assembler id4}@anchor{2dc}@anchor{gnat_ugn/inline_assembler output-variables-in-inline-assembler}@anchor{2dd}
+@anchor{gnat_ugn/inline_assembler id4}@anchor{2df}@anchor{gnat_ugn/inline_assembler output-variables-in-inline-assembler}@anchor{2e0}
@section Output Variables in Inline Assembler
@end quotation
@node Input Variables in Inline Assembler,Inlining Inline Assembler Code,Output Variables in Inline Assembler,Inline Assembler
-@anchor{gnat_ugn/inline_assembler id5}@anchor{2de}@anchor{gnat_ugn/inline_assembler input-variables-in-inline-assembler}@anchor{2df}
+@anchor{gnat_ugn/inline_assembler id5}@anchor{2e1}@anchor{gnat_ugn/inline_assembler input-variables-in-inline-assembler}@anchor{2e2}
@section Input Variables in Inline Assembler
@end quotation
@node Inlining Inline Assembler Code,Other Asm Functionality,Input Variables in Inline Assembler,Inline Assembler
-@anchor{gnat_ugn/inline_assembler id6}@anchor{2e0}@anchor{gnat_ugn/inline_assembler inlining-inline-assembler-code}@anchor{2e1}
+@anchor{gnat_ugn/inline_assembler id6}@anchor{2e3}@anchor{gnat_ugn/inline_assembler inlining-inline-assembler-code}@anchor{2e4}
@section Inlining Inline Assembler Code
thus saving the overhead of stack frame setup and an out-of-line call.
@node Other Asm Functionality,,Inlining Inline Assembler Code,Inline Assembler
-@anchor{gnat_ugn/inline_assembler other-asm-functionality}@anchor{2e2}@anchor{gnat_ugn/inline_assembler id7}@anchor{2e3}
+@anchor{gnat_ugn/inline_assembler other-asm-functionality}@anchor{2e5}@anchor{gnat_ugn/inline_assembler id7}@anchor{2e6}
@section Other @cite{Asm} Functionality
@end menu
@node The Clobber Parameter,The Volatile Parameter,,Other Asm Functionality
-@anchor{gnat_ugn/inline_assembler the-clobber-parameter}@anchor{2e4}@anchor{gnat_ugn/inline_assembler id8}@anchor{2e5}
+@anchor{gnat_ugn/inline_assembler the-clobber-parameter}@anchor{2e7}@anchor{gnat_ugn/inline_assembler id8}@anchor{2e8}
@subsection The @cite{Clobber} Parameter
@end itemize
@node The Volatile Parameter,,The Clobber Parameter,Other Asm Functionality
-@anchor{gnat_ugn/inline_assembler the-volatile-parameter}@anchor{2e6}@anchor{gnat_ugn/inline_assembler id9}@anchor{2e7}
+@anchor{gnat_ugn/inline_assembler the-volatile-parameter}@anchor{2e9}@anchor{gnat_ugn/inline_assembler id9}@anchor{2ea}
@subsection The @cite{Volatile} Parameter
problems.
@node GNU Free Documentation License,Index,Inline Assembler,Top
-@anchor{share/gnu_free_documentation_license gnu-fdl}@anchor{1}@anchor{share/gnu_free_documentation_license doc}@anchor{2e8}@anchor{share/gnu_free_documentation_license gnu-free-documentation-license}@anchor{2e9}
+@anchor{share/gnu_free_documentation_license gnu-fdl}@anchor{1}@anchor{share/gnu_free_documentation_license doc}@anchor{2eb}@anchor{share/gnu_free_documentation_license gnu-free-documentation-license}@anchor{2ec}
@chapter GNU Free Documentation License
projects / platform / upstream / linaro-gcc.git / commitdiff