GNAT User’s Guide for Native Platforms

3.2.1 Latin-1

The basic character set is Latin-1. This character set is defined by ISO standard 8859, part 1. The lower half (character codes 16#00# … 16#7F#) is identical to standard ASCII coding, but the upper half is used to represent additional characters. These include extended letters used by European languages, such as French accents, the vowels with umlauts used in German, and the extra letter A-ring used in Swedish.

For a complete list of Latin-1 codes and their encodings, see the source file of library unit Ada.Characters.Latin_1 in file a-chlat1.ads. You may use any of these extended characters freely in character or string literals. In addition, the extended characters that represent letters can be used in identifiers.

3.2.2 Other 8-Bit Codes

GNAT also supports several other 8-bit coding schemes:

`ISO 8859-2 (Latin-2)'

Latin-2 letters allowed in identifiers, with uppercase and lowercase equivalence.

`ISO 8859-3 (Latin-3)'

Latin-3 letters allowed in identifiers, with uppercase and lowercase equivalence.

`ISO 8859-4 (Latin-4)'

Latin-4 letters allowed in identifiers, with uppercase and lowercase equivalence.

`ISO 8859-5 (Cyrillic)'

ISO 8859-5 letters (Cyrillic) allowed in identifiers, with uppercase and lowercase equivalence.

`ISO 8859-15 (Latin-9)'

ISO 8859-15 (Latin-9) letters allowed in identifiers, with uppercase and lowercase equivalence

`IBM PC (code page 437)'

This code page is the normal default for PCs in the U.S. It corresponds to the original IBM PC character set. This set has some, but not all, of the extended Latin-1 letters, but these letters do not have the same encoding as Latin-1. In this mode, these letters are allowed in identifiers with uppercase and lowercase equivalence.

`IBM PC (code page 850)'

This code page is a modification of 437 extended to include all the Latin-1 letters, but still not with the usual Latin-1 encoding. In this mode, all these letters are allowed in identifiers with uppercase and lowercase equivalence.

`Full Upper 8-bit'

Any character in the range 80-FF allowed in identifiers, and all are considered distinct. In other words, there are no uppercase and lowercase equivalences in this range. This is useful in conjunction with certain encoding schemes used for some foreign character sets (e.g., the typical method of representing Chinese characters on the PC).

`No Upper-Half'

No upper-half characters in the range 80-FF are allowed in identifiers. This gives Ada 83 compatibility for identifier names.

For precise data on the encodings permitted, and the uppercase and lowercase equivalences that are recognized, see the file csets.adb in the GNAT compiler sources. You will need to obtain a full source release of GNAT to obtain this file.

3.2.3 Wide_Character Encodings

GNAT allows wide character codes to appear in character and string literals, and also optionally in identifiers, by means of the following possible encoding schemes:

`Hex Coding'

In this encoding, a wide character is represented by the following five character sequence:

ESC a b c d

where a, b, c, d are the four hexadecimal characters (using uppercase letters) of the wide character code. For example, ESC A345 is used to represent the wide character with code 16#A345#. This scheme is compatible with use of the full Wide_Character set.

`Upper-Half Coding'

The wide character with encoding 16#abcd# where the upper bit is on (in other words, ‘a’ is in the range 8-F) is represented as two bytes, 16#ab# and 16#cd#. The second byte cannot be a format control character, but is not required to be in the upper half. This method can be also used for shift-JIS or EUC, where the internal coding matches the external coding.

`Shift JIS Coding'

A wide character is represented by a two-character sequence, 16#ab# and 16#cd#, with the restrictions described for upper-half encoding as described above. The internal character code is the corresponding JIS character according to the standard algorithm for Shift-JIS conversion. Only characters defined in the JIS code set table can be used with this encoding method.

`EUC Coding'

A wide character is represented by a two-character sequence 16#ab# and 16#cd#, with both characters being in the upper half. The internal character code is the corresponding JIS character according to the EUC encoding algorithm. Only characters defined in the JIS code set table can be used with this encoding method.

`UTF-8 Coding'

A wide character is represented using UCS Transformation Format 8 (UTF-8) as defined in Annex R of ISO 10646-1/Am.2. Depending on the character value, the representation is a one, two, or three byte sequence:

16#0000#-16#007f#: 2#0xxxxxxx#
16#0080#-16#07ff#: 2#110xxxxx# 2#10xxxxxx#
16#0800#-16#ffff#: 2#1110xxxx# 2#10xxxxxx# 2#10xxxxxx#

where the xxx bits correspond to the left-padded bits of the 16-bit character value. Note that all lower half ASCII characters are represented as ASCII bytes and all upper half characters and other wide characters are represented as sequences of upper-half (The full UTF-8 scheme allows for encoding 31-bit characters as 6-byte sequences, and in the following section on wide wide characters, the use of these sequences is documented).

`Brackets Coding'

In this encoding, a wide character is represented by the following eight character sequence:

[ " a b c d " ]

where a, b, c, d are the four hexadecimal characters (using uppercase letters) of the wide character code. For example, [‘A345’] is used to represent the wide character with code 16#A345#. It is also possible (though not required) to use the Brackets coding for upper half characters. For example, the code 16#A3# can be represented as ['A3'].

This scheme is compatible with use of the full Wide_Character set, and is also the method used for wide character encoding in some standard ACATS (Ada Conformity Assessment Test Suite) test suite distributions.

3.2.4 Wide_Wide_Character Encodings

GNAT allows wide wide character codes to appear in character and string literals, and also optionally in identifiers, by means of the following possible encoding schemes:

`UTF-8 Coding'

A wide character is represented using UCS Transformation Format 8 (UTF-8) as defined in Annex R of ISO 10646-1/Am.2. Depending on the character value, the representation of character codes with values greater than 16#FFFF# is a is a four, five, or six byte sequence:

16#01_0000#-16#10_FFFF#:     11110xxx 10xxxxxx 10xxxxxx
                             10xxxxxx
16#0020_0000#-16#03FF_FFFF#: 111110xx 10xxxxxx 10xxxxxx
                             10xxxxxx 10xxxxxx
16#0400_0000#-16#7FFF_FFFF#: 1111110x 10xxxxxx 10xxxxxx
                             10xxxxxx 10xxxxxx 10xxxxxx

where the xxx bits correspond to the left-padded bits of the 32-bit character value.

`Brackets Coding'

In this encoding, a wide wide character is represented by the following ten or twelve byte character sequence:

[ " a b c d e f " ]
[ " a b c d e f g h " ]

where a-h are the six or eight hexadecimal characters (using uppercase letters) of the wide wide character code. For example, [“1F4567”] is used to represent the wide wide character with code 16#001F_4567#.

This scheme is compatible with use of the full Wide_Wide_Character set, and is also the method used for wide wide character encoding in some standard ACATS (Ada Conformity Assessment Test Suite) test suite distributions.

3.3.1 File Naming Rules

The default file name is determined by the name of the unit that the file contains. The name is formed by taking the full expanded name of the unit and replacing the separating dots with hyphens and using lowercase for all letters.

An exception arises if the file name generated by the above rules starts with one of the characters a, g, i, or s, and the second character is a minus. In this case, the character tilde is used in place of the minus. The reason for this special rule is to avoid clashes with the standard names for child units of the packages System, Ada, Interfaces, and GNAT, which use the prefixes s-, a-, i-, and g-, respectively.

The file extension is .ads for a spec and .adb for a body. The following table shows some examples of these rules.

Source File	Ada Compilation Unit
main.ads	Main (spec)
main.adb	Main (body)
arith_functions.ads	Arith_Functions (package spec)
arith_functions.adb	Arith_Functions (package body)
func-spec.ads	Func.Spec (child package spec)
func-spec.adb	Func.Spec (child package body)
main-sub.adb	Sub (subunit of Main)
a~bad.adb	A.Bad (child package body)

Following these rules can result in excessively long file names if corresponding unit names are long (for example, if child units or subunits are heavily nested). An option is available to shorten such long file names (called file name ‘krunching’). This may be particularly useful when programs being developed with GNAT are to be used on operating systems with limited file name lengths. Using gnatkr.

Of course, no file shortening algorithm can guarantee uniqueness over all possible unit names; if file name krunching is used, it is your responsibility to ensure no name clashes occur. Alternatively you can specify the exact file names that you want used, as described in the next section. Finally, if your Ada programs are migrating from a compiler with a different naming convention, you can use the gnatchop utility to produce source files that follow the GNAT naming conventions. (For details see Renaming Files with gnatchop.)

Note: in the case of Windows or Mac OS operating systems, case is not significant. So for example on Windows if the canonical name is main-sub.adb, you can use the file name Main-Sub.adb instead. However, case is significant for other operating systems, so for example, if you want to use other than canonically cased file names on a Unix system, you need to follow the procedures described in the next section.

3.3.2 Using Other File Names

In the previous section, we have described the default rules used by GNAT to determine the file name in which a given unit resides. It is often convenient to follow these default rules, and if you follow them, the compiler knows without being explicitly told where to find all the files it needs.

However, in some cases, particularly when a program is imported from another Ada compiler environment, it may be more convenient for the programmer to specify which file names contain which units. GNAT allows arbitrary file names to be used by means of the Source_File_Name pragma. The form of this pragma is as shown in the following examples:

pragma Source_File_Name (My_Utilities.Stacks,
  Spec_File_Name => "myutilst_a.ada");
pragma Source_File_name (My_Utilities.Stacks,
  Body_File_Name => "myutilst.ada");

As shown in this example, the first argument for the pragma is the unit name (in this example a child unit). The second argument has the form of a named association. The identifier indicates whether the file name is for a spec or a body; the file name itself is given by a string literal.

The source file name pragma is a configuration pragma, which means that normally it will be placed in the gnat.adc file used to hold configuration pragmas that apply to a complete compilation environment. For more details on how the gnat.adc file is created and used see Handling of Configuration Pragmas.

GNAT allows completely arbitrary file names to be specified using the source file name pragma. However, if the file name specified has an extension other than .ads or .adb it is necessary to use a special syntax when compiling the file. The name in this case must be preceded by the special sequence -x followed by a space and the name of the language, here ada, as in:

$ gcc -c -x ada peculiar_file_name.sim

gnatmake handles non-standard file names in the usual manner (the non-standard file name for the main program is simply used as the argument to gnatmake). Note that if the extension is also non-standard, then it must be included in the gnatmake command, it may not be omitted.

3.3.3 Alternative File Naming Schemes

The previous section described the use of the Source_File_Name pragma to allow arbitrary names to be assigned to individual source files. However, this approach requires one pragma for each file, and especially in large systems can result in very long gnat.adc files, and also create a maintenance problem.

GNAT also provides a facility for specifying systematic file naming schemes other than the standard default naming scheme previously described. An alternative scheme for naming is specified by the use of Source_File_Name pragmas having the following format:

pragma Source_File_Name (
   Spec_File_Name  => FILE_NAME_PATTERN
 [ , Casing          => CASING_SPEC]
 [ , Dot_Replacement => STRING_LITERAL ] );

pragma Source_File_Name (
   Body_File_Name  => FILE_NAME_PATTERN
 [ , Casing          => CASING_SPEC ]
 [ , Dot_Replacement => STRING_LITERAL ] ) ;

pragma Source_File_Name (
   Subunit_File_Name  => FILE_NAME_PATTERN
 [ , Casing          => CASING_SPEC ]
 [ , Dot_Replacement => STRING_LITERAL ] ) ;

FILE_NAME_PATTERN ::= STRING_LITERAL
CASING_SPEC ::= Lowercase | Uppercase | Mixedcase

The FILE_NAME_PATTERN string shows how the file name is constructed. It contains a single asterisk character, and the unit name is substituted systematically for this asterisk. The optional parameter Casing indicates whether the unit name is to be all upper-case letters, all lower-case letters, or mixed-case. If no Casing parameter is used, then the default is all lower-case.

The optional Dot_Replacement string is used to replace any periods that occur in subunit or child unit names. If no Dot_Replacement argument is used then separating dots appear unchanged in the resulting file name. Although the above syntax indicates that the Casing argument must appear before the Dot_Replacement argument, but it is also permissible to write these arguments in the opposite order.

As indicated, it is possible to specify different naming schemes for bodies, specs, and subunits. Quite often the rule for subunits is the same as the rule for bodies, in which case, there is no need to give a separate Subunit_File_Name rule, and in this case the Body_File_name rule is used for subunits as well.

The separate rule for subunits can also be used to implement the rather unusual case of a compilation environment (e.g., a single directory) which contains a subunit and a child unit with the same unit name. Although both units cannot appear in the same partition, the Ada Reference Manual allows (but does not require) the possibility of the two units coexisting in the same environment.

The file name translation works in the following steps:

• If there is a specific Source_File_Name pragma for the given unit, then this is always used, and any general pattern rules are ignored.
• If there is a pattern type Source_File_Name pragma that applies to the unit, then the resulting file name will be used if the file exists. If more than one pattern matches, the latest one will be tried first, and the first attempt resulting in a reference to a file that exists will be used.
• If no pattern type Source_File_Name pragma that applies to the unit for which the corresponding file exists, then the standard GNAT default naming rules are used.

As an example of the use of this mechanism, consider a commonly used scheme in which file names are all lower case, with separating periods copied unchanged to the resulting file name, and specs end with .1.ada, and bodies end with .2.ada. GNAT will follow this scheme if the following two pragmas appear:

pragma Source_File_Name
  (Spec_File_Name => ".1.ada");
pragma Source_File_Name
  (Body_File_Name => ".2.ada");

The default GNAT scheme is actually implemented by providing the following default pragmas internally:

pragma Source_File_Name
  (Spec_File_Name => ".ads", Dot_Replacement => "-");
pragma Source_File_Name
  (Body_File_Name => ".adb", Dot_Replacement => "-");

Our final example implements a scheme typically used with one of the Ada 83 compilers, where the separator character for subunits was ‘__’ (two underscores), specs were identified by adding _.ADA, bodies by adding .ADA, and subunits by adding .SEP. All file names were upper case. Child units were not present of course since this was an Ada 83 compiler, but it seems reasonable to extend this scheme to use the same double underscore separator for child units.

pragma Source_File_Name
  (Spec_File_Name => "_.ADA",
   Dot_Replacement => "__",
   Casing = Uppercase);
pragma Source_File_Name
  (Body_File_Name => ".ADA",
   Dot_Replacement => "__",
   Casing = Uppercase);
pragma Source_File_Name
  (Subunit_File_Name => ".SEP",
   Dot_Replacement => "__",
   Casing = Uppercase);

3.3.4 Handling Arbitrary File Naming Conventions with gnatname

• Arbitrary File Naming Conventions
• Running gnatname
• Switches for gnatname
• Examples of gnatname Usage

$ gnatname [ switches ]  naming_pattern  [ naming_patterns ]
    [--and [ switches ]  naming_pattern  [ naming_patterns ]]

"*.[12].ada"
"*.ad[sb]*"
"body_*"    "spec_*"

$ gnatname -c /home/me/names.adc -d sources "[a-z]*.ada*"

$ gnatname -P/home/me/proj -x "*_nt_body.ada"
-dsources -dsources/plus -Dcommon_dirs.txt "body_*" "spec_*"

3.3.5 File Name Krunching with gnatkr

This section discusses the method used by the compiler to shorten the default file names chosen for Ada units so that they do not exceed the maximum length permitted. It also describes the gnatkr utility that can be used to determine the result of applying this shortening.

• About gnatkr
• Using gnatkr
• Krunching Method
• Examples of gnatkr Usage

$ gnatkr name [ length ]

$ gnatkr very_long_unit_name.ads      --> velounna.ads
$ gnatkr grandparent-parent-child.ads --> grparchi.ads
$ gnatkr Grandparent.Parent.Child.ads --> grparchi.ads
$ gnatkr grandparent-parent-child     --> grparchi
$ gnatkr very_long_unit_name.ads/count=6 --> vlunna.ads
$ gnatkr very_long_unit_name.ads/count=0 --> very_long_unit_name.ads

3.3.6 Renaming Files with gnatchop

This section discusses how to handle files with multiple units by using the gnatchop utility. This utility is also useful in renaming files to meet the standard GNAT default file naming conventions.

• Handling Files with Multiple Units
• Operating gnatchop in Compilation Mode
• Command Line for gnatchop
• Switches for gnatchop
• Examples of gnatchop Usage

$ gnatchop switches file_name [file_name ...]
      [directory]

procedure Hello;

with Ada.Text_IO; use Ada.Text_IO;
procedure Hello is
begin
   Put_Line ("Hello");
end Hello;

$ gnatchop hellofiles

--  Just a comment

$ gnatchop toto.txt

toto.txt:1:01: warning: empty file, contains no compilation units
no compilation units found
no source files written

$ gnatchop -w hello_s.ada prerelease/files

$ gnatchop archive

$ gnatchop file1 file2 file3 direc

3.4.1 Handling of Configuration Pragmas

Configuration pragmas may either appear at the start of a compilation unit, or they can appear in a configuration pragma file to apply to all compilations performed in a given compilation environment.

GNAT also provides the gnatchop utility to provide an automatic way to handle configuration pragmas following the semantics for compilations (that is, files with multiple units), described in the RM. See Operating gnatchop in Compilation Mode for details. However, for most purposes, it will be more convenient to edit the gnat.adc file that contains configuration pragmas directly, as described in the following section.

In the case of Restrictions pragmas appearing as configuration pragmas in individual compilation units, the exact handling depends on the type of restriction.

Restrictions that require partition-wide consistency (like No_Tasking) are recognized wherever they appear and can be freely inherited, e.g. from a `with'ed unit to the `with'ing unit. This makes sense since the binder will in any case insist on seeing consistent use, so any unit not conforming to any restrictions that are anywhere in the partition will be rejected, and you might as well find that out at compile time rather than at bind time.

For restrictions that do not require partition-wide consistency, e.g. SPARK or No_Implementation_Attributes, in general the restriction applies only to the unit in which the pragma appears, and not to any other units.

The exception is No_Elaboration_Code which always applies to the entire object file from a compilation, i.e. to the body, spec, and all subunits. This restriction can be specified in a configuration pragma file, or it can be on the body and/or the spec (in either case it applies to all the relevant units). It can appear on a subunit only if it has previously appeared in the body of spec.

3.4.2 The Configuration Pragmas Files

In GNAT a compilation environment is defined by the current directory at the time that a compile command is given. This current directory is searched for a file whose name is gnat.adc. If this file is present, it is expected to contain one or more configuration pragmas that will be applied to the current compilation. However, if the switch -gnatA is used, gnat.adc is not considered. When taken into account, gnat.adc is added to the dependencies, so that if gnat.adc is modified later, an invocation of gnatmake will recompile the source.

Configuration pragmas may be entered into the gnat.adc file either by running gnatchop on a source file that consists only of configuration pragmas, or more conveniently by direct editing of the gnat.adc file, which is a standard format source file.

Besides gnat.adc, additional files containing configuration pragmas may be applied to the current compilation using the switch -gnatec=`path' where path must designate an existing file that contains only configuration pragmas. These configuration pragmas are in addition to those found in gnat.adc (provided gnat.adc is present and switch -gnatA is not used).

It is allowable to specify several switches -gnatec=, all of which will be taken into account.

Files containing configuration pragmas specified with switches -gnatec= are added to the dependencies, unless they are temporary files. A file is considered temporary if its name ends in .tmp or .TMP. Certain tools follow this naming convention because they pass information to gcc via temporary files that are immediately deleted; it doesn’t make sense to depend on a file that no longer exists. Such tools include gprbuild, gnatmake, and gnatcheck.

By default, configuration pragma files are stored by their absolute paths in ALI files. You can use the -gnateb switch in order to store them by their basename instead.

If you are using project file, a separate mechanism is provided using project attributes.

3.9.1 Introduction to Libraries in GNAT

A library is, conceptually, a collection of objects which does not have its own main thread of execution, but rather provides certain services to the applications that use it. A library can be either statically linked with the application, in which case its code is directly included in the application, or, on platforms that support it, be dynamically linked, in which case its code is shared by all applications making use of this library.

GNAT supports both types of libraries. In the static case, the compiled code can be provided in different ways. The simplest approach is to provide directly the set of objects resulting from compilation of the library source files. Alternatively, you can group the objects into an archive using whatever commands are provided by the operating system. For the latter case, the objects are grouped into a shared library.

In the GNAT environment, a library has three types of components:

• Source files,
• ALI files (see The Ada Library Information Files), and
• Object files, an archive or a shared library.

A GNAT library may expose all its source files, which is useful for documentation purposes. Alternatively, it may expose only the units needed by an external user to make use of the library. That is to say, the specs reflecting the library services along with all the units needed to compile those specs, which can include generic bodies or any body implementing an inlined routine. In the case of `stand-alone libraries' those exposed units are called `interface units' (Stand-alone Ada Libraries).

All compilation units comprising an application, including those in a library, need to be elaborated in an order partially defined by Ada’s semantics. GNAT computes the elaboration order from the ALI files and this is why they constitute a mandatory part of GNAT libraries. `Stand-alone libraries' are the exception to this rule because a specific library elaboration routine is produced independently of the application(s) using the library.

3.9.2 General Ada Libraries

• Building a library
• Installing a library
• Using a library

project My_Lib is
  for Source_Dirs use ("src1", "src2");
  for Object_Dir use "obj";
  for Library_Name use "mylib";
  for Library_Dir use "lib";
  for Library_Kind use "dynamic";
end My_lib;

$ gnatmake -Pmy_lib

with My_Lib.Service1;
with My_Lib.Service2;
with My_Lib.Service3;
procedure My_Lib_Dummy is
begin
   null;
end;

# compiling the library
$ gnatmake -c my_lib_dummy.adb

# we don't need the dummy object itself
$ rm my_lib_dummy.o my_lib_dummy.ali

# create an archive with the remaining objects
$ ar rc libmy_lib.a *.o
# some systems may require "ranlib" to be run as well

# or create a shared library
$ gcc -shared -o libmy_lib.so *.o
# some systems may require the code to have been compiled with -fPIC

# remove the object files that are now in the library
$ rm *.o

# Make the ALI files read-only so that gnatmake will not try to
# regenerate the objects that are in the library
$ chmod -w *.ali

$ gcc -v

with "my_lib";
project My_Proj is
  ...
end My_Proj;

project Liba is
   for Externally_Built use "true";
   for Source_Files use ();
   for Library_Dir use "lib";
   for Library_Name use "a";
   for Library_Kind use "static";
end Liba;

$ gnatmake -aI/dir/my_lib_src -aO/dir/my_lib_obj my_appl \\
  -largs -lmy_lib

$ gnatmake my_appl

3.9.3 Stand-alone Ada Libraries

• Introduction to Stand-alone Libraries
• Building a Stand-alone Library
• Creating a Stand-alone Library to be used in a non-Ada context
• Restrictions in Stand-alone Libraries

for Library_Dir use "lib_dir";
for Library_Name use "dummy";
for Library_Interface use ("int1", "int1.child");

for Library_Dir use "lib_dir";
for Library_Name use "dummy";
for Library_Kind use "dynamic";
for Library_Interface use ("int1", "int1.child");
for Library_Standalone use "encapsulated";

package My_Package is

   procedure Do_Something;
   pragma Export (C, Do_Something, "do_something");

   procedure Do_Something_Else;
   pragma Export (C, Do_Something_Else, "do_something_else");

end My_Package;

/* the library elaboration procedure */
extern void mylibinit (void);

/* the library finalization procedure */
extern void mylibfinal (void);

/* the interface exported by the library */
extern void do_something (void);
extern void do_something_else (void);

#include "mylib_interface.h"

int
main (void)
{
   /* First, elaborate the library before using it */
   mylibinit ();

   /* Main program, using the library exported entities */
   do_something ();
   do_something_else ();

   /* Library finalization at the end of the program */
   mylibfinal ();
   return 0;
}

3.9.4 Rebuilding the GNAT Run-Time Library

It may be useful to recompile the GNAT library in various debugging or experimentation contexts. A project file called libada.gpr is provided to that effect and can be found in the directory containing the GNAT library. The location of this directory depends on the way the GNAT environment has been installed and can be determined by means of the command:

$ gnatls -v

The last entry in the source search path usually contains the gnat library (the adainclude directory). This project file contains its own documentation and in particular the set of instructions needed to rebuild a new library and to use it.

Note that rebuilding the GNAT Run-Time is only recommended for temporary experiments or debugging, and is not supported.

3.10.1 Modeling Conditional Compilation in Ada

It is often necessary to arrange for a single source program to serve multiple purposes, where it is compiled in different ways to achieve these different goals. Some examples of the need for this feature are

• Adapting a program to a different hardware environment
• Adapting a program to a different target architecture
• Turning debugging features on and off
• Arranging for a program to compile with different compilers

In C, or C++, the typical approach would be to use the preprocessor that is defined as part of the language. The Ada language does not contain such a feature. This is not an oversight, but rather a very deliberate design decision, based on the experience that overuse of the preprocessing features in C and C++ can result in programs that are extremely difficult to maintain. For example, if we have ten switches that can be on or off, this means that there are a thousand separate programs, any one of which might not even be syntactically correct, and even if syntactically correct, the resulting program might not work correctly. Testing all combinations can quickly become impossible.

Nevertheless, the need to tailor programs certainly exists, and in this section we will discuss how this can be achieved using Ada in general, and GNAT in particular.

• Use of Boolean Constants
• Debugging - A Special Case
• Conditionalizing Declarations
• Use of Alternative Implementations
• Preprocessing

FP_Initialize_Required : constant Boolean := True;
...
if FP_Initialize_Required then
...
end if;

package Config is
   FP_Initialize_Required : constant Boolean := True;
   Reset_Available        : constant Boolean := False;
   ...
end Config;

if Debugging then
   Put_Line ("got to the first stage!");
end if;

if Debugging and then Temperature > 999.0 then
   raise Temperature_Crazy;
end if;

pragma Assert (Temperature <= 999.0, "Temperature Crazy");

pragma Assert (Temperature <= 999.0);

pragma Debug (Put_Line ("got to the first stage!"));

if ... then
   ... -- some statements
else
   pragma Assert (Num_Cases < 10);
   null;
end if;

if Small_Machine then
   declare
      X : Bit_String (1 .. 10);
   begin
      ...
   end;
else
   declare
      X : Large_Bit_String (1 .. 1000);
   begin
      ...
   end;
end if;

for Rec use
  Field1 at 0 range Boolean'Pos (Little_Endian) * 10 .. Bits_Per_Word;
end record;

for Rec use
  Field1 at 0 range 0 .. 32;
end record;

for Rec use record
    Field1 at 0 range 10 .. 32;
end record;

if Ada_2005 then
   ... neat Ada 2005 code
else
   ... not quite as neat Ada 95 code
end if;

procedure Insert is separate;

for body ("File_Queries.Insert") use "file_queries-insert-2005.ada";

#if DEBUG or else (PRIORITY > 4) then
   sequence of declarations
#else
   completely different sequence of declarations
#end if;

3.10.2 Preprocessing with gnatprep

This section discusses how to use GNAT’s gnatprep utility for simple preprocessing. Although designed for use with GNAT, gnatprep does not depend on any special GNAT features. For further discussion of conditional compilation in general, see Conditional Compilation.

• Preprocessing Symbols
• Using gnatprep
• Switches for gnatprep
• Form of Definitions File
• Form of Input Text for gnatprep

$ gnatprep [ switches ] infile outfile [ deffile ]

symbol := value

#if <expression> [then]
   lines
#elsif <expression> [then]
   lines
#elsif <expression> [then]
   lines
...
#else
   lines
#end if;

<expression> ::=  <symbol>
<expression> ::=  <symbol> = "<value>"
<expression> ::=  <symbol> = <symbol>
<expression> ::=  <symbol> = <integer>
<expression> ::=  <symbol> > <integer>
<expression> ::=  <symbol> >= <integer>
<expression> ::=  <symbol> < <integer>
<expression> ::=  <symbol> <= <integer>
<expression> ::=  <symbol> 'Defined
<expression> ::=  not <expression>
<expression> ::=  <expression> and <expression>
<expression> ::=  <expression> or <expression>
<expression> ::=  <expression> and then <expression>
<expression> ::=  <expression> or else <expression>
<expression> ::=  ( <expression> )

not X or Y

(not X) or Y
not (X or Y)

$symbol

Header : String := "$XYZ";

Header : String := $XYZ;

3.10.3 Integrated Preprocessing

As noted above, a file to be preprocessed consists of Ada source code in which preprocessing lines have been inserted. However, instead of using gnatprep to explicitly preprocess a file as a separate step before compilation, you can carry out the preprocessing implicitly as part of compilation. Such `integrated preprocessing', which is the common style with C, is performed when either or both of the following switches are passed to the compiler:

• -gnatep, which specifies the `preprocessor data file'. This file dictates how the source files will be preprocessed (e.g., which symbol definition files apply to which sources).
• -gnateD, which defines values for preprocessing symbols.

Integrated preprocessing applies only to Ada source files, it is not available for configuration pragma files.

With integrated preprocessing, the output from the preprocessor is not, by default, written to any external file. Instead it is passed internally to the compiler. To preserve the result of preprocessing in a file, either run gnatprep in standalone mode or else supply the -gnateG switch (described below) to the compiler.

When using project files:

• the builder switch -x should be used if any Ada source is compiled with gnatep=, so that the compiler finds the `preprocessor data file'.
• the preprocessing data file and the symbol definition files should be located in the source directories of the project.

Note that the gnatmake switch -m will almost always trigger recompilation for sources that are preprocessed, because gnatmake cannot compute the checksum of the source after preprocessing.

The actual preprocessing function is described in detail in Preprocessing with gnatprep. This section explains the switches that relate to integrated preprocessing.

-gnatep=`preprocessor_data_file'

This switch specifies the file name (without directory information) of the preprocessor data file. Either place this file in one of the source directories, or, when using project files, reference the project file’s directory via the project_name'Project_Dir project attribute; e.g:

project Prj is
   package Compiler is
      for Switches ("Ada") use
        ("-gnatep=" & Prj'Project_Dir & "prep.def");
   end Compiler;
end Prj;

A preprocessor data file is a text file that contains `preprocessor control lines'. A preprocessor control line directs the preprocessing of either a particular source file, or, analogous to others in Ada, all sources not specified elsewhere in the preprocessor data file. A preprocessor control line can optionally identify a `definition file' that assigns values to preprocessor symbols, as well as a list of switches that relate to preprocessing. Empty lines and comments (using Ada syntax) are also permitted, with no semantic effect.

Here’s an example of a preprocessor data file:

"toto.adb"  "prep.def" -u
--  Preprocess toto.adb, using definition file prep.def
--  Undefined symbols are treated as False

* -c -DVERSION=V101
--  Preprocess all other sources without using a definition file
--  Suppressed lined are commented
--  Symbol VERSION has the value V101

"tata.adb" "prep2.def" -s
--  Preprocess tata.adb, using definition file prep2.def
--  List all symbols with their values

A preprocessor control line has the following syntax:

<preprocessor_control_line> ::=
   <preprocessor_input> [ <definition_file_name> ] { <switch> }

<preprocessor_input> ::= <source_file_name> | '*'

<definition_file_name> ::= <string_literal>

<source_file_name> := <string_literal>

<switch> := (See below for list)

Thus each preprocessor control line starts with either a literal string or the character ‘*’:

• A literal string is the file name (without directory information) of the source file that will be input to the preprocessor.
• The character ‘*’ is a wild-card indicator; the additional parameters on the line indicate the preprocessing for all the sources that are not specified explicitly on other lines (the order of the lines is not significant).

It is an error to have two lines with the same file name or two lines starting with the character ‘*’.

After the file name or ‘*’, an optional literal string specifies the name of the definition file to be used for preprocessing (Form of Definitions File). The definition files are found by the compiler in one of the source directories. In some cases, when compiling a source in a directory other than the current directory, if the definition file is in the current directory, it may be necessary to add the current directory as a source directory through the -I switch; otherwise the compiler would not find the definition file.

Finally, switches similar to those of gnatprep may optionally appear:

-b

Causes both preprocessor lines and the lines deleted by preprocessing to be replaced by blank lines, preserving the line number. This switch is always implied; however, if specified after -c it cancels the effect of -c.

-c

Causes both preprocessor lines and the lines deleted by preprocessing to be retained as comments marked with the special string ‘–!’.

-D`symbol'=`new_value'

Define or redefine symbol to have new_value as its value. The permitted form for symbol is either an Ada identifier, or any Ada reserved word aside from if, else, elsif, end, and, or and then. The permitted form for new_value is a literal string, an Ada identifier or any Ada reserved word. A symbol declared with this switch replaces a symbol with the same name defined in a definition file.

-s

Causes a sorted list of symbol names and values to be listed on the standard output file.

-u

Causes undefined symbols to be treated as having the value FALSE in the context of a preprocessor test. In the absence of this option, an undefined symbol in a #if or #elsif test will be treated as an error.

-gnateD`symbol'[=`new_value']

Define or redefine symbol to have new_value as its value. If no value is supplied, then the value of symbol is True. The form of symbol is an identifier, following normal Ada (case-insensitive) rules for its syntax, and new_value is either an arbitrary string between double quotes or any sequence (including an empty sequence) of characters from the set (letters, digits, period, underline). Ada reserved words may be used as symbols, with the exceptions of if, else, elsif, end, and, or and then.

Examples:

-gnateDToto=Tata
-gnateDFoo
-gnateDFoo=\"Foo-Bar\"

A symbol declared with this switch on the command line replaces a symbol with the same name either in a definition file or specified with a switch -D in the preprocessor data file.

This switch is similar to switch -D of gnatprep.

-gnateG

When integrated preprocessing is performed on source file filename.extension, create or overwrite filename.extension.prep to contain the result of the preprocessing. For example if the source file is foo.adb then the output file will be foo.adb.prep.

3.11.1 Interfacing to C

Interfacing Ada with a foreign language such as C involves using compiler directives to import and/or export entity definitions in each language – using extern statements in C, for instance, and the Import, Export, and Convention pragmas in Ada. A full treatment of these topics is provided in Appendix B, section 1 of the Ada Reference Manual.

There are two ways to build a program using GNAT that contains some Ada sources and some foreign language sources, depending on whether or not the main subprogram is written in Ada. Here is a source example with the main subprogram in Ada:

/* file1.c */
#include <stdio.h>

void print_num (int num)
{
  printf ("num is %d.\\n", num);
  return;
}

/* file2.c */

/* num_from_Ada is declared in my_main.adb */
extern int num_from_Ada;

int get_num (void)
{
  return num_from_Ada;
}

--  my_main.adb
procedure My_Main is

   --  Declare then export an Integer entity called num_from_Ada
   My_Num : Integer := 10;
   pragma Export (C, My_Num, "num_from_Ada");

   --  Declare an Ada function spec for Get_Num, then use
   --  C function get_num for the implementation.
   function Get_Num return Integer;
   pragma Import (C, Get_Num, "get_num");

   --  Declare an Ada procedure spec for Print_Num, then use
   --  C function print_num for the implementation.
   procedure Print_Num (Num : Integer);
   pragma Import (C, Print_Num, "print_num");

begin
   Print_Num (Get_Num);
end My_Main;

To build this example:

• First compile the foreign language files to generate object files:

  $ gcc -c file1.c
  $ gcc -c file2.c
  

• Then, compile the Ada units to produce a set of object files and ALI files:

  $ gnatmake -c my_main.adb
  

• Run the Ada binder on the Ada main program:

  $ gnatbind my_main.ali
  

• Link the Ada main program, the Ada objects and the other language objects:

  $ gnatlink my_main.ali file1.o file2.o
  

The last three steps can be grouped in a single command:

$ gnatmake my_main.adb -largs file1.o file2.o

If the main program is in a language other than Ada, then you may have more than one entry point into the Ada subsystem. You must use a special binder option to generate callable routines that initialize and finalize the Ada units (Binding with Non-Ada Main Programs). Calls to the initialization and finalization routines must be inserted in the main program, or some other appropriate point in the code. The call to initialize the Ada units must occur before the first Ada subprogram is called, and the call to finalize the Ada units must occur after the last Ada subprogram returns. The binder will place the initialization and finalization subprograms into the b~xxx.adb file where they can be accessed by your C sources. To illustrate, we have the following example:

/* main.c */
extern void adainit (void);
extern void adafinal (void);
extern int add (int, int);
extern int sub (int, int);

int main (int argc, char *argv[])
{
   int a = 21, b = 7;

   adainit();

   /* Should print "21 + 7 = 28" */
   printf ("%d + %d = %d\\n", a, b, add (a, b));

   /* Should print "21 - 7 = 14" */
   printf ("%d - %d = %d\\n", a, b, sub (a, b));

   adafinal();
}

--  unit1.ads
package Unit1 is
   function Add (A, B : Integer) return Integer;
   pragma Export (C, Add, "add");
end Unit1;

--  unit1.adb
package body Unit1 is
   function Add (A, B : Integer) return Integer is
   begin
      return A + B;
   end Add;
end Unit1;

--  unit2.ads
package Unit2 is
   function Sub (A, B : Integer) return Integer;
   pragma Export (C, Sub, "sub");
end Unit2;

--  unit2.adb
package body Unit2 is
   function Sub (A, B : Integer) return Integer is
   begin
      return A - B;
   end Sub;
end Unit2;

The build procedure for this application is similar to the last example’s:

• First, compile the foreign language files to generate object files:

  $ gcc -c main.c
  

• Next, compile the Ada units to produce a set of object files and ALI files:

  $ gnatmake -c unit1.adb
  $ gnatmake -c unit2.adb
  

• Run the Ada binder on every generated ALI file. Make sure to use the -n option to specify a foreign main program:

  $ gnatbind -n unit1.ali unit2.ali
  

• Link the Ada main program, the Ada objects and the foreign language objects. You need only list the last ALI file here:

  $ gnatlink unit2.ali main.o -o exec_file
  

  This procedure yields a binary executable called exec_file.

Depending on the circumstances (for example when your non-Ada main object does not provide symbol main), you may also need to instruct the GNAT linker not to include the standard startup objects by passing the -nostartfiles switch to gnatlink.

3.11.2 Calling Conventions

GNAT follows standard calling sequence conventions and will thus interface to any other language that also follows these conventions. The following Convention identifiers are recognized by GNAT:

Ada

This indicates that the standard Ada calling sequence will be used and all Ada data items may be passed without any limitations in the case where GNAT is used to generate both the caller and callee. It is also possible to mix GNAT generated code and code generated by another Ada compiler. In this case, the data types should be restricted to simple cases, including primitive types. Whether complex data types can be passed depends on the situation. Probably it is safe to pass simple arrays, such as arrays of integers or floats. Records may or may not work, depending on whether both compilers lay them out identically. Complex structures involving variant records, access parameters, tasks, or protected types, are unlikely to be able to be passed.

Note that in the case of GNAT running on a platform that supports HP Ada 83, a higher degree of compatibility can be guaranteed, and in particular records are laid out in an identical manner in the two compilers. Note also that if output from two different compilers is mixed, the program is responsible for dealing with elaboration issues. Probably the safest approach is to write the main program in the version of Ada other than GNAT, so that it takes care of its own elaboration requirements, and then call the GNAT-generated adainit procedure to ensure elaboration of the GNAT components. Consult the documentation of the other Ada compiler for further details on elaboration.

However, it is not possible to mix the tasking run time of GNAT and HP Ada 83, All the tasking operations must either be entirely within GNAT compiled sections of the program, or entirely within HP Ada 83 compiled sections of the program.

Assembler

Specifies assembler as the convention. In practice this has the same effect as convention Ada (but is not equivalent in the sense of being considered the same convention).

Asm

Equivalent to Assembler.

COBOL

Data will be passed according to the conventions described in section B.4 of the Ada Reference Manual.

C

Data will be passed according to the conventions described in section B.3 of the Ada Reference Manual.

A note on interfacing to a C ‘varargs’ function:

In C, varargs allows a function to take a variable number of arguments. There is no direct equivalent in this to Ada. One approach that can be used is to create a C wrapper for each different profile and then interface to this C wrapper. For example, to print an int value using printf, create a C function printfi that takes two arguments, a pointer to a string and an int, and calls printf. Then in the Ada program, use pragma Import to interface to printfi.

It may work on some platforms to directly interface to a varargs function by providing a specific Ada profile for a particular call. However, this does not work on all platforms, since there is no guarantee that the calling sequence for a two argument normal C function is the same as for calling a varargs C function with the same two arguments.

Default

Equivalent to C.

External

Equivalent to C.

C_Plus_Plus (or CPP)

This stands for C++. For most purposes this is identical to C. See the separate description of the specialized GNAT pragmas relating to C++ interfacing for further details.

Fortran

Data will be passed according to the conventions described in section B.5 of the Ada Reference Manual.

Intrinsic

This applies to an intrinsic operation, as defined in the Ada Reference Manual. If a pragma Import (Intrinsic) applies to a subprogram, this means that the body of the subprogram is provided by the compiler itself, usually by means of an efficient code sequence, and that the user does not supply an explicit body for it. In an application program, the pragma may be applied to the following sets of names:

• Rotate_Left, Rotate_Right, Shift_Left, Shift_Right, Shift_Right_Arithmetic. The corresponding subprogram declaration must have two formal parameters. The first one must be a signed integer type or a modular type with a binary modulus, and the second parameter must be of type Natural. The return type must be the same as the type of the first argument. The size of this type can only be 8, 16, 32, or 64.
• Binary arithmetic operators: ‘+’, ‘-‘, ‘*’, ‘/’. The corresponding operator declaration must have parameters and result type that have the same root numeric type (for example, all three are long_float types). This simplifies the definition of operations that use type checking to perform dimensional checks:

  type Distance is new Long_Float;
  type Time     is new Long_Float;
  type Velocity is new Long_Float;
  function "/" (D : Distance; T : Time)
    return Velocity;
  pragma Import (Intrinsic, "/");

This common idiom is often programmed with a generic definition and an
explicit body. The pragma makes it simpler to introduce such declarations.
It incurs no overhead in compilation time or code size, because it is
implemented as a single machine instruction.

• General subprogram entities. This is used to bind an Ada subprogram declaration to a compiler builtin by name with back-ends where such interfaces are available. A typical example is the set of __builtin functions exposed by the GCC back-end, as in the following example:

  function builtin_sqrt (F : Float) return Float;
  pragma Import (Intrinsic, builtin_sqrt, "__builtin_sqrtf");
  

  Most of the GCC builtins are accessible this way, and as for other import conventions (e.g. C), it is the user’s responsibility to ensure that the Ada subprogram profile matches the underlying builtin expectations.

Stdcall

This is relevant only to Windows implementations of GNAT, and specifies that the Stdcall calling sequence will be used, as defined by the NT API. Nevertheless, to ease building cross-platform bindings this convention will be handled as a C calling convention on non-Windows platforms.

DLL

This is equivalent to Stdcall.

Win32

This is equivalent to Stdcall.

Stubbed

This is a special convention that indicates that the compiler should provide a stub body that raises Program_Error.

GNAT additionally provides a useful pragma Convention_Identifier that can be used to parameterize conventions and allow additional synonyms to be specified. For example if you have legacy code in which the convention identifier Fortran77 was used for Fortran, you can use the configuration pragma:

pragma Convention_Identifier (Fortran77, Fortran);

And from now on the identifier Fortran77 may be used as a convention identifier (for example in an Import pragma) with the same meaning as Fortran.

3.11.3 Building Mixed Ada and C++ Programs

A programmer inexperienced with mixed-language development may find that building an application containing both Ada and C++ code can be a challenge. This section gives a few hints that should make this task easier.

• Interfacing to C++
• Linking a Mixed C++ & Ada Program
• A Simple Example
• Interfacing with C++ constructors
• Interfacing with C++ at the Class Level

$ gnatmake -c simple_cpp_interface
$ g++ -c cpp_main.C
$ g++ -c ex7.C
$ gnatbind -n simple_cpp_interface
$ gnatlink simple_cpp_interface -o cpp_main --LINK=g++ -lstdc++ ex7.o cpp_main.o

//cpp_main.C

#include "ex7.h"

extern "C" {
  void adainit (void);
  void adafinal (void);
  void method1 (A *t);
}

void method1 (A *t)
{
  t->method1 ();
}

int main ()
{
  A obj;
  adainit ();
  obj.method2 (3030);
  adafinal ();
}

//ex7.h

class Origin {
 public:
  int o_value;
};
class A : public Origin {
 public:
  void method1 (void);
  void method2 (int v);
  A();
  int   a_value;
};

//ex7.C

#include "ex7.h"
#include <stdio.h>

extern "C" { void ada_method2 (A *t, int v);}

void A::method1 (void)
{
  a_value = 2020;
  printf ("in A::method1, a_value = %d \\n",a_value);
}

void A::method2 (int v)
{
   ada_method2 (this, v);
   printf ("in A::method2, a_value = %d \\n",a_value);
}

A::A(void)
{
   a_value = 1010;
  printf ("in A::A, a_value = %d \\n",a_value);
}

-- simple_cpp_interface.ads
with System;
package Simple_Cpp_Interface is
   type A is limited
      record
         Vptr    : System.Address;
         O_Value : Integer;
         A_Value : Integer;
      end record;
   pragma Convention (C, A);

   procedure Method1 (This : in out A);
   pragma Import (C, Method1);

   procedure Ada_Method2 (This : in out A; V : Integer);
   pragma Export (C, Ada_Method2);

end Simple_Cpp_Interface;

-- simple_cpp_interface.adb
package body Simple_Cpp_Interface is

   procedure Ada_Method2 (This : in out A; V : Integer) is
   begin
      Method1 (This);
      This.A_Value := V;
   end Ada_Method2;

end Simple_Cpp_Interface;

class Root {
public:
  int  a_value;
  int  b_value;
  virtual int Get_Value ();
  Root();              // Default constructor
  Root(int v);         // 1st non-default constructor
  Root(int v, int w);  // 2nd non-default constructor
};

with Interfaces.C; use Interfaces.C;
package Pkg_Root is
  type Root is tagged limited record
     A_Value : int;
     B_Value : int;
  end record;
  pragma Import (CPP, Root);

  function Get_Value (Obj : Root) return int;
  pragma Import (CPP, Get_Value);

  function Constructor return Root;
  pragma Cpp_Constructor (Constructor, "_ZN4RootC1Ev");

  function Constructor (v : Integer) return Root;
  pragma Cpp_Constructor (Constructor, "_ZN4RootC1Ei");

  function Constructor (v, w : Integer) return Root;
  pragma Cpp_Constructor (Constructor, "_ZN4RootC1Eii");
end Pkg_Root;

Obj1 : Root;
Obj2 : Root := Constructor;
Obj3 : Root := Constructor (v => 10);
Obj4 : Root := Constructor (30, 40);

type DT is new Root with record
   C_Value : Natural := 2009;
end record;

Obj5 : DT;
Obj6 : DT := Function_Returning_DT (50);
Obj7 : DT := (Constructor (30,40) with C_Value => 50);

type Rec1 is limited record
   Data1 : Root := Constructor (10);
   Value : Natural := 1000;
end record;

type Rec2 (D : Integer := 20) is limited record
   Rec   : Rec1;
   Data2 : Root := Constructor (D, 30);
end record;

Obj8 : Rec2 (40);

Obj9 : Rec2 := (Rec => (Data1 => Constructor (15, 16),
                        others => <>),
                others => <>);

function Constructor (V : Integer) return Rec2 is
begin
   return Obj : Rec2 := (Rec => (Data1  => Constructor (V, 20),
                                 others => <>),
                         others => <>) do
      --  Further actions required for construction of
      --  objects of type Rec2
      ...
   end record;
end Constructor;

class Animal {
 public:
   virtual void Set_Age (int New_Age);
   virtual int Age ();
   Animal() {Age_Count = 0;};
 private:
   int Age_Count;
};

class Carnivore {
public:
   virtual int Number_Of_Teeth () = 0;
};

class Domestic {
public:
   virtual void Set_Owner (char* Name) = 0;
};

class Dog : Animal, Carnivore, Domestic {
 public:
   virtual int  Number_Of_Teeth ();
   virtual void Set_Owner (char* Name);

   Dog(); // Constructor
 private:
   int  Tooth_Count;
   char *Owner;
};

with Interfaces.C.Strings; use Interfaces.C.Strings;
package Animals is
  type Carnivore is limited interface;
  pragma Convention (C_Plus_Plus, Carnivore);
  function Number_Of_Teeth (X : Carnivore)
     return Natural is abstract;

  type Domestic is limited interface;
  pragma Convention (C_Plus_Plus, Domestic);
  procedure Set_Owner
    (X    : in out Domestic;
     Name : Chars_Ptr) is abstract;

  type Animal is tagged limited record
    Age : Natural;
  end record;
  pragma Import (C_Plus_Plus, Animal);

  procedure Set_Age (X : in out Animal; Age : Integer);
  pragma Import (C_Plus_Plus, Set_Age);

  function Age (X : Animal) return Integer;
  pragma Import (C_Plus_Plus, Age);

  function New_Animal return Animal;
  pragma CPP_Constructor (New_Animal);
  pragma Import (CPP, New_Animal, "_ZN6AnimalC1Ev");

  type Dog is new Animal and Carnivore and Domestic with record
    Tooth_Count : Natural;
    Owner       : Chars_Ptr;
  end record;
  pragma Import (C_Plus_Plus, Dog);

  function Number_Of_Teeth (A : Dog) return Natural;
  pragma Import (C_Plus_Plus, Number_Of_Teeth);

  procedure Set_Owner (A : in out Dog; Name : Chars_Ptr);
  pragma Import (C_Plus_Plus, Set_Owner);

  function New_Dog return Dog;
  pragma CPP_Constructor (New_Dog);
  pragma Import (CPP, New_Dog, "_ZN3DogC2Ev");
end Animals;

with Animals; use Animals;
package Vaccinated_Animals is
  type Vaccinated_Dog is new Dog with null record;
  function Vaccination_Expired (A : Vaccinated_Dog) return Boolean;
end Vaccinated_Animals;

with Interfaces.C.Strings;
use Interfaces.C.Strings;
package Animals is
  type Carnivore is limited interface;
  pragma Convention (C_Plus_Plus, Carnivore);
  function Number_Of_Teeth (X : Carnivore)
     return Natural is abstract;

  type Domestic is limited interface;
  pragma Convention (C_Plus_Plus, Domestic);
  procedure Set_Owner
    (X    : in out Domestic;
     Name : Chars_Ptr) is abstract;

  type Animal is tagged record
    Age : Natural;
  end record;
  pragma Convention (C_Plus_Plus, Animal);

  procedure Set_Age (X : in out Animal; Age : Integer);
  pragma Export (C_Plus_Plus, Set_Age);

  function Age (X : Animal) return Integer;
  pragma Export (C_Plus_Plus, Age);

  function New_Animal return Animal'Class;
  pragma Export (C_Plus_Plus, New_Animal);

  type Dog is new Animal and Carnivore and Domestic with record
    Tooth_Count : Natural;
    Owner       : String (1 .. 30);
  end record;
  pragma Convention (C_Plus_Plus, Dog);

  function Number_Of_Teeth (A : Dog) return Natural;
  pragma Export (C_Plus_Plus, Number_Of_Teeth);

  procedure Set_Owner (A : in out Dog; Name : Chars_Ptr);
  pragma Export (C_Plus_Plus, Set_Owner);

  function New_Dog return Dog'Class;
  pragma Export (C_Plus_Plus, New_Dog);
end Animals;

#include "animals.h"
#include <iostream>
using namespace std;

void Check_Carnivore (Carnivore *obj) {...}
void Check_Domestic (Domestic *obj)   {...}
void Check_Animal (Animal *obj)       {...}
void Check_Dog (Dog *obj)             {...}

extern "C" {
  void adainit (void);
  void adafinal (void);
  Dog* new_dog ();
}

void test ()
{
  Dog *obj = new_dog();  // Ada constructor
  Check_Carnivore (obj); // Check secondary DT
  Check_Domestic (obj);  // Check secondary DT
  Check_Animal (obj);    // Check primary DT
  Check_Dog (obj);       // Check primary DT
}

int main ()
{
  adainit ();  test();  adafinal ();
  return 0;
}

3.11.4 Generating Ada Bindings for C and C++ headers

GNAT includes a binding generator for C and C++ headers which is intended to do 95% of the tedious work of generating Ada specs from C or C++ header files.

Note that this capability is not intended to generate 100% correct Ada specs, and will is some cases require manual adjustments, although it can often be used out of the box in practice.

Some of the known limitations include:

• only very simple character constant macros are translated into Ada constants. Function macros (macros with arguments) are partially translated as comments, to be completed manually if needed.
• some extensions (e.g. vector types) are not supported
• pointers to pointers are mapped to System.Address
• identifiers with identical name (except casing) may generate compilation errors (e.g. shm_get vs SHM_GET).

The code is generated using Ada 2012 syntax, which makes it easier to interface with other languages. In most cases you can still use the generated binding even if your code is compiled using earlier versions of Ada (e.g. -gnat95).

• Running the Binding Generator
• Generating Bindings for C++ Headers
• Switches

$ gcc -c -fdump-ada-spec -C /usr/include/time.h
$ gcc -c *.ads

$ gcc -c -fdump-ada-spec -DXLIB_ILLEGAL_ACCESS -C /usr/include/X11/Xlib.h

#include <stdio.h>
#include <readline/readline.h>

$ gcc -c -fdump-ada-spec readline1.h

class Carnivore {
public:
   virtual int Number_Of_Teeth () = 0;
};

class Domestic {
public:
   virtual void Set_Owner (char* Name) = 0;
};

class Animal {
public:
  int Age_Count;
  virtual void Set_Age (int New_Age);
};

class Dog : Animal, Carnivore, Domestic {
 public:
  int  Tooth_Count;
  char *Owner;

  virtual int  Number_Of_Teeth ();
  virtual void Set_Owner (char* Name);

  Dog();
};

package Class_Carnivore is
  type Carnivore is limited interface;
  pragma Import (CPP, Carnivore);

  function Number_Of_Teeth (this : access Carnivore) return int is abstract;
end;
use Class_Carnivore;

package Class_Domestic is
  type Domestic is limited interface;
  pragma Import (CPP, Domestic);

  procedure Set_Owner
    (this : access Domestic;
     Name : Interfaces.C.Strings.chars_ptr) is abstract;
end;
use Class_Domestic;

package Class_Animal is
  type Animal is tagged limited record
    Age_Count : aliased int;
  end record;
  pragma Import (CPP, Animal);

  procedure Set_Age (this : access Animal; New_Age : int);
  pragma Import (CPP, Set_Age, "_ZN6Animal7Set_AgeEi");
end;
use Class_Animal;

package Class_Dog is
  type Dog is new Animal and Carnivore and Domestic with record
    Tooth_Count : aliased int;
    Owner : Interfaces.C.Strings.chars_ptr;
  end record;
  pragma Import (CPP, Dog);

  function Number_Of_Teeth (this : access Dog) return int;
  pragma Import (CPP, Number_Of_Teeth, "_ZN3Dog15Number_Of_TeethEv");

  procedure Set_Owner
    (this : access Dog; Name : Interfaces.C.Strings.chars_ptr);
  pragma Import (CPP, Set_Owner, "_ZN3Dog9Set_OwnerEPc");

  function New_Dog return Dog;
  pragma CPP_Constructor (New_Dog);
  pragma Import (CPP, New_Dog, "_ZN3DogC1Ev");
end;
use Class_Dog;

3.11.5 Generating C Headers for Ada Specifications

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:

• Scalar types
• Constrained arrays
• Records (untagged)
• Composition of the above types
• Constant declarations
• Object declarations
• Subprogram declarations

• Running the C Header Generator

$ gcc -c -gnatceg pack1.ads

package Pack2 is
   type Int is range 1 .. 10;
end Pack2;

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;

/* 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 */

3.12.1 Comparison between GNAT and C/C++ Compilation Models

The GNAT model of compilation is close to the C and C++ models. You can think of Ada specs as corresponding to header files in C. As in C, you don’t need to compile specs; they are compiled when they are used. The Ada `with' is similar in effect to the #include of a C header.

One notable difference is that, in Ada, you may compile specs separately to check them for semantic and syntactic accuracy. This is not always possible with C headers because they are fragments of programs that have less specific syntactic or semantic rules.

The other major difference is the requirement for running the binder, which performs two important functions. First, it checks for consistency. In C or C++, the only defense against assembling inconsistent programs lies outside the compiler, in a makefile, for example. The binder satisfies the Ada requirement that it be impossible to construct an inconsistent program when the compiler is used in normal mode.

The other important function of the binder is to deal with elaboration issues. There are also elaboration issues in C++ that are handled automatically. This automatic handling has the advantage of being simpler to use, but the C++ programmer has no control over elaboration. Where gnatbind might complain there was no valid order of elaboration, a C++ compiler would simply construct a program that malfunctioned at run time.

3.12.2 Comparison between GNAT and Conventional Ada Library Models

This section is intended for Ada programmers who have used an Ada compiler implementing the traditional Ada library model, as described in the Ada Reference Manual.

In GNAT, there is no ‘library’ in the normal sense. Instead, the set of source files themselves acts as the library. Compiling Ada programs does not generate any centralized information, but rather an object file and a ALI file, which are of interest only to the binder and linker. In a traditional system, the compiler reads information not only from the source file being compiled, but also from the centralized library. This means that the effect of a compilation depends on what has been previously compiled. In particular:

• When a unit is `with'ed, the unit seen by the compiler corresponds to the version of the unit most recently compiled into the library.
• Inlining is effective only if the necessary body has already been compiled into the library.
• Compiling a unit may obsolete other units in the library.

In GNAT, compiling one unit never affects the compilation of any other units because the compiler reads only source files. Only changes to source files can affect the results of a compilation. In particular:

• When a unit is `with'ed, the unit seen by the compiler corresponds to the source version of the unit that is currently accessible to the compiler.
• Inlining requires the appropriate source files for the package or subprogram bodies to be available to the compiler. Inlining is always effective, independent of the order in which units are compiled.
• Compiling a unit never affects any other compilations. The editing of sources may cause previous compilations to be out of date if they depended on the source file being modified.

The most important result of these differences is that order of compilation is never significant in GNAT. There is no situation in which one is required to do one compilation before another. What shows up as order of compilation requirements in the traditional Ada library becomes, in GNAT, simple source dependencies; in other words, there is only a set of rules saying what source files must be present when a file is compiled.

3.13.1 Using Other Utility Programs with GNAT

The object files generated by GNAT are in standard system format and in particular the debugging information uses this format. This means programs generated by GNAT can be used with existing utilities that depend on these formats.

In general, any utility program that works with C will also often work with Ada programs generated by GNAT. This includes software utilities such as gprof (a profiling program), gdb (the FSF debugger), and utilities such as Purify.

3.13.2 The External Symbol Naming Scheme of GNAT

In order to interpret the output from GNAT, when using tools that are originally intended for use with other languages, it is useful to understand the conventions used to generate link names from the Ada entity names.

All link names are in all lowercase letters. With the exception of library procedure names, the mechanism used is simply to use the full expanded Ada name with dots replaced by double underscores. For example, suppose we have the following package spec:

package QRS is
   MN : Integer;
end QRS;

The variable MN has a full expanded Ada name of QRS.MN, so the corresponding link name is qrs__mn. Of course if a pragma Export is used this may be overridden:

package Exports is
   Var1 : Integer;
   pragma Export (Var1, C, External_Name => "var1_name");
   Var2 : Integer;
   pragma Export (Var2, C, Link_Name => "var2_link_name");
end Exports;

In this case, the link name for Var1 is whatever link name the C compiler would assign for the C function var1_name. This typically would be either var1_name or _var1_name, depending on operating system conventions, but other possibilities exist. The link name for Var2 is var2_link_name, and this is not operating system dependent.

One exception occurs for library level procedures. A potential ambiguity arises between the required name _main for the C main program, and the name we would otherwise assign to an Ada library level procedure called Main (which might well not be the main program).

To avoid this ambiguity, we attach the prefix _ada_ to such names. So if we have a library level procedure such as:

procedure Hello (S : String);

the external name of this procedure will be _ada_hello.

4.1.1 Running gnatmake

The usual form of the gnatmake command is

$ gnatmake [<switches>] <file_name> [<file_names>] [<mode_switches>]

The only required argument is one file_name, which specifies a compilation unit that is a main program. Several file_names can be specified: this will result in several executables being built. If switches are present, they can be placed before the first file_name, between file_names or after the last file_name. If mode_switches are present, they must always be placed after the last file_name and all switches.

If you are using standard file extensions (.adb and .ads), then the extension may be omitted from the file_name arguments. However, if you are using non-standard extensions, then it is required that the extension be given. A relative or absolute directory path can be specified in a file_name, in which case, the input source file will be searched for in the specified directory only. Otherwise, the input source file will first be searched in the directory where gnatmake was invoked and if it is not found, it will be search on the source path of the compiler as described in Search Paths and the Run-Time Library (RTL).

All gnatmake output (except when you specify -M) is sent to stderr. The output produced by the -M switch is sent to stdout.

4.1.2 Switches for gnatmake

You may specify any of the following switches to gnatmake:

--version

Display Copyright and version, then exit disregarding all other options.

--help

If --version was not used, display usage, then exit disregarding all other options.

--GCC=`compiler_name'

Program used for compiling. The default is gcc. You need to use quotes around compiler_name if compiler_name contains spaces or other separator characters. As an example --GCC="foo -x -y" will instruct gnatmake to use foo -x -y as your compiler. A limitation of this syntax is that the name and path name of the executable itself must not include any embedded spaces. Note that switch -c is always inserted after your command name. Thus in the above example the compiler command that will be used by gnatmake will be foo -c -x -y. If several --GCC=compiler_name are used, only the last compiler_name is taken into account. However, all the additional switches are also taken into account. Thus, --GCC="foo -x -y" --GCC="bar -z -t" is equivalent to --GCC="bar -x -y -z -t".

--GNATBIND=`binder_name'

Program used for binding. The default is gnatbind. You need to use quotes around binder_name if binder_name contains spaces or other separator characters. As an example --GNATBIND="bar -x -y" will instruct gnatmake to use bar -x -y as your binder. Binder switches that are normally appended by gnatmake to gnatbind are now appended to the end of bar -x -y. A limitation of this syntax is that the name and path name of the executable itself must not include any embedded spaces.

--GNATLINK=`linker_name'

Program used for linking. The default is gnatlink. You need to use quotes around linker_name if linker_name contains spaces or other separator characters. As an example --GNATLINK="lan -x -y" will instruct gnatmake to use lan -x -y as your linker. Linker switches that are normally appended by gnatmake to gnatlink are now appended to the end of lan -x -y. A limitation of this syntax is that the name and path name of the executable itself must not include any embedded spaces.

--create-map-file

When linking an executable, create a map file. The name of the map file has the same name as the executable with extension “.map”.

--create-map-file=`mapfile'

When linking an executable, create a map file with the specified name.

--create-missing-dirs

When using project files (-P`project'), automatically create missing object directories, library directories and exec directories.

--single-compile-per-obj-dir

Disallow simultaneous compilations in the same object directory when project files are used.

--subdirs=`subdir'

Actual object directory of each project file is the subdirectory subdir of the object directory specified or defaulted in the project file.

--unchecked-shared-lib-imports

By default, shared library projects are not allowed to import static library projects. When this switch is used on the command line, this restriction is relaxed.

--source-info=`source info file'

Specify a source info file. This switch is active only when project files are used. If the source info file is specified as a relative path, then it is relative to the object directory of the main project. If the source info file does not exist, then after the Project Manager has successfully parsed and processed the project files and found the sources, it creates the source info file. If the source info file already exists and can be read successfully, then the Project Manager will get all the needed information about the sources from the source info file and will not look for them. This reduces the time to process the project files, especially when looking for sources that take a long time. If the source info file exists but cannot be parsed successfully, the Project Manager will attempt to recreate it. If the Project Manager fails to create the source info file, a message is issued, but gnatmake does not fail. gnatmake “trusts” the source info file. This means that if the source files have changed (addition, deletion, moving to a different source directory), then the source info file need to be deleted and recreated.

-a

Consider all files in the make process, even the GNAT internal system files (for example, the predefined Ada library files), as well as any locked files. Locked files are files whose ALI file is write-protected. By default, gnatmake does not check these files, because the assumption is that the GNAT internal files are properly up to date, and also that any write protected ALI files have been properly installed. Note that if there is an installation problem, such that one of these files is not up to date, it will be properly caught by the binder. You may have to specify this switch if you are working on GNAT itself. The switch -a is also useful in conjunction with -f if you need to recompile an entire application, including run-time files, using special configuration pragmas, such as a Normalize_Scalars pragma.

By default gnatmake -a compiles all GNAT internal files with gcc -c -gnatpg rather than gcc -c.

-b

Bind only. Can be combined with -c to do compilation and binding, but no link. Can be combined with -l to do binding and linking. When not combined with -c all the units in the closure of the main program must have been previously compiled and must be up to date. The root unit specified by file_name may be given without extension, with the source extension or, if no GNAT Project File is specified, with the ALI file extension.

-c

Compile only. Do not perform binding, except when -b is also specified. Do not perform linking, except if both -b and -l are also specified. If the root unit specified by file_name is not a main unit, this is the default. Otherwise gnatmake will attempt binding and linking unless all objects are up to date and the executable is more recent than the objects.

-C

Use a temporary mapping file. A mapping file is a way to communicate to the compiler two mappings: from unit names to file names (without any directory information) and from file names to path names (with full directory information). A mapping file can make the compiler’s file searches faster, especially if there are many source directories, or the sources are read over a slow network connection. If -P is used, a mapping file is always used, so -C is unnecessary; in this case the mapping file is initially populated based on the project file. If -C is used without -P, the mapping file is initially empty. Each invocation of the compiler will add any newly accessed sources to the mapping file.

-C=`file'

Use a specific mapping file. The file, specified as a path name (absolute or relative) by this switch, should already exist, otherwise the switch is ineffective. The specified mapping file will be communicated to the compiler. This switch is not compatible with a project file (-P‘file‘) or with multiple compiling processes (-jnnn, when nnn is greater than 1).

-d

Display progress for each source, up to date or not, as a single line:

completed x out of y (zz%)

If the file needs to be compiled this is displayed after the invocation of the compiler. These lines are displayed even in quiet output mode.

-D `dir'

Put all object files and ALI file in directory dir. If the -D switch is not used, all object files and ALI files go in the current working directory.

This switch cannot be used when using a project file.

-eI`nnn'

Indicates that the main source is a multi-unit source and the rank of the unit in the source file is nnn. nnn needs to be a positive number and a valid index in the source. This switch cannot be used when gnatmake is invoked for several mains.

-eL

Follow all symbolic links when processing project files. This should be used if your project uses symbolic links for files or directories, but is not needed in other cases.

This also assumes that no directory matches the naming scheme for files (for instance that you do not have a directory called “sources.ads” when using the default GNAT naming scheme).

When you do not have to use this switch (i.e., by default), gnatmake is able to save a lot of system calls (several per source file and object file), which can result in a significant speed up to load and manipulate a project file, especially when using source files from a remote system.

-eS

Output the commands for the compiler, the binder and the linker on standard output, instead of standard error.

-f

Force recompilations. Recompile all sources, even though some object files may be up to date, but don’t recompile predefined or GNAT internal files or locked files (files with a write-protected ALI file), unless the -a switch is also specified.

-F

When using project files, if some errors or warnings are detected during parsing and verbose mode is not in effect (no use of switch -v), then error lines start with the full path name of the project file, rather than its simple file name.

-g

Enable debugging. This switch is simply passed to the compiler and to the linker.

-i

In normal mode, gnatmake compiles all object files and ALI files into the current directory. If the -i switch is used, then instead object files and ALI files that already exist are overwritten in place. This means that once a large project is organized into separate directories in the desired manner, then gnatmake will automatically maintain and update this organization. If no ALI files are found on the Ada object path (see Search Paths and the Run-Time Library (RTL)), the new object and ALI files are created in the directory containing the source being compiled. If another organization is desired, where objects and sources are kept in different directories, a useful technique is to create dummy ALI files in the desired directories. When detecting such a dummy file, gnatmake will be forced to recompile the corresponding source file, and it will be put the resulting object and ALI files in the directory where it found the dummy file.

-j`n'

Use n processes to carry out the (re)compilations. On a multiprocessor machine compilations will occur in parallel. If n is 0, then the maximum number of parallel compilations is the number of core processors on the platform. In the event of compilation errors, messages from various compilations might get interspersed (but gnatmake will give you the full ordered list of failing compiles at the end). If this is problematic, rerun the make process with n set to 1 to get a clean list of messages.

-k

Keep going. Continue as much as possible after a compilation error. To ease the programmer’s task in case of compilation errors, the list of sources for which the compile fails is given when gnatmake terminates.

If gnatmake is invoked with several file_names and with this switch, if there are compilation errors when building an executable, gnatmake will not attempt to build the following executables.

-l

Link only. Can be combined with -b to binding and linking. Linking will not be performed if combined with -c but not with -b. When not combined with -b all the units in the closure of the main program must have been previously compiled and must be up to date, and the main program needs to have been bound. The root unit specified by file_name may be given without extension, with the source extension or, if no GNAT Project File is specified, with the ALI file extension.

-m

Specify that the minimum necessary amount of recompilations be performed. In this mode gnatmake ignores time stamp differences when the only modifications to a source file consist in adding/removing comments, empty lines, spaces or tabs. This means that if you have changed the comments in a source file or have simply reformatted it, using this switch will tell gnatmake not to recompile files that depend on it (provided other sources on which these files depend have undergone no semantic modifications). Note that the debugging information may be out of date with respect to the sources if the -m switch causes a compilation to be switched, so the use of this switch represents a trade-off between compilation time and accurate debugging information.

-M

Check if all objects are up to date. If they are, output the object dependences to stdout in a form that can be directly exploited in a Makefile. By default, each source file is prefixed with its (relative or absolute) directory name. This name is whatever you specified in the various -aI and -I switches. If you use gnatmake -M -q (see below), only the source file names, without relative paths, are output. If you just specify the -M switch, dependencies of the GNAT internal system files are omitted. This is typically what you want. If you also specify the -a switch, dependencies of the GNAT internal files are also listed. Note that dependencies of the objects in external Ada libraries (see switch -aL`dir' in the following list) are never reported.

-n

Don’t compile, bind, or link. Checks if all objects are up to date. If they are not, the full name of the first file that needs to be recompiled is printed. Repeated use of this option, followed by compiling the indicated source file, will eventually result in recompiling all required units.

-o `exec_name'

Output executable name. The name of the final executable program will be exec_name. If the -o switch is omitted the default name for the executable will be the name of the input file in appropriate form for an executable file on the host system.

This switch cannot be used when invoking gnatmake with several file_names.

-p

Same as --create-missing-dirs

-P`project'

Use project file project. Only one such switch can be used.

-q

Quiet. When this flag is not set, the commands carried out by gnatmake are displayed.

-s

Recompile if compiler switches have changed since last compilation. All compiler switches but -I and -o are taken into account in the following way: orders between different ‘first letter’ switches are ignored, but orders between same switches are taken into account. For example, -O -O2 is different than -O2 -O, but -g -O is equivalent to -O -g.

This switch is recommended when Integrated Preprocessing is used.

-u

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.

-U

When used without a project file or with one or several mains on the command line, is equivalent to -u. When used with a project file and no main on the command line, all sources of all project files are checked and compiled if not up to date, and libraries are rebuilt, if necessary.

-v

Verbose. Display the reason for all recompilations gnatmake decides are necessary, with the highest verbosity level.

-vl

Verbosity level Low. Display fewer lines than in verbosity Medium.

-vm

Verbosity level Medium. Potentially display fewer lines than in verbosity High.

-vh

Verbosity level High. Equivalent to -v.

-vP`x'

Indicate the verbosity of the parsing of GNAT project files. See Switches Related to Project Files.

-x

Indicate that sources that are not part of any Project File may be compiled. Normally, when using Project Files, only sources that are part of a Project File may be compile. When this switch is used, a source outside of all Project Files may be compiled. The ALI file and the object file will be put in the object directory of the main Project. The compilation switches used will only be those specified on the command line. Even when -x is used, mains specified on the command line need to be sources of a project file.

-X`name'=`value'

Indicate that external variable name has the value value. The Project Manager will use this value for occurrences of external(name) when parsing the project file. Switches Related to Project Files.

-z

No main subprogram. Bind and link the program even if the unit name given on the command line is a package name. The resulting executable will execute the elaboration routines of the package and its closure, then the finalization routines.

GCC switches

Any uppercase or multi-character switch that is not a gnatmake switch is passed to gcc (e.g., -O, -gnato, etc.)

Source and library search path switches

-aI`dir'

When looking for source files also look in directory dir. The order in which source files search is undertaken is described in Search Paths and the Run-Time Library (RTL).

-aL`dir'

Consider dir as being an externally provided Ada library. Instructs gnatmake to skip compilation units whose .ALI files have been located in directory dir. This allows you to have missing bodies for the units in dir and to ignore out of date bodies for the same units. You still need to specify the location of the specs for these units by using the switches -aI`dir' or -I`dir'. Note: this switch is provided for compatibility with previous versions of gnatmake. The easier method of causing standard libraries to be excluded from consideration is to write-protect the corresponding ALI files.

-aO`dir'

When searching for library and object files, look in directory dir. The order in which library files are searched is described in Search Paths for gnatbind.

-A`dir'

Equivalent to -aL`dir' -aI`dir'.

-I`dir'

Equivalent to -aO`dir' -aI`dir'.

-I-

Do not look for source files in the directory containing the source file named in the command line. Do not look for ALI or object files in the directory where gnatmake was invoked.

-L`dir'

Add directory dir to the list of directories in which the linker will search for libraries. This is equivalent to -largs -L`dir'. Furthermore, under Windows, the sources pointed to by the libraries path set in the registry are not searched for.

-nostdinc

Do not look for source files in the system default directory.

-nostdlib

Do not look for library files in the system default directory.

--RTS=`rts-path'

Specifies the default location of the run-time library. GNAT looks for the run-time in the following directories, and stops as soon as a valid run-time is found (adainclude or ada_source_path, and adalib or ada_object_path present):

• `<current directory>/$rts_path'
• `<default-search-dir>/$rts_path'
• `<default-search-dir>/rts-$rts_path'
• The selected path is handled like a normal RTS path.

4.1.3 Mode Switches for gnatmake

The mode switches (referred to as mode_switches) allow the inclusion of switches that are to be passed to the compiler itself, the binder or the linker. The effect of a mode switch is to cause all subsequent switches up to the end of the switch list, or up to the next mode switch, to be interpreted as switches to be passed on to the designated component of GNAT.

-cargs `switches'

Compiler switches. Here switches is a list of switches that are valid switches for gcc. They will be passed on to all compile steps performed by gnatmake.

-bargs `switches'

Binder switches. Here switches is a list of switches that are valid switches for gnatbind. They will be passed on to all bind steps performed by gnatmake.

-largs `switches'

Linker switches. Here switches is a list of switches that are valid switches for gnatlink. They will be passed on to all link steps performed by gnatmake.

-margs `switches'

Make switches. The switches are directly interpreted by gnatmake, regardless of any previous occurrence of -cargs, -bargs or -largs.

4.1.4 Notes on the Command Line

This section contains some additional useful notes on the operation of the gnatmake command.

• If gnatmake finds no ALI files, it recompiles the main program and all other units required by the main program. This means that gnatmake can be used for the initial compile, as well as during subsequent steps of the development cycle.
• If you enter gnatmake foo.adb, where foo is a subunit or body of a generic unit, gnatmake recompiles foo.adb (because it finds no ALI) and stops, issuing a warning.
• In gnatmake the switch -I is used to specify both source and library file paths. Use -aI instead if you just want to specify source paths only and -aO if you want to specify library paths only.
• gnatmake will ignore any files whose ALI file is write-protected. This may conveniently be used to exclude standard libraries from consideration and in particular it means that the use of the -f switch will not recompile these files unless -a is also specified.
• gnatmake has been designed to make the use of Ada libraries particularly convenient. Assume you have an Ada library organized as follows: `obj-dir' contains the objects and ALI files for of your Ada compilation units, whereas `include-dir' contains the specs of these units, but no bodies. Then to compile a unit stored in main.adb, which uses this Ada library you would just type:

  $ gnatmake -aI`include-dir`  -aL`obj-dir`  main
  

• Using gnatmake along with the -m (minimal recompilation) switch provides a mechanism for avoiding unnecessary recompilations. Using this switch, you can update the comments/format of your source files without having to recompile everything. Note, however, that adding or deleting lines in a source files may render its debugging info obsolete. If the file in question is a spec, the impact is rather limited, as that debugging info will only be useful during the elaboration phase of your program. For bodies the impact can be more significant. In all events, your debugger will warn you if a source file is more recent than the corresponding object, and alert you to the fact that the debugging information may be out of date.

4.1.5 How gnatmake Works

Generally gnatmake automatically performs all necessary recompilations and you don’t need to worry about how it works. However, it may be useful to have some basic understanding of the gnatmake approach and in particular to understand how it uses the results of previous compilations without incorrectly depending on them.

First a definition: an object file is considered `up to date' if the corresponding ALI file exists and if all the source files listed in the dependency section of this ALI file have time stamps matching those in the ALI file. This means that neither the source file itself nor any files that it depends on have been modified, and hence there is no need to recompile this file.

gnatmake works by first checking if the specified main unit is up to date. If so, no compilations are required for the main unit. If not, gnatmake compiles the main program to build a new ALI file that reflects the latest sources. Then the ALI file of the main unit is examined to find all the source files on which the main program depends, and gnatmake recursively applies the above procedure on all these files.

This process ensures that gnatmake only trusts the dependencies in an existing ALI file if they are known to be correct. Otherwise it always recompiles to determine a new, guaranteed accurate set of dependencies. As a result the program is compiled ‘upside down’ from what may be more familiar as the required order of compilation in some other Ada systems. In particular, clients are compiled before the units on which they depend. The ability of GNAT to compile in any order is critical in allowing an order of compilation to be chosen that guarantees that gnatmake will recompute a correct set of new dependencies if necessary.

When invoking gnatmake with several file_names, if a unit is imported by several of the executables, it will be recompiled at most once.

Note: when using non-standard naming conventions (Using Other File Names), changing through a configuration pragmas file the version of a source and invoking gnatmake to recompile may have no effect, if the previous version of the source is still accessible by gnatmake. It may be necessary to use the switch -f.

4.1.6 Examples of gnatmake Usage

`gnatmake hello.adb'

Compile all files necessary to bind and link the main program hello.adb (containing unit Hello) and bind and link the resulting object files to generate an executable file hello.

`gnatmake main1 main2 main3'

Compile all files necessary to bind and link the main programs main1.adb (containing unit Main1), main2.adb (containing unit Main2) and main3.adb (containing unit Main3) and bind and link the resulting object files to generate three executable files main1, main2 and main3.

`gnatmake -q Main_Unit -cargs -O2 -bargs -l'

Compile all files necessary to bind and link the main program unit Main_Unit (from file main_unit.adb). All compilations will be done with optimization level 2 and the order of elaboration will be listed by the binder. gnatmake will operate in quiet mode, not displaying commands it is executing.

4.2.1 Compiling Programs

The first step in creating an executable program is to compile the units of the program using the gcc command. You must compile the following files:

• the body file (.adb) for a library level subprogram or generic subprogram
• the spec file (.ads) for a library level package or generic package that has no body
• the body file (.adb) for a library level package or generic package that has a body

You need `not' compile the following files

• the spec of a library unit which has a body
• subunits

because they are compiled as part of compiling related units. GNAT package specs when the corresponding body is compiled, and subunits when the parent is compiled.

If you attempt to compile any of these files, you will get one of the following error messages (where fff is the name of the file you compiled):

cannot generate code for file ``fff`` (package spec)
to check package spec, use -gnatc

cannot generate code for file ``fff`` (missing subunits)
to check parent unit, use -gnatc

cannot generate code for file ``fff`` (subprogram spec)
to check subprogram spec, use -gnatc

cannot generate code for file ``fff`` (subunit)
to check subunit, use -gnatc

As indicated by the above error messages, if you want to submit one of these files to the compiler to check for correct semantics without generating code, then use the -gnatc switch.

The basic command for compiling a file containing an Ada unit is:

$ gcc -c [switches] <file name>

where file name is the name of the Ada file (usually having an extension .ads for a spec or .adb for a body). You specify the -c switch to tell gcc to compile, but not link, the file. The result of a successful compilation is an object file, which has the same name as the source file but an extension of .o and an Ada Library Information (ALI) file, which also has the same name as the source file, but with .ali as the extension. GNAT creates these two output files in the current directory, but you may specify a source file in any directory using an absolute or relative path specification containing the directory information.

TESTING: the --foobar`NN' switch

gcc is actually a driver program that looks at the extensions of the file arguments and loads the appropriate compiler. For example, the GNU C compiler is cc1, and the Ada compiler is gnat1. These programs are in directories known to the driver program (in some configurations via environment variables you set), but need not be in your path. The gcc driver also calls the assembler and any other utilities needed to complete the generation of the required object files.

It is possible to supply several file names on the same gcc command. This causes gcc to call the appropriate compiler for each file. For example, the following command lists two separate files to be compiled:

$ gcc -c x.adb y.adb

calls gnat1 (the Ada compiler) twice to compile x.adb and y.adb. The compiler generates two object files x.o and y.o and the two ALI files x.ali and y.ali.

Any switches apply to all the files listed, see Compiler Switches for a list of available gcc switches.

4.2.2 Search Paths and the Run-Time Library (RTL)

With the GNAT source-based library system, the compiler must be able to find source files for units that are needed by the unit being compiled. Search paths are used to guide this process.

The compiler compiles one source file whose name must be given explicitly on the command line. In other words, no searching is done for this file. To find all other source files that are needed (the most common being the specs of units), the compiler examines the following directories, in the following order:

• The directory containing the source file of the main unit being compiled (the file name on the command line).
• Each directory named by an -I switch given on the gcc command line, in the order given.
• Each of the directories listed in the text file whose name is given by the ADA_PRJ_INCLUDE_FILE environment variable. ADA_PRJ_INCLUDE_FILE is normally set by gnatmake or by the gnat driver when project files are used. It should not normally be set by other means.
• Each of the directories listed in the value of the ADA_INCLUDE_PATH environment variable. Construct this value exactly as the PATH environment variable: a list of directory names separated by colons (semicolons when working with the NT version).
• The content of the ada_source_path file which is part of the GNAT installation tree and is used to store standard libraries such as the GNAT Run Time Library (RTL) source files. Installing a library

Specifying the switch -I- inhibits the use of the directory containing the source file named in the command line. You can still have this directory on your search path, but in this case it must be explicitly requested with a -I switch.

Specifying the switch -nostdinc inhibits the search of the default location for the GNAT Run Time Library (RTL) source files.

The compiler outputs its object files and ALI files in the current working directory. Caution: The object file can be redirected with the -o switch; however, gcc and gnat1 have not been coordinated on this so the ALI file will not go to the right place. Therefore, you should avoid using the -o switch.

The packages Ada, System, and Interfaces and their children make up the GNAT RTL, together with the simple System.IO package used in the "Hello World" example. The sources for these units are needed by the compiler and are kept together in one directory. Not all of the bodies are needed, but all of the sources are kept together anyway. In a normal installation, you need not specify these directory names when compiling or binding. Either the environment variables or the built-in defaults cause these files to be found.

In addition to the language-defined hierarchies (System, Ada and Interfaces), the GNAT distribution provides a fourth hierarchy, consisting of child units of GNAT. This is a collection of generally useful types, subprograms, etc. See the GNAT_Reference_Manual for further details.

Besides simplifying access to the RTL, a major use of search paths is in compiling sources from multiple directories. This can make development environments much more flexible.

4.2.3 Order of Compilation Issues

If, in our earlier example, there was a spec for the hello procedure, it would be contained in the file hello.ads; yet this file would not have to be explicitly compiled. This is the result of the model we chose to implement library management. Some of the consequences of this model are as follows:

• There is no point in compiling specs (except for package specs with no bodies) because these are compiled as needed by clients. If you attempt a useless compilation, you will receive an error message. It is also useless to compile subunits because they are compiled as needed by the parent.
• There are no order of compilation requirements: performing a compilation never obsoletes anything. The only way you can obsolete something and require recompilations is to modify one of the source files on which it depends.
• There is no library as such, apart from the ALI files (The Ada Library Information Files, for information on the format of these files). For now we find it convenient to create separate ALI files, but eventually the information therein may be incorporated into the object file directly.
• When you compile a unit, the source files for the specs of all units that it `with's, all its subunits, and the bodies of any generics it instantiates must be available (reachable by the search-paths mechanism described above), or you will receive a fatal error message.

4.2.4 Examples

The following are some typical Ada compilation command line examples:

$ gcc -c xyz.adb

Compile body in file xyz.adb with all default options.

$ gcc -c -O2 -gnata xyz-def.adb

Compile the child unit package in file xyz-def.adb with extensive optimizations, and pragma Assert/Debug statements enabled.

$ gcc -c -gnatc abc-def.adb

Compile the subunit in file abc-def.adb in semantic-checking-only mode.

4.3.1 Alphabetical List of All Switches

-b `target'

Compile your program to run on target, which is the name of a system configuration. You must have a GNAT cross-compiler built if target is not the same as your host system.

-B`dir'

Load compiler executables (for example, gnat1, the Ada compiler) from dir instead of the default location. Only use this switch when multiple versions of the GNAT compiler are available. See the “Options for Directory Search” section in the Using the GNU Compiler Collection (GCC) manual for further details. You would normally use the -b or -V switch instead.

-c

Compile. Always use this switch when compiling Ada programs.

Note: for some other languages when using gcc, notably in the case of C and C++, it is possible to use use gcc without a -c switch to compile and link in one step. In the case of GNAT, you cannot use this approach, because the binder must be run and gcc cannot be used to run the GNAT binder.

-fcallgraph-info[=su,da]

Makes the compiler output callgraph information for the program, on a per-file basis. The information is generated in the VCG format. It can be decorated with additional, per-node and/or per-edge information, if a list of comma-separated markers is additionally specified. When the su marker is specified, the callgraph is decorated with stack usage information; it is equivalent to -fstack-usage. When the da marker is specified, the callgraph is decorated with information about dynamically allocated objects.

-fdiagnostics-format=json

Makes GNAT emit warning and error messages as JSON. Inhibits printing of text warning and errors messages except if -gnatv or -gnatl are present.

-fdump-scos

Generates SCO (Source Coverage Obligation) information in the ALI file. This information is used by advanced coverage tools. See unit SCOs in the compiler sources for details in files scos.ads and scos.adb.

-fgnat-encodings=[all|gdb|minimal]

This switch controls the balance between GNAT encodings and standard DWARF emitted in the debug information.

-flto[=`n']

Enables Link Time Optimization. This switch must be used in conjunction with the -Ox switches (but not with the -gnatn switch since it is a full replacement for the latter) and instructs the compiler to defer most optimizations until the link stage. The advantage of this approach is that the compiler can do a whole-program analysis and choose the best interprocedural optimization strategy based on a complete view of the program, instead of a fragmentary view with the usual approach. This can also speed up the compilation of big programs and reduce the size of the executable, compared with a traditional per-unit compilation with inlining across units enabled by the -gnatn switch. The drawback of this approach is that it may require more memory and that the debugging information generated by -g with it might be hardly usable. The switch, as well as the accompanying -Ox switches, must be specified both for the compilation and the link phases. If the n parameter is specified, the optimization and final code generation at link time are executed using n parallel jobs by means of an installed make program.

-fno-inline

Suppresses all inlining, unless requested with pragma Inline_Always. The effect is enforced regardless of other optimization or inlining switches. Note that inlining can also be suppressed on a finer-grained basis with pragma No_Inline.

-fno-inline-functions

Suppresses automatic inlining of subprograms, which is enabled if -O3 is used.

-fno-inline-small-functions

Suppresses automatic inlining of small subprograms, which is enabled if -O2 is used.

-fno-inline-functions-called-once

Suppresses inlining of subprograms local to the unit and called once from within it, which is enabled if -O1 is used.

-fno-ivopts

Suppresses high-level loop induction variable optimizations, which are enabled if -O1 is used. These optimizations are generally profitable but, for some specific cases of loops with numerous uses of the iteration variable that follow a common pattern, they may end up destroying the regularity that could be exploited at a lower level and thus producing inferior code.

-fno-strict-aliasing

Causes the compiler to avoid assumptions regarding non-aliasing of objects of different types. See Optimization and Strict Aliasing for details.

-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 -gnato0 for very peculiar cases of low-level programming.

-fstack-check

Activates stack checking. See Stack Overflow Checking for details.

-fstack-usage

Makes the compiler output stack usage information for the program, on a per-subprogram basis. See Static Stack Usage Analysis for details.

-g

Generate debugging information. This information is stored in the object file and copied from there to the final executable file by the linker, where it can be read by the debugger. You must use the -g switch if you plan on using the debugger.

-gnat05

Allow full Ada 2005 features.

-gnat12

Allow full Ada 2012 features.

-gnat2005

Allow full Ada 2005 features (same as -gnat05)

-gnat2012

Allow full Ada 2012 features (same as -gnat12)

-gnat2022

Allow full Ada 2022 features

-gnat83

Enforce Ada 83 restrictions.

-gnat95

Enforce Ada 95 restrictions.

Note: for compatibility with some Ada 95 compilers which support only the overriding keyword of Ada 2005, the -gnatd.D switch can be used along with -gnat95 to achieve a similar effect with GNAT.

-gnatd.D instructs GNAT to consider overriding as a keyword and handle its associated semantic checks, even in Ada 95 mode.

-gnata

Assertions enabled. Pragma Assert and pragma Debug to be activated. Note that these pragmas can also be controlled using the configuration pragmas Assertion_Policy and Debug_Policy. It also activates pragmas Check, Precondition, and Postcondition. Note that these pragmas can also be controlled using the configuration pragma Check_Policy. In Ada 2012, it also activates all assertions defined in the RM as aspects: preconditions, postconditions, type invariants and (sub)type predicates. In all Ada modes, corresponding pragmas for type invariants and (sub)type predicates are also activated. The default is that all these assertions are disabled, and have no effect, other than being checked for syntactic validity, and in the case of subtype predicates, constructions such as membership tests still test predicates even if assertions are turned off.

-gnatA

Avoid processing gnat.adc. If a gnat.adc file is present, it will be ignored.

-gnatb

Generate brief messages to stderr even if verbose mode set.

-gnatB

Assume no invalid (bad) values except for ‘Valid attribute use (Validity Checking).

-gnatc

Check syntax and semantics only (no code generation attempted). When the compiler is invoked by gnatmake, if the switch -gnatc is only given to the compiler (after -cargs or in package Compiler of the project file, gnatmake will fail because it will not find the object file after compilation. If gnatmake is called with -gnatc as a builder switch (before -cargs or in package Builder of the project file) then gnatmake will not fail because it will not look for the object files after compilation, and it will not try to build and link.

-gnatC

Generate CodePeer intermediate format (no code generation attempted). This switch will generate an intermediate representation suitable for use by CodePeer (.scil files). This switch is not compatible with code generation (it will, among other things, disable some switches such as -gnatn, and enable others such as -gnata).

-gnatd

Specify debug options for the compiler. The string of characters after the -gnatd specifies the specific debug options. The possible characters are 0-9, a-z, A-Z, optionally preceded by a dot or underscore. See compiler source file debug.adb for details of the implemented debug options. Certain debug options are relevant to applications programmers, and these are documented at appropriate points in this users guide.

-gnatD

Create expanded source files for source level debugging. This switch also suppresses generation of cross-reference information (see -gnatx). Note that this switch is not allowed if a previous -gnatR switch has been given, since these two switches are not compatible.

-gnateA

Check that the actual parameters of a subprogram call are not aliases of one another. To qualify as aliasing, their memory locations must be identical or overlapping, at least one of the corresponding formal parameters must be of mode OUT or IN OUT, and at least one of the corresponding formal parameters must have its parameter passing mechanism not specified.

type Rec_Typ is record
   Data : Integer := 0;
end record;

function Self (Val : Rec_Typ) return Rec_Typ is
begin
   return Val;
end Self;

procedure Detect_Aliasing (Val_1 : in out Rec_Typ; Val_2 : Rec_Typ) is
begin
   null;
end Detect_Aliasing;

Obj : Rec_Typ;

Detect_Aliasing (Obj, Obj);
Detect_Aliasing (Obj, Self (Obj));

In the example above, the first call to Detect_Aliasing fails with a Program_Error at run time because the actuals for Val_1 and Val_2 denote the same object. The second call executes without raising an exception because Self(Obj) produces an anonymous object which does not share the memory location of Obj.

-gnateb

Store configuration files by their basename in ALI files. This switch is used for instance by gprbuild for distributed builds in order to prevent issues where machine-specific absolute paths could end up being stored in ALI files.

-gnatec=`path'

Specify a configuration pragma file (the equal sign is optional) (The Configuration Pragmas Files).

-gnateC

Generate CodePeer messages in a compiler-like format. This switch is only effective if -gnatcC is also specified and requires an installation of CodePeer.

-gnated

Disable atomic synchronization

-gnateDsymbol[=`value']

Defines a symbol, associated with value, for preprocessing. (Integrated Preprocessing).

-gnateE

Generate extra information in exception messages. In particular, display extra column information and the value and range associated with index and range check failures, and extra column information for access checks. In cases where the compiler is able to determine at compile time that a check will fail, it gives a warning, and the extra information is not produced at run time.

-gnatef

Display full source path name in brief error messages.

-gnateF

Check for overflow on all floating-point operations, including those for unconstrained predefined types. See description of pragma Check_Float_Overflow in GNAT RM.

-gnateg -gnatceg

The -gnatc switch must always be specified before this switch, e.g. -gnatceg. Generate a C header from the Ada input file. See Generating C Headers for Ada Specifications for more information.

-gnateG

Save result of preprocessing in a text file.

-gnatei`nnn'

Set maximum number of instantiations during compilation of a single unit to nnn. This may be useful in increasing the default maximum of 8000 for the rare case when a single unit legitimately exceeds this limit.

-gnateI`nnn'

Indicates that the source is a multi-unit source and that the index of the unit to compile is nnn. nnn needs to be a positive number and need to be a valid index in the multi-unit source.

-gnatel

This switch can be used with the static elaboration model to issue info messages showing where implicit pragma Elaborate and pragma Elaborate_All are generated. This is useful in diagnosing elaboration circularities caused by these implicit pragmas when using the static elaboration model. See See the section in this guide on elaboration checking for further details. These messages are not generated by default, and are intended only for temporary use when debugging circularity problems.

-gnateL

This switch turns off the info messages about implicit elaboration pragmas.

-gnatem=`path'

Specify a mapping file (the equal sign is optional) (Units to Sources Mapping Files).

-gnatep=`file'

Specify a preprocessing data file (the equal sign is optional) (Integrated Preprocessing).

-gnateP

Turn categorization dependency errors into warnings. Ada requires that units that WITH one another have compatible categories, for example a Pure unit cannot WITH a Preelaborate unit. If this switch is used, these errors become warnings (which can be ignored, or suppressed in the usual manner). This can be useful in some specialized circumstances such as the temporary use of special test software.

-gnateS

Synonym of -fdump-scos, kept for backwards compatibility.

-gnatet=`path'

Generate target dependent information. The format of the output file is described in the section about switch -gnateT.

-gnateT=`path'

Read target dependent information, such as endianness or sizes and alignments of base type. If this switch is passed, the default target dependent information of the compiler is replaced by the one read from the input file. This is used by tools other than the compiler, e.g. to do semantic analysis of programs that will run on some other target than the machine on which the tool is run.

The following target dependent values should be defined, where Nat denotes a natural integer value, Pos denotes a positive integer value, and fields marked with a question mark are boolean fields, where a value of 0 is False, and a value of 1 is True:

Bits_BE                    : Nat; -- Bits stored big-endian?
Bits_Per_Unit              : Pos; -- Bits in a storage unit
Bits_Per_Word              : Pos; -- Bits in a word
Bytes_BE                   : Nat; -- Bytes stored big-endian?
Char_Size                  : Pos; -- Standard.Character'Size
Double_Float_Alignment     : Nat; -- Alignment of double float
Double_Scalar_Alignment    : Nat; -- Alignment of double length scalar
Double_Size                : Pos; -- Standard.Long_Float'Size
Float_Size                 : Pos; -- Standard.Float'Size
Float_Words_BE             : Nat; -- Float words stored big-endian?
Int_Size                   : Pos; -- Standard.Integer'Size
Long_Double_Size           : Pos; -- Standard.Long_Long_Float'Size
Long_Long_Size             : Pos; -- Standard.Long_Long_Integer'Size
Long_Size                  : Pos; -- Standard.Long_Integer'Size
Maximum_Alignment          : Pos; -- Maximum permitted alignment
Max_Unaligned_Field        : Pos; -- Maximum size for unaligned bit field
Pointer_Size               : Pos; -- System.Address'Size
Short_Enums                : Nat; -- Foreign enums use short size?
Short_Size                 : Pos; -- Standard.Short_Integer'Size
Strict_Alignment           : Nat; -- Strict alignment?
System_Allocator_Alignment : Nat; -- Alignment for malloc calls
Wchar_T_Size               : Pos; -- Interfaces.C.wchar_t'Size
Words_BE                   : Nat; -- Words stored big-endian?

Bits_Per_Unit is the number of bits in a storage unit, the equivalent of GCC macro BITS_PER_UNIT documented as follows: Define this macro to be the number of bits in an addressable storage unit (byte); normally 8.

Bits_Per_Word is the number of bits in a machine word, the equivalent of GCC macro BITS_PER_WORD documented as follows: Number of bits in a word; normally 32.

Double_Float_Alignment, if not zero, is the maximum alignment that the compiler can choose by default for a 64-bit floating-point type or object.

Double_Scalar_Alignment, if not zero, is the maximum alignment that the compiler can choose by default for a 64-bit or larger scalar type or object.

Maximum_Alignment is the maximum alignment that the compiler can choose by default for a type or object, which is also the maximum alignment that can be specified in GNAT. It is computed for GCC backends as BIGGEST_ALIGNMENT / BITS_PER_UNIT where GCC macro BIGGEST_ALIGNMENT is documented as follows: Biggest alignment that any data type can require on this machine, in bits.

Max_Unaligned_Field is the maximum size for unaligned bit field, which is 64 for the majority of GCC targets (but can be different on some targets).

Strict_Alignment is the equivalent of GCC macro STRICT_ALIGNMENT documented as follows: Define this macro to be the value 1 if instructions will fail to work if given data not on the nominal alignment. If instructions will merely go slower in that case, define this macro as 0.

System_Allocator_Alignment is the guaranteed alignment of data returned by calls to malloc.

The format of the input file is as follows. First come the values of the variables defined above, with one line per value:

name  value

where name is the name of the parameter, spelled out in full, and cased as in the above list, and value is an unsigned decimal integer. Two or more blanks separates the name from the value.

All the variables must be present, in alphabetical order (i.e. the same order as the list above).

Then there is a blank line to separate the two parts of the file. Then come the lines showing the floating-point types to be registered, with one line per registered mode:

name  digs float_rep size alignment

where name is the string name of the type (which can have single spaces embedded in the name (e.g. long double), digs is the number of digits for the floating-point type, float_rep is the float representation (I for IEEE-754-Binary, which is the only one supported at this time), size is the size in bits, alignment is the alignment in bits. The name is followed by at least two blanks, fields are separated by at least one blank, and a LF character immediately follows the alignment field.

Here is an example of a target parameterization file:

Bits_BE                       0
Bits_Per_Unit                 8
Bits_Per_Word                64
Bytes_BE                      0
Char_Size                     8
Double_Float_Alignment        0
Double_Scalar_Alignment       0
Double_Size                  64
Float_Size                   32
Float_Words_BE                0
Int_Size                     64
Long_Double_Size            128
Long_Long_Size               64
Long_Size                    64
Maximum_Alignment            16
Max_Unaligned_Field          64
Pointer_Size                 64
Short_Size                   16
Strict_Alignment              0
System_Allocator_Alignment   16
Wchar_T_Size                 32
Words_BE                      0

float         15  I  64  64
double        15  I  64  64
long double   18  I  80 128
TF            33  I 128 128

-gnateu

Ignore unrecognized validity, warning, and style switches that appear after this switch is given. This may be useful when compiling sources developed on a later version of the compiler with an earlier version. Of course the earlier version must support this switch.

-gnateV

Check that all actual parameters of a subprogram call are valid according to the rules of validity checking (Validity Checking).

-gnateY

Ignore all STYLE_CHECKS pragmas. Full legality checks are still carried out, but the pragmas have no effect on what style checks are active. This allows all style checking options to be controlled from the command line.

-gnatE

Dynamic elaboration checking mode enabled. For further details see Elaboration Order Handling in GNAT.

-gnatf

Full errors. Multiple errors per line, all undefined references, do not attempt to suppress cascaded errors.

-gnatF

Externals names are folded to all uppercase.

-gnatg

Internal GNAT implementation mode. This should not be used for applications programs, it is intended only for use by the compiler and its run-time library. For documentation, see the GNAT sources. Note that -gnatg implies -gnatw.ge and -gnatyg so that all standard warnings and all standard style options are turned on. All warnings and style messages are treated as errors.

-gnatG=nn

List generated expanded code in source form.

-gnath

Output usage information. The output is written to stdout.

-gnatH

Legacy elaboration-checking mode enabled. When this switch is in effect, the pre-18.x access-before-elaboration model becomes the de facto model. For further details see Elaboration Order Handling in GNAT.

-gnati`c'

Identifier character set (c = 1/2/3/4/5/9/p/8/f/n/w). For details of the possible selections for c, see Character Set Control.

-gnatI

Ignore representation clauses. When this switch is used, representation clauses are treated as comments. This is useful when initially porting code where you want to ignore rep clause problems, and also for compiling foreign code (particularly for use with ASIS). The representation clauses that are ignored are: enumeration_representation_clause, record_representation_clause, and attribute_definition_clause for the following attributes: Address, Alignment, Bit_Order, Component_Size, Machine_Radix, Object_Size, Scalar_Storage_Order, Size, Small, Stream_Size, and Value_Size. Pragma Default_Scalar_Storage_Order is also ignored. Note that this option should be used only for compiling – the code is likely to malfunction at run time.

-gnatj`nn'

Reformat error messages to fit on nn character lines

-gnatJ

Permissive elaboration-checking mode enabled. When this switch is in effect, the post-18.x access-before-elaboration model ignores potential issues with:

• Accept statements
• Activations of tasks defined in instances
• Assertion pragmas
• Calls from within an instance to its enclosing context
• Calls through generic formal parameters
• Calls to subprograms defined in instances
• Entry calls
• Indirect calls using ‘Access
• Requeue statements
• Select statements
• Synchronous task suspension

and does not emit compile-time diagnostics or run-time checks. For further details see Elaboration Order Handling in GNAT.

-gnatk=`n'

Limit file names to n (1-999) characters (k = krunch).

-gnatl

Output full source listing with embedded error messages.

-gnatL

Used in conjunction with -gnatG or -gnatD to intersperse original source lines (as comment lines with line numbers) in the expanded source output.

-gnatm=`n'

Limit number of detected error or warning messages to n where n is in the range 1..999999. The default setting if no switch is given is 9999. If the number of warnings reaches this limit, then a message is output and further warnings are suppressed, but the compilation is continued. If the number of error messages reaches this limit, then a message is output and the compilation is abandoned. The equal sign here is optional. A value of zero means that no limit applies.

-gnatn[12]

Activate inlining across units for subprograms for which pragma Inline is specified. This inlining is performed by the GCC back-end. An optional digit sets the inlining level: 1 for moderate inlining across units or 2 for full inlining across units. If no inlining level is specified, the compiler will pick it based on the optimization level.

-gnatN

Activate front end inlining for subprograms for which pragma Inline is specified. This inlining is performed by the front end and will be visible in the -gnatG output.

When using a gcc-based back end, then the use of -gnatN is deprecated, and the use of -gnatn is preferred. Historically front end inlining was more extensive than the gcc back end inlining, but that is no longer the case.

-gnato0

Suppresses overflow checking. This causes the behavior of the compiler to match the default for older versions where overflow checking was suppressed by default. This is equivalent to having pragma Suppress (Overflow_Check) in a configuration pragma file.

-gnato??

Set default mode for handling generation of code to avoid intermediate arithmetic overflow. Here ?? is two digits, a single digit, or nothing. Each digit is one of the digits 1 through 3:

Digit	Interpretation
`1'	All intermediate overflows checked against base type (STRICT)
`2'	Minimize intermediate overflows (MINIMIZED)
`3'	Eliminate intermediate overflows (ELIMINATED)

If only one digit appears, then it applies to all cases; if two digits are given, then the first applies outside assertions, pre/postconditions, and type invariants, and the second applies within assertions, pre/postconditions, and type invariants.

If no digits follow the -gnato, then it is equivalent to -gnato11, causing all intermediate overflows to be handled in strict mode.

This switch also causes arithmetic overflow checking to be performed (as though pragma Unsuppress (Overflow_Check) had been specified).

The default if no option -gnato is given is that overflow handling is in STRICT mode (computations done using the base type), and that overflow checking is enabled.

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 Specifying the Desired Mode.

-gnatp

Suppress all checks. See Run-Time Checks for details. This switch has no effect if cancelled by a subsequent -gnat-p switch.

-gnat-p

Cancel effect of previous -gnatp switch.

-gnatq

Don’t quit. Try semantics, even if parse errors.

-gnatQ

Don’t quit. Generate ALI and tree files even if illegalities. Note that code generation is still suppressed in the presence of any errors, so even with -gnatQ no object file is generated.

-gnatr

Treat pragma Restrictions as Restriction_Warnings.

-gnatR[0|1|2|3|4][e][j][m][s]

Output representation information for declared types, objects and subprograms. Note that this switch is not allowed if a previous -gnatD switch has been given, since these two switches are not compatible.

-gnats

Syntax check only.

-gnatS

Print package Standard.

-gnatT`nnn'

All compiler tables start at nnn times usual starting size.

-gnatu

List units for this compilation.

-gnatU

Tag all error messages with the unique string ‘error:’

-gnatv

Verbose mode. Full error output with source lines to stdout.

-gnatV

Control level of validity checking (Validity Checking).

-gnatw`xxx'

Warning mode where xxx is a string of option letters that denotes the exact warnings that are enabled or disabled (Warning Message Control).

-gnatW`e'

Wide character encoding method (e=n/h/u/s/e/8).

-gnatx

Suppress generation of cross-reference information.

-gnatX

Enable GNAT implementation extensions and latest Ada version.

-gnaty

Enable built-in style checks (Style Checking).

-gnatz`m'

Distribution stub generation and compilation (m=r/c for receiver/caller stubs).

-I`dir'

Direct GNAT to search the dir directory for source files needed by the current compilation (see Search Paths and the Run-Time Library (RTL)).

-I-

Except for the source file named in the command line, do not look for source files in the directory containing the source file named in the command line (see Search Paths and the Run-Time Library (RTL)).

-o `file'

This switch is used in gcc to redirect the generated object file and its associated ALI file. Beware of this switch with GNAT, because it may cause the object file and ALI file to have different names which in turn may confuse the binder and the linker.

-nostdinc

Inhibit the search of the default location for the GNAT Run Time Library (RTL) source files.

-nostdlib

Inhibit the search of the default location for the GNAT Run Time Library (RTL) ALI files.

-O[`n']

n controls the optimization level:

`n'	Effect
`0'	No optimization, the default setting if no -O appears
`1'	Normal optimization, the default if you specify -O without an operand. A good compromise between code quality and compilation time.
`2'	Extensive optimization, may improve execution time, possibly at the cost of substantially increased compilation time.
`3'	Same as -O2, and also includes inline expansion for small subprograms in the same unit.
`s'	Optimize space usage

See also Optimization Levels.

-pass-exit-codes

Catch exit codes from the compiler and use the most meaningful as exit status.

--RTS=`rts-path'

Specifies the default location of the run-time library. Same meaning as the equivalent gnatmake flag (Switches for gnatmake).

-S

Used in place of -c to cause the assembler source file to be generated, using .s as the extension, instead of the object file. This may be useful if you need to examine the generated assembly code.

-fverbose-asm

Used in conjunction with -S to cause the generated assembly code file to be annotated with variable names, making it significantly easier to follow.

-v

Show commands generated by the gcc driver. Normally used only for debugging purposes or if you need to be sure what version of the compiler you are executing.

-V `ver'

Execute ver version of the compiler. This is the gcc version, not the GNAT version.

-w

Turn off warnings generated by the back end of the compiler. Use of this switch also causes the default for front end warnings to be set to suppress (as though -gnatws had appeared at the start of the options).

You may combine a sequence of GNAT switches into a single switch. For example, the combined switch

-gnatofi3

is equivalent to specifying the following sequence of switches:

-gnato -gnatf -gnati3

The following restrictions apply to the combination of switches in this manner:

• The switch -gnatc if combined with other switches must come first in the string.
• The switch -gnats if combined with other switches must come first in the string.
• The switches -gnatzc and -gnatzr may not be combined with any other switches, and only one of them may appear in the command line.
• The switch -gnat-p may not be combined with any other switch.
• Once a ‘y’ appears in the string (that is a use of the -gnaty switch), then all further characters in the switch are interpreted as style modifiers (see description of -gnaty).
• Once a ‘d’ appears in the string (that is a use of the -gnatd switch), then all further characters in the switch are interpreted as debug flags (see description of -gnatd).
• Once a ‘w’ appears in the string (that is a use of the -gnatw switch), then all further characters in the switch are interpreted as warning mode modifiers (see description of -gnatw).
• Once a ‘V’ appears in the string (that is a use of the -gnatV switch), then all further characters in the switch are interpreted as validity checking options (Validity Checking).
• Option ‘em’, ‘ec’, ‘ep’, ‘l=’ and ‘R’ must be the last options in a combined list of options.

4.3.2 Output and Error Message Control

The standard default format for error messages is called ‘brief format’. Brief format messages are written to stderr (the standard error file) and have the following form:

e.adb:3:04: Incorrect spelling of keyword "function"
e.adb:4:20: ";" should be "is"

The first integer after the file name is the line number in the file, and the second integer is the column number within the line. GNAT Studio can parse the error messages and point to the referenced character. The following switches provide control over the error message format:

-gnatv

The v stands for verbose. The effect of this setting is to write long-format error messages to stdout (the standard output file. The same program compiled with the -gnatv switch would generate:

3. funcion X (Q : Integer)
   |
>>> Incorrect spelling of keyword "function"
4. return Integer;
                 |
>>> ";" should be "is"

The vertical bar indicates the location of the error, and the >>> prefix can be used to search for error messages. When this switch is used the only source lines output are those with errors.

-gnatl

The l stands for list. This switch causes a full listing of the file to be generated. In the case where a body is compiled, the corresponding spec is also listed, along with any subunits. Typical output from compiling a package body p.adb might look like:

Compiling: p.adb

     1. package body p is
     2.    procedure a;
     3.    procedure a is separate;
     4. begin
     5.    null
               |
        >>> missing ";"

     6. end;

Compiling: p.ads

     1. package p is
     2.    pragma Elaborate_Body
                                |
        >>> missing ";"

     3. end p;

Compiling: p-a.adb

     1. separate p
                |
        >>> missing "("

     2. procedure a is
     3. begin
     4.    null
               |
        >>> missing ";"

     5. end;

When you specify the -gnatv or -gnatl switches and standard output is redirected, a brief summary is written to stderr (standard error) giving the number of error messages and warning messages generated.

-gnatl=`fname'

This has the same effect as -gnatl except that the output is written to a file instead of to standard output. If the given name fname does not start with a period, then it is the full name of the file to be written. If fname is an extension, it is appended to the name of the file being compiled. For example, if file xyz.adb is compiled with -gnatl=.lst, then the output is written to file xyz.adb.lst.

-gnatU

This switch forces all error messages to be preceded by the unique string ‘error:’. This means that error messages take a few more characters in space, but allows easy searching for and identification of error messages.

-gnatb

The b stands for brief. This switch causes GNAT to generate the brief format error messages to stderr (the standard error file) as well as the verbose format message or full listing (which as usual is written to stdout (the standard output file).

-gnatm=`n'

The m stands for maximum. n is a decimal integer in the range of 1 to 999999 and limits the number of error or warning messages to be generated. For example, using -gnatm2 might yield

e.adb:3:04: Incorrect spelling of keyword "function"
e.adb:5:35: missing ".."
fatal error: maximum number of errors detected
compilation abandoned

The default setting if no switch is given is 9999. If the number of warnings reaches this limit, then a message is output and further warnings are suppressed, but the compilation is continued. If the number of error messages reaches this limit, then a message is output and the compilation is abandoned. A value of zero means that no limit applies.

Note that the equal sign is optional, so the switches -gnatm2 and -gnatm=2 are equivalent.

-gnatf

The f stands for full. Normally, the compiler suppresses error messages that are likely to be redundant. This switch causes all error messages to be generated. In particular, in the case of references to undefined variables. If a given variable is referenced several times, the normal format of messages is

e.adb:7:07: "V" is undefined (more references follow)

where the parenthetical comment warns that there are additional references to the variable V. Compiling the same program with the -gnatf switch yields

e.adb:7:07: "V" is undefined
e.adb:8:07: "V" is undefined
e.adb:8:12: "V" is undefined
e.adb:8:16: "V" is undefined
e.adb:9:07: "V" is undefined
e.adb:9:12: "V" is undefined

The -gnatf switch also generates additional information for some error messages. Some examples are:

• Details on possibly non-portable unchecked conversion
• List possible interpretations for ambiguous calls
• Additional details on incorrect parameters

-gnatjnn

In normal operation mode (or if -gnatj0 is used), then error messages with continuation lines are treated as though the continuation lines were separate messages (and so a warning with two continuation lines counts as three warnings, and is listed as three separate messages).

If the -gnatjnn switch is used with a positive value for nn, then messages are output in a different manner. A message and all its continuation lines are treated as a unit, and count as only one warning or message in the statistics totals. Furthermore, the message is reformatted so that no line is longer than nn characters.

-gnatq

The q stands for quit (really ‘don’t quit’). In normal operation mode, the compiler first parses the program and determines if there are any syntax errors. If there are, appropriate error messages are generated and compilation is immediately terminated. This switch tells GNAT to continue with semantic analysis even if syntax errors have been found. This may enable the detection of more errors in a single run. On the other hand, the semantic analyzer is more likely to encounter some internal fatal error when given a syntactically invalid tree.

-gnatQ

In normal operation mode, the ALI file is not generated if any illegalities are detected in the program. The use of -gnatQ forces generation of the ALI file. This file is marked as being in error, so it cannot be used for binding purposes, but it does contain reasonably complete cross-reference information, and thus may be useful for use by tools (e.g., semantic browsing tools or integrated development environments) that are driven from the ALI file. This switch implies -gnatq, since the semantic phase must be run to get a meaningful ALI file.

When -gnatQ is used and the generated ALI file is marked as being in error, gnatmake will attempt to recompile the source when it finds such an ALI file, including with switch -gnatc.

Note that -gnatQ has no effect if -gnats is specified, since ALI files are never generated if -gnats is set.

4.3.3 Warning Message Control

In addition to error messages, which correspond to illegalities as defined in the Ada Reference Manual, the compiler detects two kinds of warning situations.

First, the compiler considers some constructs suspicious and generates a warning message to alert you to a possible error. Second, if the compiler detects a situation that is sure to raise an exception at run time, it generates a warning message. The following shows an example of warning messages:

e.adb:4:24: warning: creation of object may raise Storage_Error
e.adb:10:17: warning: static value out of range
e.adb:10:17: warning: "Constraint_Error" will be raised at run time

GNAT considers a large number of situations as appropriate for the generation of warning messages. As always, warnings are not definite indications of errors. For example, if you do an out-of-range assignment with the deliberate intention of raising a Constraint_Error exception, then the warning that may be issued does not indicate an error. Some of the situations for which GNAT issues warnings (at least some of the time) are given in the following list. This list is not complete, and new warnings are often added to subsequent versions of GNAT. The list is intended to give a general idea of the kinds of warnings that are generated.

• Possible infinitely recursive calls
• Out-of-range values being assigned
• Possible order of elaboration problems
• Size not a multiple of alignment for a record type
• Assertions (pragma Assert) that are sure to fail
• Unreachable code
• Address clauses with possibly unaligned values, or where an attempt is made to overlay a smaller variable with a larger one.
• Fixed-point type declarations with a null range
• Direct_IO or Sequential_IO instantiated with a type that has access values
• Variables that are never assigned a value
• Variables that are referenced before being initialized
• Task entries with no corresponding accept statement
• Duplicate accepts for the same task entry in a select
• Objects that take too much storage
• Unchecked conversion between types of differing sizes
• Missing return statement along some execution path in a function
• Incorrect (unrecognized) pragmas
• Incorrect external names
• Allocation from empty storage pool
• Potentially blocking operation in protected type
• Suspicious parenthesization of expressions
• Mismatching bounds in an aggregate
• Attempt to return local value by reference
• Premature instantiation of a generic body
• Attempt to pack aliased components
• Out of bounds array subscripts
• Wrong length on string assignment
• Violations of style rules if style checking is enabled
• Unused `with' clauses
• Bit_Order usage that does not have any effect
• Standard.Duration used to resolve universal fixed expression
• Dereference of possibly null value
• Declaration that is likely to cause storage error
• Internal GNAT unit `with'ed by application unit
• Values known to be out of range at compile time
• Unreferenced or unmodified variables. Note that a special exemption applies to variables which contain any of the substrings DISCARD, DUMMY, IGNORE, JUNK, UNUSED, in any casing. Such variables are considered likely to be intentionally used in a situation where otherwise a warning would be given, so warnings of this kind are always suppressed for such variables.
• Address overlays that could clobber memory
• Unexpected initialization when address clause present
• Bad alignment for address clause
• Useless type conversions
• Redundant assignment statements and other redundant constructs
• Useless exception handlers
• Accidental hiding of name by child unit
• Access before elaboration detected at compile time
• A range in a for loop that is known to be null or might be null

The following section lists compiler switches that are available to control the handling of warning messages. It is also possible to exercise much finer control over what warnings are issued and suppressed using the GNAT pragma Warnings (see the description of the pragma in the GNAT_Reference_manual).

-gnatwa

`Activate most optional warnings.'

This switch activates most optional warning messages. See the remaining list in this section for details on optional warning messages that can be individually controlled. The warnings that are not turned on by this switch are:

• -gnatwd (implicit dereferencing)
• -gnatw.d (tag warnings with -gnatw switch)
• -gnatwh (hiding)
• -gnatw.h (holes in record layouts)
• -gnatw.j (late primitives of tagged types)
• -gnatw.k (redefinition of names in standard)
• -gnatwl (elaboration warnings)
• -gnatw.l (inherited aspects)
• -gnatw.n (atomic synchronization)
• -gnatwo (address clause overlay)
• -gnatw.o (values set by out parameters ignored)
• -gnatw.q (questionable layout of record types)
• -gnatw_r (out-of-order record representation clauses)
• -gnatw.s (overridden size clause)
• -gnatwt (tracking of deleted conditional code)
• -gnatw.u (unordered enumeration)
• -gnatw.w (use of Warnings Off)
• -gnatw.y (reasons for package needing body)

All other optional warnings are turned on.

-gnatwA

`Suppress all optional errors.'

This switch suppresses all optional warning messages, see remaining list in this section for details on optional warning messages that can be individually controlled. Note that unlike switch -gnatws, the use of switch -gnatwA does not suppress warnings that are normally given unconditionally and cannot be individually controlled (for example, the warning about a missing exit path in a function). Also, again unlike switch -gnatws, warnings suppressed by the use of switch -gnatwA can be individually turned back on. For example the use of switch -gnatwA followed by switch -gnatwd will suppress all optional warnings except the warnings for implicit dereferencing.

-gnatw.a

`Activate warnings on failing assertions.'

This switch activates warnings for assertions where the compiler can tell at compile time that the assertion will fail. Note that this warning is given even if assertions are disabled. The default is that such warnings are generated.

-gnatw.A

`Suppress warnings on failing assertions.'

This switch suppresses warnings for assertions where the compiler can tell at compile time that the assertion will fail.

-gnatw_a

`Activate warnings on anonymous allocators.'

This switch activates warnings for allocators of anonymous access types, which can involve run-time accessibility checks and lead to unexpected accessibility violations. For more details on the rules involved, see RM 3.10.2 (14).

-gnatw_A

`Supress warnings on anonymous allocators.'

This switch suppresses warnings for anonymous access type allocators.

-gnatwb

`Activate warnings on bad fixed values.'

This switch activates warnings for static fixed-point expressions whose value is not an exact multiple of Small. Such values are implementation dependent, since an implementation is free to choose either of the multiples that surround the value. GNAT always chooses the closer one, but this is not required behavior, and it is better to specify a value that is an exact multiple, ensuring predictable execution. The default is that such warnings are not generated.

-gnatwB

`Suppress warnings on bad fixed values.'

This switch suppresses warnings for static fixed-point expressions whose value is not an exact multiple of Small.

-gnatw.b

`Activate warnings on biased representation.'

This switch activates warnings when a size clause, value size clause, component clause, or component size clause forces the use of biased representation for an integer type (e.g. representing a range of 10..11 in a single bit by using 0/1 to represent 10/11). The default is that such warnings are generated.

-gnatw.B

`Suppress warnings on biased representation.'

This switch suppresses warnings for representation clauses that force the use of biased representation.

-gnatwc

`Activate warnings on conditionals.'

This switch activates warnings for conditional expressions used in tests that are known to be True or False at compile time. The default is that such warnings are not generated. Note that this warning does not get issued for the use of boolean variables or constants whose values are known at compile time, since this is a standard technique for conditional compilation in Ada, and this would generate too many false positive warnings.

This warning option also activates a special test for comparisons using the operators ‘>=’ and’ <=’. If the compiler can tell that only the equality condition is possible, then it will warn that the ‘>’ or ‘<’ part of the test is useless and that the operator could be replaced by ‘=’. An example would be comparing a Natural variable <= 0.

This warning option also generates warnings if one or both tests is optimized away in a membership test for integer values if the result can be determined at compile time. Range tests on enumeration types are not included, since it is common for such tests to include an end point.

This warning can also be turned on using -gnatwa.

-gnatwC

`Suppress warnings on conditionals.'

This switch suppresses warnings for conditional expressions used in tests that are known to be True or False at compile time.

-gnatw.c

`Activate warnings on missing component clauses.'

This switch activates warnings for record components where a record representation clause is present and has component clauses for the majority, but not all, of the components. A warning is given for each component for which no component clause is present.

-gnatw.C

`Suppress warnings on missing component clauses.'

This switch suppresses warnings for record components that are missing a component clause in the situation described above.

-gnatw_c

`Activate warnings on unknown condition in Compile_Time_Warning.'

This switch activates warnings on a pragma Compile_Time_Warning or Compile_Time_Error whose condition has a value that is not known at compile time. The default is that such warnings are generated.

-gnatw_C

`Suppress warnings on unknown condition in Compile_Time_Warning.'

This switch supresses warnings on a pragma Compile_Time_Warning or Compile_Time_Error whose condition has a value that is not known at compile time.

-gnatwd

`Activate warnings on implicit dereferencing.'

If this switch is set, then the use of a prefix of an access type in an indexed component, slice, or selected component without an explicit .all will generate a warning. With this warning enabled, access checks occur only at points where an explicit .all appears in the source code (assuming no warnings are generated as a result of this switch). The default is that such warnings are not generated.

-gnatwD

`Suppress warnings on implicit dereferencing.'

This switch suppresses warnings for implicit dereferences in indexed components, slices, and selected components.

-gnatw.d

`Activate tagging of warning and info messages.'

If this switch is set, then warning messages are tagged, with one of the following strings:

• `[-gnatw?]' Used to tag warnings controlled by the switch -gnatwx where x is a letter a-z.
• `[-gnatw.?]' Used to tag warnings controlled by the switch -gnatw.x where x is a letter a-z.
• `[-gnatel]' Used to tag elaboration information (info) messages generated when the static model of elaboration is used and the -gnatel switch is set.
• `[restriction warning]' Used to tag warning messages for restriction violations, activated by use of the pragma Restriction_Warnings.
• `[warning-as-error]' Used to tag warning messages that have been converted to error messages by use of the pragma Warning_As_Error. Note that such warnings are prefixed by the string “error: ” rather than “warning: “.
• `[enabled by default]' Used to tag all other warnings that are always given by default, unless warnings are completely suppressed using pragma `Warnings(Off)' or the switch -gnatws.

-gnatw.D

`Deactivate tagging of warning and info messages messages.'

If this switch is set, then warning messages return to the default mode in which warnings and info messages are not tagged as described above for -gnatw.d.

-gnatwe

`Treat warnings and style checks as errors.'

This switch causes warning messages and style check messages to be treated as errors. The warning string still appears, but the warning messages are counted as errors, and prevent the generation of an object file. Note that this is the only -gnatw switch that affects the handling of style check messages. Note also that this switch has no effect on info (information) messages, which are not treated as errors if this switch is present.

-gnatw.e

`Activate every optional warning.'

This switch activates all optional warnings, including those which are not activated by -gnatwa. The use of this switch is not recommended for normal use. If you turn this switch on, it is almost certain that you will get large numbers of useless warnings. The warnings that are excluded from -gnatwa are typically highly specialized warnings that are suitable for use only in code that has been specifically designed according to specialized coding rules.

-gnatwE

`Treat all run-time exception warnings as errors.'

This switch causes warning messages regarding errors that will be raised during run-time execution to be treated as errors.

-gnatwf

`Activate warnings on unreferenced formals.'

This switch causes a warning to be generated if a formal parameter is not referenced in the body of the subprogram. This warning can also be turned on using -gnatwu. The default is that these warnings are not generated.

-gnatwF

`Suppress warnings on unreferenced formals.'

This switch suppresses warnings for unreferenced formal parameters. Note that the combination -gnatwu followed by -gnatwF has the effect of warning on unreferenced entities other than subprogram formals.

-gnatwg

`Activate warnings on unrecognized pragmas.'

This switch causes a warning to be generated if an unrecognized pragma is encountered. Apart from issuing this warning, the pragma is ignored and has no effect. The default is that such warnings are issued (satisfying the Ada Reference Manual requirement that such warnings appear).

-gnatwG

`Suppress warnings on unrecognized pragmas.'

This switch suppresses warnings for unrecognized pragmas.

-gnatw.g

`Warnings used for GNAT sources.'

This switch sets the warning categories that are used by the standard GNAT style. Currently this is equivalent to -gnatwAao.q.s.CI.V.X.Z but more warnings may be added in the future without advanced notice.

-gnatwh

`Activate warnings on hiding.'

This switch activates warnings on hiding declarations that are considered potentially confusing. Not all cases of hiding cause warnings; for example an overriding declaration hides an implicit declaration, which is just normal code. The default is that warnings on hiding are not generated.

-gnatwH

`Suppress warnings on hiding.'

This switch suppresses warnings on hiding declarations.

-gnatw.h

`Activate warnings on holes/gaps in records.'

This switch activates warnings on component clauses in record representation clauses that leave holes (gaps) in the record layout. If this warning option is active, then record representation clauses should specify a contiguous layout, adding unused fill fields if needed.

-gnatw.H

`Suppress warnings on holes/gaps in records.'

This switch suppresses warnings on component clauses in record representation clauses that leave holes (haps) in the record layout.

-gnatwi

`Activate warnings on implementation units.'

This switch activates warnings for a `with' of an internal GNAT implementation unit, defined as any unit from the Ada, Interfaces, GNAT, or System hierarchies that is not documented in either the Ada Reference Manual or the GNAT Programmer’s Reference Manual. Such units are intended only for internal implementation purposes and should not be `with'ed by user programs. The default is that such warnings are generated

-gnatwI

`Disable warnings on implementation units.'

This switch disables warnings for a `with' of an internal GNAT implementation unit.

-gnatw.i

`Activate warnings on overlapping actuals.'

This switch enables a warning on statically detectable overlapping actuals in a subprogram call, when one of the actuals is an in-out parameter, and the types of the actuals are not by-copy types. This warning is off by default.

-gnatw.I

`Disable warnings on overlapping actuals.'

This switch disables warnings on overlapping actuals in a call.

-gnatwj

`Activate warnings on obsolescent features (Annex J).'

If this warning option is activated, then warnings are generated for calls to subprograms marked with pragma Obsolescent and for use of features in Annex J of the Ada Reference Manual. In the case of Annex J, not all features are flagged. In particular use of the renamed packages (like Text_IO) and use of package ASCII are not flagged, since these are very common and would generate many annoying positive warnings. The default is that such warnings are not generated.

In addition to the above cases, warnings are also generated for GNAT features that have been provided in past versions but which have been superseded (typically by features in the new Ada standard). For example, pragma Ravenscar will be flagged since its function is replaced by pragma Profile(Ravenscar), and pragma Interface_Name will be flagged since its function is replaced by pragma Import.

Note that this warning option functions differently from the restriction No_Obsolescent_Features in two respects. First, the restriction applies only to annex J features. Second, the restriction does flag uses of package ASCII.

-gnatwJ

`Suppress warnings on obsolescent features (Annex J).'

This switch disables warnings on use of obsolescent features.

-gnatw.j

`Activate warnings on late declarations of tagged type primitives.'

This switch activates warnings on visible primitives added to a tagged type after deriving a private extension from it.

-gnatw.J

`Suppress warnings on late declarations of tagged type primitives.'

This switch suppresses warnings on visible primitives added to a tagged type after deriving a private extension from it.

-gnatwk

`Activate warnings on variables that could be constants.'

This switch activates warnings for variables that are initialized but never modified, and then could be declared constants. The default is that such warnings are not given.

-gnatwK

`Suppress warnings on variables that could be constants.'

This switch disables warnings on variables that could be declared constants.

-gnatw.k

`Activate warnings on redefinition of names in standard.'

This switch activates warnings for declarations that declare a name that is defined in package Standard. Such declarations can be confusing, especially since the names in package Standard continue to be directly visible, meaning that use visibiliy on such redeclared names does not work as expected. Names of discriminants and components in records are not included in this check.

-gnatw.K

`Suppress warnings on redefinition of names in standard.'

This switch disables warnings for declarations that declare a name that is defined in package Standard.

-gnatwl

`Activate warnings for elaboration pragmas.'

This switch activates warnings for possible elaboration problems, including suspicious use of Elaborate pragmas, when using the static elaboration model, and possible situations that may raise Program_Error when using the dynamic elaboration model. See the section in this guide on elaboration checking for further details. The default is that such warnings are not generated.

-gnatwL

`Suppress warnings for elaboration pragmas.'

This switch suppresses warnings for possible elaboration problems.

-gnatw.l

`List inherited aspects.'

This switch causes the compiler to list inherited invariants, preconditions, and postconditions from Type_Invariant’Class, Invariant’Class, Pre’Class, and Post’Class aspects. Also list inherited subtype predicates.

-gnatw.L

`Suppress listing of inherited aspects.'

This switch suppresses listing of inherited aspects.

-gnatwm

`Activate warnings on modified but unreferenced variables.'

This switch activates warnings for variables that are assigned (using an initialization value or with one or more assignment statements) but whose value is never read. The warning is suppressed for volatile variables and also for variables that are renamings of other variables or for which an address clause is given. The default is that these warnings are not given.

-gnatwM

`Disable warnings on modified but unreferenced variables.'

This switch disables warnings for variables that are assigned or initialized, but never read.

-gnatw.m

`Activate warnings on suspicious modulus values.'

This switch activates warnings for modulus values that seem suspicious. The cases caught are where the size is the same as the modulus (e.g. a modulus of 7 with a size of 7 bits), and modulus values of 32 or 64 with no size clause. The guess in both cases is that 2**x was intended rather than x. In addition expressions of the form 2*x for small x generate a warning (the almost certainly accurate guess being that 2**x was intended). This switch also activates warnings for negative literal values of a modular type, which are interpreted as large positive integers after wrap-around. The default is that these warnings are given.

-gnatw.M

`Disable warnings on suspicious modulus values.'

This switch disables warnings for suspicious modulus values.

-gnatwn

`Set normal warnings mode.'

This switch sets normal warning mode, in which enabled warnings are issued and treated as warnings rather than errors. This is the default mode. the switch -gnatwn can be used to cancel the effect of an explicit -gnatws or -gnatwe. It also cancels the effect of the implicit -gnatwe that is activated by the use of -gnatg.

-gnatw.n

`Activate warnings on atomic synchronization.'

This switch actives warnings when an access to an atomic variable requires the generation of atomic synchronization code. These warnings are off by default.

-gnatw.N

`Suppress warnings on atomic synchronization.'

This switch suppresses warnings when an access to an atomic variable requires the generation of atomic synchronization code.

-gnatwo

`Activate warnings on address clause overlays.'

This switch activates warnings for possibly unintended initialization effects of defining address clauses that cause one variable to overlap another. The default is that such warnings are generated.

-gnatwO

`Suppress warnings on address clause overlays.'

This switch suppresses warnings on possibly unintended initialization effects of defining address clauses that cause one variable to overlap another.

-gnatw.o

`Activate warnings on modified but unreferenced out parameters.'

This switch activates warnings for variables that are modified by using them as actuals for a call to a procedure with an out mode formal, where the resulting assigned value is never read. It is applicable in the case where there is more than one out mode formal. If there is only one out mode formal, the warning is issued by default (controlled by -gnatwu). The warning is suppressed for volatile variables and also for variables that are renamings of other variables or for which an address clause is given. The default is that these warnings are not given.

-gnatw.O

`Disable warnings on modified but unreferenced out parameters.'

This switch suppresses warnings for variables that are modified by using them as actuals for a call to a procedure with an out mode formal, where the resulting assigned value is never read.

-gnatwp

`Activate warnings on ineffective pragma Inlines.'

This switch activates warnings for failure of front end inlining (activated by -gnatN) to inline a particular call. There are many reasons for not being able to inline a call, including most commonly that the call is too complex to inline. The default is that such warnings are not given. Warnings on ineffective inlining by the gcc back-end can be activated separately, using the gcc switch -Winline.

-gnatwP

`Suppress warnings on ineffective pragma Inlines.'

This switch suppresses warnings on ineffective pragma Inlines. If the inlining mechanism cannot inline a call, it will simply ignore the request silently.

-gnatw.p

`Activate warnings on parameter ordering.'

This switch activates warnings for cases of suspicious parameter ordering when the list of arguments are all simple identifiers that match the names of the formals, but are in a different order. The warning is suppressed if any use of named parameter notation is used, so this is the appropriate way to suppress a false positive (and serves to emphasize that the “misordering” is deliberate). The default is that such warnings are not given.

-gnatw.P

`Suppress warnings on parameter ordering.'

This switch suppresses warnings on cases of suspicious parameter ordering.

-gnatw_p

`Activate warnings for pedantic checks.'

This switch activates warnings for the failure of certain pedantic checks. The only case currently supported is a check that the subtype_marks given for corresponding formal parameter and function results in a subprogram declaration and its body denote the same subtype declaration. The default is that such warnings are not given.

-gnatw_P

`Suppress warnings for pedantic checks.'

This switch suppresses warnings on violations of pedantic checks.

-gnatwq

`Activate warnings on questionable missing parentheses.'

This switch activates warnings for cases where parentheses are not used and the result is potential ambiguity from a readers point of view. For example (not a > b) when a and b are modular means ((not a) > b) and very likely the programmer intended (not (a > b)). Similarly (-x mod 5) means (-(x mod 5)) and quite likely ((-x) mod 5) was intended. In such situations it seems best to follow the rule of always parenthesizing to make the association clear, and this warning switch warns if such parentheses are not present. The default is that these warnings are given.

-gnatwQ

`Suppress warnings on questionable missing parentheses.'

This switch suppresses warnings for cases where the association is not clear and the use of parentheses is preferred.

-gnatw.q

`Activate warnings on questionable layout of record types.'

This switch activates warnings for cases where the default layout of a record type, that is to say the layout of its components in textual order of the source code, would very likely cause inefficiencies in the code generated by the compiler, both in terms of space and speed during execution. One warning is issued for each problematic component without representation clause in the nonvariant part and then in each variant recursively, if any.

The purpose of these warnings is neither to prescribe an optimal layout nor to force the use of representation clauses, but rather to get rid of the most blatant inefficiencies in the layout. Therefore, the default layout is matched against the following synthetic ordered layout and the deviations are flagged on a component-by-component basis:

• first all components or groups of components whose length is fixed and a multiple of the storage unit,
• then the remaining components whose length is fixed and not a multiple of the storage unit,
• then the remaining components whose length doesn’t depend on discriminants (that is to say, with variable but uniform length for all objects),
• then all components whose length depends on discriminants,
• finally the variant part (if any),

for the nonvariant part and for each variant recursively, if any.

The exact wording of the warning depends on whether the compiler is allowed to reorder the components in the record type or precluded from doing it by means of pragma No_Component_Reordering.

The default is that these warnings are not given.

-gnatw.Q

`Suppress warnings on questionable layout of record types.'

This switch suppresses warnings for cases where the default layout of a record type would very likely cause inefficiencies.

-gnatwr

`Activate warnings on redundant constructs.'

This switch activates warnings for redundant constructs. The following is the current list of constructs regarded as redundant:

• Assignment of an item to itself.
• Type conversion that converts an expression to its own type.
• Use of the attribute Base where typ'Base is the same as typ.
• Use of pragma Pack when all components are placed by a record representation clause.
• Exception handler containing only a reraise statement (raise with no operand) which has no effect.
• Use of the operator abs on an operand that is known at compile time to be non-negative
• Comparison of an object or (unary or binary) operation of boolean type to an explicit True value.
• Import of parent package.

The default is that warnings for redundant constructs are not given.

-gnatwR

`Suppress warnings on redundant constructs.'

This switch suppresses warnings for redundant constructs.

-gnatw.r

`Activate warnings for object renaming function.'

This switch activates warnings for an object renaming that renames a function call, which is equivalent to a constant declaration (as opposed to renaming the function itself). The default is that these warnings are given.

-gnatw.R

`Suppress warnings for object renaming function.'

This switch suppresses warnings for object renaming function.

-gnatw_r

`Activate warnings for out-of-order record representation clauses.'

This switch activates warnings for record representation clauses, if the order of component declarations, component clauses, and bit-level layout do not all agree. The default is that these warnings are not given.

-gnatw_R

`Suppress warnings for out-of-order record representation clauses.'

-gnatws

`Suppress all warnings.'

This switch completely suppresses the output of all warning messages from the GNAT front end, including both warnings that can be controlled by switches described in this section, and those that are normally given unconditionally. The effect of this suppress action can only be cancelled by a subsequent use of the switch -gnatwn.

Note that switch -gnatws does not suppress warnings from the gcc back end. To suppress these back end warnings as well, use the switch -w in addition to -gnatws. Also this switch has no effect on the handling of style check messages.

-gnatw.s

`Activate warnings on overridden size clauses.'

This switch activates warnings on component clauses in record representation clauses where the length given overrides that specified by an explicit size clause for the component type. A warning is similarly given in the array case if a specified component size overrides an explicit size clause for the array component type.

-gnatw.S

`Suppress warnings on overridden size clauses.'

This switch suppresses warnings on component clauses in record representation clauses that override size clauses, and similar warnings when an array component size overrides a size clause.

-gnatwt

`Activate warnings for tracking of deleted conditional code.'

This switch activates warnings for tracking of code in conditionals (IF and CASE statements) that is detected to be dead code which cannot be executed, and which is removed by the front end. This warning is off by default. This may be useful for detecting deactivated code in certified applications.

-gnatwT

`Suppress warnings for tracking of deleted conditional code.'

This switch suppresses warnings for tracking of deleted conditional code.

-gnatw.t

`Activate warnings on suspicious contracts.'

This switch activates warnings on suspicious contracts. This includes warnings on suspicious postconditions (whether a pragma Postcondition or a Post aspect in Ada 2012) and suspicious contract cases (pragma or aspect Contract_Cases). A function postcondition or contract case is suspicious when no postcondition or contract case for this function mentions the result of the function. A procedure postcondition or contract case is suspicious when it only refers to the pre-state of the procedure, because in that case it should rather be expressed as a precondition. This switch also controls warnings on suspicious cases of expressions typically found in contracts like quantified expressions and uses of Update attribute. The default is that such warnings are generated.

-gnatw.T

`Suppress warnings on suspicious contracts.'

This switch suppresses warnings on suspicious contracts.

-gnatwu

`Activate warnings on unused entities.'

This switch activates warnings to be generated for entities that are declared but not referenced, and for units that are `with'ed and not referenced. In the case of packages, a warning is also generated if no entities in the package are referenced. This means that if a with’ed package is referenced but the only references are in use clauses or renames declarations, a warning is still generated. A warning is also generated for a generic package that is `with'ed but never instantiated. In the case where a package or subprogram body is compiled, and there is a `with' on the corresponding spec that is only referenced in the body, a warning is also generated, noting that the `with' can be moved to the body. The default is that such warnings are not generated. This switch also activates warnings on unreferenced formals (it includes the effect of -gnatwf).

-gnatwU

`Suppress warnings on unused entities.'

This switch suppresses warnings for unused entities and packages. It also turns off warnings on unreferenced formals (and thus includes the effect of -gnatwF).

-gnatw.u

`Activate warnings on unordered enumeration types.'

This switch causes enumeration types to be considered as conceptually unordered, unless an explicit pragma Ordered is given for the type. The effect is to generate warnings in clients that use explicit comparisons or subranges, since these constructs both treat objects of the type as ordered. (A `client' is defined as a unit that is other than the unit in which the type is declared, or its body or subunits.) Please refer to the description of pragma Ordered in the GNAT Reference Manual for further details. The default is that such warnings are not generated.

-gnatw.U

`Deactivate warnings on unordered enumeration types.'

This switch causes all enumeration types to be considered as ordered, so that no warnings are given for comparisons or subranges for any type.

-gnatwv

`Activate warnings on unassigned variables.'

This switch activates warnings for access to variables which may not be properly initialized. The default is that such warnings are generated. This switch will also be emitted when initializing an array or record object via the following aggregate:

Array_Or_Record : XXX := (others => <>);

unless the relevant type fully initializes all components.

-gnatwV

`Suppress warnings on unassigned variables.'

This switch suppresses warnings for access to variables which may not be properly initialized.

-gnatw.v

`Activate info messages for non-default bit order.'

This switch activates messages (labeled “info”, they are not warnings, just informational messages) about the effects of non-default bit-order on records to which a component clause is applied. The effect of specifying non-default bit ordering is a bit subtle (and changed with Ada 2005), so these messages, which are given by default, are useful in understanding the exact consequences of using this feature.

-gnatw.V

`Suppress info messages for non-default bit order.'

This switch suppresses information messages for the effects of specifying non-default bit order on record components with component clauses.

-gnatww

`Activate warnings on wrong low bound assumption.'

This switch activates warnings for indexing an unconstrained string parameter with a literal or S’Length. This is a case where the code is assuming that the low bound is one, which is in general not true (for example when a slice is passed). The default is that such warnings are generated.

-gnatwW

`Suppress warnings on wrong low bound assumption.'

This switch suppresses warnings for indexing an unconstrained string parameter with a literal or S’Length. Note that this warning can also be suppressed in a particular case by adding an assertion that the lower bound is 1, as shown in the following example:

procedure K (S : String) is
   pragma Assert (S'First = 1);
   ...

-gnatw.w

`Activate warnings on Warnings Off pragmas.'

This switch activates warnings for use of pragma Warnings (Off, entity) where either the pragma is entirely useless (because it suppresses no warnings), or it could be replaced by pragma Unreferenced or pragma Unmodified. Also activates warnings for the case of Warnings (Off, String), where either there is no matching Warnings (On, String), or the Warnings (Off) did not suppress any warning. The default is that these warnings are not given.

-gnatw.W

`Suppress warnings on unnecessary Warnings Off pragmas.'

This switch suppresses warnings for use of pragma Warnings (Off, ...).

-gnatwx

`Activate warnings on Export/Import pragmas.'

This switch activates warnings on Export/Import pragmas when the compiler detects a possible conflict between the Ada and foreign language calling sequences. For example, the use of default parameters in a convention C procedure is dubious because the C compiler cannot supply the proper default, so a warning is issued. The default is that such warnings are generated.

-gnatwX

`Suppress warnings on Export/Import pragmas.'

This switch suppresses warnings on Export/Import pragmas. The sense of this is that you are telling the compiler that you know what you are doing in writing the pragma, and it should not complain at you.

-gnatw.x

`Activate warnings for No_Exception_Propagation mode.'

This switch activates warnings for exception usage when pragma Restrictions (No_Exception_Propagation) is in effect. Warnings are given for implicit or explicit exception raises which are not covered by a local handler, and for exception handlers which do not cover a local raise. The default is that these warnings are given for units that contain exception handlers.

-gnatw.X

`Disable warnings for No_Exception_Propagation mode.'

This switch disables warnings for exception usage when pragma Restrictions (No_Exception_Propagation) is in effect.

-gnatwy

`Activate warnings for Ada compatibility issues.'

For the most part, newer versions of Ada are upwards compatible with older versions. For example, Ada 2005 programs will almost always work when compiled as Ada 2012. However there are some exceptions (for example the fact that some is now a reserved word in Ada 2012). This switch activates several warnings to help in identifying and correcting such incompatibilities. The default is that these warnings are generated. Note that at one point Ada 2005 was called Ada 0Y, hence the choice of character.

-gnatwY

`Disable warnings for Ada compatibility issues.'

This switch suppresses the warnings intended to help in identifying incompatibilities between Ada language versions.

-gnatw.y

`Activate information messages for why package spec needs body.'

There are a number of cases in which a package spec needs a body. For example, the use of pragma Elaborate_Body, or the declaration of a procedure specification requiring a completion. This switch causes information messages to be output showing why a package specification requires a body. This can be useful in the case of a large package specification which is unexpectedly requiring a body. The default is that such information messages are not output.

-gnatw.Y

`Disable information messages for why package spec needs body.'

This switch suppresses the output of information messages showing why a package specification needs a body.

-gnatwz

`Activate warnings on unchecked conversions.'

This switch activates warnings for unchecked conversions where the types are known at compile time to have different sizes. The default is that such warnings are generated. Warnings are also generated for subprogram pointers with different conventions.

-gnatwZ

`Suppress warnings on unchecked conversions.'

This switch suppresses warnings for unchecked conversions where the types are known at compile time to have different sizes or conventions.

-gnatw.z

`Activate warnings for size not a multiple of alignment.'

This switch activates warnings for cases of array and record types with specified Size and Alignment attributes where the size is not a multiple of the alignment, resulting in an object size that is greater than the specified size. The default is that such warnings are generated.

-gnatw.Z

`Suppress warnings for size not a multiple of alignment.'

This switch suppresses warnings for cases of array and record types with specified Size and Alignment attributes where the size is not a multiple of the alignment, resulting in an object size that is greater than the specified size. The warning can also be suppressed by giving an explicit Object_Size value.

-Wunused

The warnings controlled by the -gnatw switch are generated by the front end of the compiler. The GCC back end can provide additional warnings and they are controlled by the -W switch. For example, -Wunused activates back end warnings for entities that are declared but not referenced.

-Wuninitialized

Similarly, -Wuninitialized activates the back end warning for uninitialized variables. This switch must be used in conjunction with an optimization level greater than zero.

-Wstack-usage=`len'

Warn if the stack usage of a subprogram might be larger than len bytes. See Static Stack Usage Analysis for details.

-Wall

This switch enables most warnings from the GCC back end. The code generator detects a number of warning situations that are missed by the GNAT front end, and this switch can be used to activate them. The use of this switch also sets the default front-end warning mode to -gnatwa, that is, most front-end warnings are activated as well.

-w

Conversely, this switch suppresses warnings from the GCC back end. The use of this switch also sets the default front-end warning mode to -gnatws, that is, front-end warnings are suppressed as well.

-Werror

This switch causes warnings from the GCC back end to be treated as errors. The warning string still appears, but the warning messages are counted as errors, and prevent the generation of an object file. The use of this switch also sets the default front-end warning mode to -gnatwe, that is, front-end warning messages and style check messages are treated as errors as well.

A string of warning parameters can be used in the same parameter. For example:

-gnatwaGe

will turn on all optional warnings except for unrecognized pragma warnings, and also specify that warnings should be treated as errors.

When no switch -gnatw is used, this is equivalent to:

• -gnatw.a
• -gnatwB
• -gnatw.b
• -gnatwC
• -gnatw.C
• -gnatwD
• -gnatw.D
• -gnatwF
• -gnatw.F
• -gnatwg
• -gnatwH
• -gnatw.H
• -gnatwi
• -gnatwJ
• -gnatw.J
• -gnatwK
• -gnatw.K
• -gnatwL
• -gnatw.L
• -gnatwM
• -gnatw.m
• -gnatwn
• -gnatw.N
• -gnatwo
• -gnatw.O
• -gnatwP
• -gnatw.P
• -gnatwq
• -gnatw.Q
• -gnatwR
• -gnatw.R
• -gnatw.S
• -gnatwT
• -gnatw.t
• -gnatwU
• -gnatw.U
• -gnatwv
• -gnatw.v
• -gnatww
• -gnatw.W
• -gnatwx
• -gnatw.X
• -gnatwy
• -gnatw.Y
• -gnatwz
• -gnatw.z