\input texinfo @c -*-texinfo-*-
@c %**start of header
-
-@c oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
-@c o
-@c GNAT DOCUMENTATION o
-@c o
-@c G N A T C O D I N G S T Y L E o
-@c o
-@c Copyright (C) 1992-2012, AdaCore o
-@c o
-@c oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
-
@setfilename gnat-style.info
+@documentencoding UTF-8
+@ifinfo
+@*Generated by Sphinx 4.0.2.@*
+@end ifinfo
+@settitle GNAT Coding Style A Guide for GNAT Developers
+@defindex ge
+@paragraphindent 0
+@exampleindent 4
+@finalout
+@dircategory GNU Ada Tools
+@direntry
+* gnat-style: (gnat-style.info). gnat-style
+@end direntry
-@copying
-Copyright @copyright{} 1992-2012, AdaCore
+@definfoenclose strong,`,'
+@definfoenclose emph,`,'
+@c %**end of header
-Permission is granted to copy, distribute and/or modify this document
-under the terms of the GNU Free Documentation License, Version 1.3 or
-any later version published by the Free Software Foundation; with no
-Invariant Sections, with no Front-Cover Texts and with no Back-Cover
-Texts. A copy of the license is included in the section entitled
-``GNU Free Documentation License''.
-@end copying
+@copying
+@quotation
+GNAT Coding Style: A Guide for GNAT Developers , Jun 23, 2021
-@settitle GNAT Coding Style
-@setchapternewpage odd
+AdaCore
-@include gcc-common.texi
+Copyright @copyright{} 2008-2021, Free Software Foundation
+@end quotation
-@dircategory Software development
-@direntry
-* gnat-style: (gnat-style). GNAT Coding Style
-@end direntry
-
-@macro syntax{element}
-@t{\element\}
-@end macro
-@c %**end of header
+@end copying
@titlepage
-@titlefont{GNAT Coding Style:}
-@sp 1
-@title A Guide for GNAT Developers
-@subtitle GNAT, The GNU Ada Compiler
-@versionsubtitle
-@author Ada Core Technologies, Inc.
-@page
-@vskip 0pt plus 1filll
-
+@title GNAT Coding Style A Guide for GNAT Developers
@insertcopying
@end titlepage
+@contents
-@raisesections
+@c %** start of user preamble
-@node Top, General, , (dir)
-@comment node-name, next, previous, up
+@c %** end of user preamble
@ifnottex
-@noindent
-GNAT Coding Style@*
-A Guide for GNAT Developers
-@sp 2
-@noindent
-GNAT, The GNU Ada Compiler@*
-
-@noindent
+@node Top
+@top GNAT Coding Style A Guide for GNAT Developers
@insertcopying
@end ifnottex
-
+@c %**start of body
+@anchor{gnat-style doc}@anchor{0}
@menu
-* General::
-* Lexical Elements::
-* Declarations and Types::
-* Expressions and Names::
-* Statements::
-* Subprograms::
-* Packages::
-* Program Structure::
-* GNU Free Documentation License::
-* Index::
+* General::
+* Lexical Elements::
+* Declarations and Types::
+* Expressions and Names::
+* Statements::
+* Subprograms::
+* Packages and Visibility Rules::
+* Program Structure and Compilation Issues::
+* Index::
+
@end menu
-@c -------------------------------------------------------------------------
-@node General, Lexical Elements, Top, Top
-@section General
-@c -------------------------------------------------------------------------
+@node General,Lexical Elements,Top,Top
+@anchor{gnat-style general}@anchor{1}@anchor{gnat-style gnat-coding-style-a-guide-for-gnat-developers}@anchor{2}
+@chapter General
+
-@noindent
Most of GNAT is written in Ada using a consistent style to ensure
readability of the code. This document has been written to help
maintain this consistent style, while having a large group of developers
For the coding style in the C parts of the compiler and run time,
see the GNU Coding Guidelines.
-This document is structured after the @cite{Ada Reference Manual}.
+This document is structured after the Ada Reference Manual.
Those familiar with that document should be able to quickly
lookup style rules for particular constructs.
+@node Lexical Elements,Declarations and Types,General,Top
+@anchor{gnat-style lexical-elements}@anchor{3}
+@chapter Lexical Elements
-@c -------------------------------------------------------------------------
-@node Lexical Elements, Declarations and Types, General, Top
-@section Lexical Elements
-@c -------------------------------------------------------------------------
-@cindex Lexical elements
-
-@subsection Character Set and Separators
-@c -------------------------------------------------------------------------
-@cindex Character set
-@cindex ASCII
-@cindex Separators
-@cindex End-of-line
-@cindex Line length
-@cindex Indentation
-
-@itemize @bullet
-@item
-The character set used should be plain 7-bit ASCII@.
+
+@menu
+* Character Set and Separators::
+* Identifiers::
+* Numeric Literals::
+* Reserved Words::
+* Comments::
+
+@end menu
+
+@node Character Set and Separators,Identifiers,,Lexical Elements
+@anchor{gnat-style character-set-and-separators}@anchor{4}
+@section Character Set and Separators
+
+
+@geindex Character set
+
+@geindex ASCII
+
+@geindex Separators
+
+@geindex End-of-line
+
+@geindex Line length
+
+@geindex Indentation
+
+
+@itemize *
+
+@item
+The character set used should be plain 7-bit ASCII.
The only separators allowed are space and the end-of-line sequence.
No other control character or format effector (such as @code{HT},
-@code{VT}, @code{FF})
+@code{VT}, @code{FF} )
should be used.
The normal end-of-line sequence is used, which may be
@code{LF}, @code{CR/LF} or @code{CR},
depending on the host system. An optional @code{SUB}
-(@code{16#1A#}) may be present as the
+( @code{16#1A#} ) may be present as the
last character in the file on hosts using that character as file terminator.
-@item
+@item
Files that are checked in or distributed should be in host format.
-@item
+@item
A line should never be longer than 79 characters, not counting the line
separator.
-@item
+@item
Lines must not have trailing blanks.
-@item
+@item
Indentation is 3 characters per level for @code{if} statements, loops, and
@code{case} statements.
For exact information on required spacing between lexical
-elements, see file @file{style.adb}.
-@cindex @file{style.adb} file
+elements, see file style.adb.
+
+@geindex style.adb file
@end itemize
+@node Identifiers,Numeric Literals,Character Set and Separators,Lexical Elements
+@anchor{gnat-style identifiers}@anchor{5}
+@section Identifiers
+
-@subsection Identifiers
-@c -------------------------------------------------------------------------
-@itemize @bullet
-@cindex Identifiers
-@item
+@itemize *
+
+@item
Identifiers will start with an upper case letter, and each letter following
an underscore will be upper case.
-@cindex Casing (for identifiers)
+
+@geindex Casing (for identifiers)
+
Short acronyms may be all upper case.
All other letters are lower case.
An exception is for identifiers matching a foreign language. In particular,
-we use all lower case where appropriate for C@.
+we use all lower case where appropriate for C.
-@item
+@item
Use underscores to separate words in an identifier.
-@cindex Underscores
-@item Try to limit your use of abbreviations in identifiers.
+@geindex Underscores
+
+@item
+Try to limit your use of abbreviations in identifiers.
It is ok to make a few abbreviations, explain what they mean, and then
-use them frequently, but don't use lots of obscure abbreviations. An
+use them frequently, but don’t use lots of obscure abbreviations. An
example is the @code{ALI} word which stands for Ada Library
Information and is by convention always written in upper-case when
used in entity names.
-@smallexample @c adanocomment
- procedure Find_ALI_Files;
-@end smallexample
+@example
+procedure Find_ALI_Files;
+@end example
-@item
-Don't use the variable name @code{I}, use @code{J} instead; @code{I} is too
-easily confused with @code{1} in some fonts. Similarly don't use the
+@item
+Don’t use the variable name @code{I}, use @code{J} instead; @code{I} is too
+easily confused with @code{1} in some fonts. Similarly don’t use the
variable @code{O}, which is too easily mistaken for the number @code{0}.
@end itemize
-@subsection Numeric Literals
-@c -------------------------------------------------------------------------
-@cindex Numeric literals
+@node Numeric Literals,Reserved Words,Identifiers,Lexical Elements
+@anchor{gnat-style numeric-literals}@anchor{6}
+@section Numeric Literals
+
+
+
+@itemize *
-@itemize @bullet
-@item
+@item
Numeric literals should include underscores where helpful for
readability.
-@cindex Underscores
-@smallexample
- 1_000_000
- 16#8000_0000#
- 3.14159_26535_89793_23846
-@end smallexample
+@geindex Underscores
+
+@example
+1_000_000
+16#8000_0000#
+3.14159_26535_89793_23846
+@end example
@end itemize
-@subsection Reserved Words
-@c -------------------------------------------------------------------------
-@cindex Reserved words
+@node Reserved Words,Comments,Numeric Literals,Lexical Elements
+@anchor{gnat-style reserved-words}@anchor{7}
+@section Reserved Words
+
+
-@itemize @bullet
-@item
+@itemize *
+
+@item
Reserved words use all lower case.
-@cindex Casing (for reserved words)
-@smallexample @c adanocomment
- return else
-@end smallexample
+@geindex Casing (for reserved words)
+
+@example
+return else
+@end example
-@item
+@item
The words @code{Access}, @code{Delta} and @code{Digits} are
-capitalized when used as @syntax{attribute_designator}.
+capitalized when used as attribute_designator.
@end itemize
-@subsection Comments
-@c -------------------------------------------------------------------------
-@cindex Comments
+@node Comments,,Reserved Words,Lexical Elements
+@anchor{gnat-style comments}@anchor{8}
+@section Comments
-@itemize @bullet
-@item
+
+
+@itemize *
+
+@item
A comment starts with @code{--} followed by two spaces.
-The only exception to this rule (i.e.@: one space is tolerated) is when the
+The only exception to this rule (i.e. one space is tolerated) is when the
comment ends with a single space followed by @code{--}.
It is also acceptable to have only one space between @code{--} and the start
of the comment when the comment is at the end of a line,
after some Ada code.
-@item
+@item
Every sentence in a comment should start with an upper-case letter (including
the first letter of the comment).
-@cindex Casing (in comments)
-@item
-When declarations are commented with ``hanging'' comments, i.e.@:
+@geindex Casing (in comments)
+
+@item
+When declarations are commented with ‘hanging’ comments, i.e.
comments after the declaration, there is no blank line before the
comment, and if it is absolutely necessary to have blank lines within
the comments, e.g. to make paragraph separations within a single comment,
normal rule, which is to use entirely blank lines for separating
comment paragraphs). The comment starts at same level of indentation
as code it is commenting.
-@cindex Blank lines (in comments)
-@cindex Indentation
-@smallexample @c adanocomment
- z : Integer;
- -- Integer value for storing value of z
- --
- -- The previous line was a blank line.
-@end smallexample
+@geindex Blank lines (in comments)
+
+@geindex Indentation
-@item
+@example
+z : Integer;
+-- Integer value for storing value of z
+--
+-- The previous line was a blank line.
+@end example
+
+@item
Comments that are dubious or incomplete, or that comment on possibly
-wrong or incomplete code, should be preceded or followed by @code{???}@.
+wrong or incomplete code, should be preceded or followed by @code{???}.
-@item
+@item
Comments in a subprogram body must generally be surrounded by blank lines.
An exception is a comment that follows a line containing a single keyword
-(@code{begin}, @code{else}, @code{loop}):
+( @code{begin}, @code{else}, @code{loop} ):
-@smallexample @c adanocomment
-@group
- begin
- -- Comment for the next statement
+@example
+begin
+ -- Comment for the next statement
- A := 5;
+ A := 5;
- -- Comment for the B statement
+ -- Comment for the B statement
- B := 6;
- end;
-@end group
-@end smallexample
+ B := 6;
+end;
+@end example
-@item
+@item
In sequences of statements, comments at the end of the lines should be
aligned.
-@cindex Alignment (in comments)
-@smallexample @c adanocomment
- My_Identifier := 5; -- First comment
- Other_Id := 6; -- Second comment
-@end smallexample
+@geindex Alignment (in comments)
+
+@example
+My_Identifier := 5; -- First comment
+Other_Id := 6; -- Second comment
+@end example
-@item
+@item
Short comments that fit on a single line are @emph{not} ended with a
period. Comments taking more than a line are punctuated in the normal
manner.
-@item
+@item
Comments should focus on @emph{why} instead of @emph{what}.
Descriptions of what subprograms do go with the specification.
-@item
+@item
Comments describing a subprogram spec should specifically mention the
formal argument names. General rule: write a comment that does not
depend on the names of things. The names are supplementary, not
sufficient, as comments.
-@item
+@item
@emph{Do not} put two spaces after periods in comments.
@end itemize
-@c -------------------------------------------------------------------------
-@node Declarations and Types, Expressions and Names, Lexical Elements,Top
-@section Declarations and Types
-@c -------------------------------------------------------------------------
-@cindex Declarations and Types
+@node Declarations and Types,Expressions and Names,Lexical Elements,Top
+@anchor{gnat-style declarations-and-types}@anchor{9}
+@chapter Declarations and Types
+
+
-@itemize @bullet
-@item
+@itemize *
+
+@item
In entity declarations, colons must be surrounded by spaces. Colons
should be aligned.
-@cindex Alignment (in declarations)
-@smallexample @c adanocomment
- Entity1 : Integer;
- My_Entity : Integer;
-@end smallexample
+@geindex Alignment (in declarations)
+
+@example
+Entity1 : Integer;
+My_Entity : Integer;
+@end example
-@item
+@item
Declarations should be grouped in a logical order.
Related groups of declarations may be preceded by a header comment.
-@item
+@item
All local subprograms in a subprogram or package body should be declared
before the first local subprogram body.
-@item
+@item
Do not declare local entities that hide global entities.
-@cindex Hiding of outer entities
-@item
+@geindex Hiding of outer entities
+
+@item
Do not declare multiple variables in one declaration that spans lines.
Start a new declaration on each line, instead.
-@item
-The @syntax{defining_identifier}s of global declarations serve as
-comments of a sort. So don't choose terse names, but look for names
+@item
+The defining_identifiers of global declarations serve as
+comments of a sort. So don’t choose terse names, but look for names
that give useful information instead.
-@item
+@item
Local names can be shorter, because they are used only within
one context, where comments explain their purpose.
-@item
+@item
When starting an initialization or default expression on the line that follows
the declaration line, use 2 characters for indentation.
-@smallexample @c adanocomment
- Entity1 : Integer :=
- Function_Name (Parameters, For_Call);
-@end smallexample
+@example
+Entity1 : Integer :=
+ Function_Name (Parameters, For_Call);
+@end example
-@item
+@item
If an initialization or default expression needs to be continued on subsequent
lines, the continuations should be indented from the start of the expression.
-@smallexample @c adanocomment
- Entity1 : Integer := Long_Function_Name
- (parameters for call);
-@end smallexample
-
+@example
+Entity1 : Integer := Long_Function_Name
+ (parameters for call);
+@end example
@end itemize
+@node Expressions and Names,Statements,Declarations and Types,Top
+@anchor{gnat-style expressions-and-names}@anchor{a}
+@chapter Expressions and Names
+
-@c -------------------------------------------------------------------------
-@node Expressions and Names, Statements, Declarations and Types, Top
-@section Expressions and Names
-@c -------------------------------------------------------------------------
-@cindex Expressions and names
-@itemize @bullet
+@itemize *
-@item
+@item
Every operator must be surrounded by spaces. An exception is that
this rule does not apply to the exponentiation operator, for which
there are no specific layout rules. The reason for this exception
is that sometimes it makes clearer reading to leave out the spaces
around exponentiation.
-@cindex Operators
-@smallexample @c adanocomment
- E := A * B**2 + 3 * (C - D);
-@end smallexample
+@geindex Operators
-@item
+@example
+E := A * B**2 + 3 * (C - D);
+@end example
+
+@item
Use parentheses where they clarify the intended association of operands
with operators:
-@cindex Parenthesization of expressions
-@smallexample @c adanocomment
- (A / B) * C
-@end smallexample
+
+@geindex Parenthesization of expressions
+
+@example
+(A / B) * C
+@end example
@end itemize
-@c -------------------------------------------------------------------------
-@node Statements, Subprograms, Expressions and Names, Top
-@section Statements
-@c -------------------------------------------------------------------------
-@cindex Statements
+@node Statements,Subprograms,Expressions and Names,Top
+@anchor{gnat-style statements}@anchor{b}
+@chapter Statements
+
+
+@menu
+* Simple and Compound Statements::
+* If Statements::
+* Case Statements::
+* Loop Statements::
+* Block Statements::
+
+@end menu
+
+@node Simple and Compound Statements,If Statements,,Statements
+@anchor{gnat-style simple-and-compound-statements}@anchor{c}
+@section Simple and Compound Statements
-@subsection Simple and Compound Statements
-@c -------------------------------------------------------------------------
-@cindex Simple and compound statements
-@itemize @bullet
-@item
+
+@itemize *
+
+@item
Use only one statement or label per line.
-@item
-A longer @syntax{sequence_of_statements} may be divided in logical
+
+@item
+A longer sequence_of_statements may be divided in logical
groups or separated from surrounding code using a blank line.
@end itemize
-@subsection If Statements
-@c -------------------------------------------------------------------------
-@cindex @code{if} statement
+@node If Statements,Case Statements,Simple and Compound Statements,Statements
+@anchor{gnat-style if-statements}@anchor{d}
+@section If Statements
+
-@itemize @bullet
-@item
+
+@itemize *
+
+@item
When the @code{if}, @code{elsif} or @code{else} keywords fit on the
same line with the condition and the @code{then} keyword, then the
statement is formatted as follows:
-@cindex Alignment (in an @code{if} statement)
-
-@smallexample @c adanocomment
-@group
- if @var{condition} then
- ...
- elsif @var{condition} then
- ...
- else
- ...
- end if;
-@end group
-@end smallexample
-
-@noindent
+
+@geindex Alignment (in an if statement)
+
+@example
+if condition then
+ ...
+elsif condition then
+ ...
+else
+ ...
+end if;
+@end example
+
When the above layout is not possible, @code{then} should be aligned
with @code{if}, and conditions should preferably be split before an
@code{and} or @code{or} keyword a follows:
-@smallexample @c adanocomment
-@group
- if @var{long_condition_that_has_to_be_split}
- and then @var{continued_on_the_next_line}
- then
- ...
- end if;
-@end group
-@end smallexample
-
-@noindent
+@example
+if long_condition_that_has_to_be_split
+ and then continued_on_the_next_line
+then
+ ...
+end if;
+@end example
+
The @code{elsif}, @code{else} and @code{end if} always line up with
the @code{if} keyword. The preferred location for splitting the line
is before @code{and} or @code{or}. The continuation of a condition is
As an exception, if conditions are closely related either of the
following is allowed:
-@smallexample
-@group
- if x = lakdsjfhlkashfdlkflkdsalkhfsalkdhflkjdsahf
- or else
- x = asldkjhalkdsjfhhfd
- or else
- x = asdfadsfadsf
- then
- ...
- end if;
-@end group
-
-@group
- if x = lakdsjfhlkashfdlkflkdsalkhfsalkdhflkjdsahf or else
- x = asldkjhalkdsjfhhfd or else
- x = asdfadsfadsf
- then
- ...
- end if;
-@end group
-@end smallexample
-
-@item
-Conditions should use short-circuit forms (@code{and then},
-@code{or else}), except when the operands are boolean variables
+@example
+if x = lakdsjfhlkashfdlkflkdsalkhfsalkdhflkjdsahf
+ or else
+ x = asldkjhalkdsjfhhfd
+ or else
+ x = asdfadsfadsf
+then
+ ...
+end if;
+
+if x = lakdsjfhlkashfdlkflkdsalkhfsalkdhflkjdsahf or else
+ x = asldkjhalkdsjfhhfd or else
+ x = asdfadsfadsf
+then
+ ...
+end if;
+@end example
+
+@item
+Conditions should use short-circuit forms ( @code{and then},
+@code{or else} ), except when the operands are boolean variables
or boolean constants.
-@cindex Short-circuit forms
-@item
+@geindex Short-circuit forms
+
+@item
Complex conditions in @code{if} statements are indented two characters:
-@cindex Indentation (in @code{if} statements)
-
-@smallexample @c adanocomment
-@group
- if @var{this_complex_condition}
- and then @var{that_other_one}
- and then @var{one_last_one}
- then
- ...
- end if;
-@end group
-@end smallexample
-
-@noindent
+
+@geindex Indentation (in if statements)
+
+@example
+if this_complex_condition
+ and then that_other_one
+ and then one_last_one
+then
+ ...
+end if;
+@end example
+
There are some cases where complex conditionals can be laid out
in manners that do not follow these rules to preserve better
parallelism between branches, e.g.
-@smallexample @c adanocomment
-@group
- if xyz.abc (gef) = 'c'
- or else
- xyz.abc (gef) = 'x'
- then
- ...
- end if;
-@end group
-@end smallexample
+@example
+if xyz.abc (gef) = 'c'
+ or else
+ xyz.abc (gef) = 'x'
+then
+ ...
+end if;
+@end example
-
-@item
+@item
Every @code{if} block is preceded and followed by a blank line, except
-where it begins or ends a @syntax{sequence_of_statements}.
-@cindex Blank lines (in an @code{if} statement)
+where it begins or ends a sequence_of_statements.
+
+@geindex Blank lines (in an if statement)
-@smallexample @c adanocomment
-@group
- A := 5;
+@example
+A := 5;
- if A = 5 then
- null;
- end if;
+if A = 5 then
+ null;
+end if;
- A := 6;
-@end group
-@end smallexample
+A := 6;
+@end example
@end itemize
-@subsection Case Statements
-@cindex @code{case} statements
+@node Case Statements,Loop Statements,If Statements,Statements
+@anchor{gnat-style case-statements}@anchor{e}
+@section Case Statements
+
+
+
+@itemize *
-@itemize @bullet
-@item
+@item
Layout is as below. For long @code{case} statements, the extra indentation
can be saved by aligning the @code{when} clauses with the opening @code{case}.
-@smallexample @c adanocomment
-@group
- case @var{expression} is
- when @var{condition} =>
- ...
- when @var{condition} =>
- ...
- end case;
-@end group
-@end smallexample
+@example
+case expression is
+ when condition =>
+ ...
+ when condition =>
+ ...
+end case;
+@end example
@end itemize
-@subsection Loop Statements
-@cindex Loop statements
+@node Loop Statements,Block Statements,Case Statements,Statements
+@anchor{gnat-style loop-statements}@anchor{f}
+@section Loop Statements
+
+
-@itemize @bullet
-@item
+@itemize *
+
+@item
When possible, have @code{for} or @code{while} on one line with the
condition and the @code{loop} keyword.
-@smallexample @c adanocomment
-@group
- for J in S'Range loop
- ...
- end loop;
-@end group
-@end smallexample
-
-@noindent
-If the condition is too long, split the condition (see ``If
-statements'' above) and align @code{loop} with the @code{for} or
+@example
+for J in S'Range loop
+ ...
+end loop;
+@end example
+
+If the condition is too long, split the condition (see ‘If
+statements’ above) and align @code{loop} with the @code{for} or
@code{while} keyword.
-@cindex Alignment (in a loop statement)
-
-@smallexample @c adanocomment
-@group
- while @var{long_condition_that_has_to_be_split}
- and then @var{continued_on_the_next_line}
- loop
- ...
- end loop;
-@end group
-@end smallexample
-
-@noindent
-If the @syntax{loop_statement} has an identifier, it is laid out as follows:
-
-@smallexample @c adanocomment
-@group
- Outer : while not @var{condition} loop
- ...
- end Outer;
-@end group
-@end smallexample
+
+@geindex Alignment (in a loop statement)
+
+@example
+while long_condition_that_has_to_be_split
+ and then continued_on_the_next_line
+loop
+ ...
+end loop;
+@end example
+
+If the loop_statement has an identifier, it is laid out as follows:
+
+@example
+Outer : while not condition loop
+ ...
+end Outer;
+@end example
@end itemize
-@subsection Block Statements
-@cindex Block statement
+@node Block Statements,,Loop Statements,Statements
+@anchor{gnat-style block-statements}@anchor{10}
+@section Block Statements
+
+
+
+@itemize *
-@itemize @bullet
-@item
+@item
The @code{declare} (optional), @code{begin} and @code{end} words
-are aligned, except when the @syntax{block_statement} is named. There
+are aligned, except when the block_statement is named. There
is a blank line before the @code{begin} keyword:
-@cindex Alignment (in a block statement)
-@smallexample @c adanocomment
-@group
- Some_Block : declare
- ...
+@geindex Alignment (in a block statement)
- begin
- ...
- end Some_Block;
-@end group
-@end smallexample
+@example
+Some_Block : declare
+ ...
+begin
+ ...
+end Some_Block;
+@end example
@end itemize
-@c -------------------------------------------------------------------------
-@node Subprograms, Packages, Statements, Top
-@section Subprograms
-@c -------------------------------------------------------------------------
-@cindex Subprograms
+@node Subprograms,Packages and Visibility Rules,Statements,Top
+@anchor{gnat-style subprograms}@anchor{11}
+@chapter Subprograms
-@subsection Subprogram Declarations
-@c -------------------------------------------------------------------------
-@itemize @bullet
-@item
+@menu
+* Subprogram Declarations::
+* Subprogram Bodies::
+
+@end menu
+
+@node Subprogram Declarations,Subprogram Bodies,,Subprograms
+@anchor{gnat-style subprogram-declarations}@anchor{12}
+@section Subprogram Declarations
+
+
+
+@itemize *
+
+@item
Do not write the @code{in} for parameters.
-@smallexample @c adanocomment
- function Length (S : String) return Integer;
-@end smallexample
+@example
+function Length (S : String) return Integer;
+@end example
-@item
+@item
When the declaration line for a procedure or a function is too long to fit
the entire declaration (including the keyword procedure or function) on a
single line, then fold it, putting a single parameter on a line, aligning
the colons, as in:
-@smallexample @c adanocomment
-@group
- procedure Set_Heading
- (Source : String;
- Count : Natural;
- Pad : Character := Space;
- Fill : Boolean := True);
-@end group
-@end smallexample
-
-@noindent
+@example
+procedure Set_Heading
+ (Source : String;
+ Count : Natural;
+ Pad : Character := Space;
+ Fill : Boolean := True);
+@end example
+
In the case of a function, if the entire spec does not fit on one line, then
the return may appear after the last parameter, as in:
-@smallexample @c adanocomment
-@group
- function Head
- (Source : String;
- Count : Natural;
- Pad : Character := Space) return String;
-@end group
-@end smallexample
+@example
+function Head
+ (Source : String;
+ Count : Natural;
+ Pad : Character := Space) return String;
+@end example
-@noindent
Or it may appear on its own as a separate line. This form is preferred when
putting the return on the same line as the last parameter would result in
an overlong line. The return type may optionally be aligned with the types
of the parameters (usually we do this aligning if it results only in a small
-number of extra spaces, and otherwise we don't attempt to align). So two
+number of extra spaces, and otherwise we don’t attempt to align). So two
alternative forms for the above spec are:
-@smallexample @c adanocomment
-@group
- function Head
- (Source : String;
- Count : Natural;
- Pad : Character := Space)
- return String;
-
- function Head
- (Source : String;
- Count : Natural;
- Pad : Character := Space)
- return String;
-@end group
-@end smallexample
-
+@example
+function Head
+ (Source : String;
+ Count : Natural;
+ Pad : Character := Space)
+ return String;
+
+function Head
+ (Source : String;
+ Count : Natural;
+ Pad : Character := Space)
+ return String;
+@end example
@end itemize
-@subsection Subprogram Bodies
-@c -------------------------------------------------------------------------
-@cindex Subprogram bodies
+@node Subprogram Bodies,,Subprogram Declarations,Subprograms
+@anchor{gnat-style subprogram-bodies}@anchor{13}
+@section Subprogram Bodies
+
+
-@itemize @bullet
-@item
+@itemize *
+
+@item
Function and procedure bodies should usually be sorted alphabetically. Do
not attempt to sort them in some logical order by functionality. For a
sequence of subprogram specs, a general alphabetical sorting is also
usually appropriate, but occasionally it makes sense to group by major
function, with appropriate headers.
-@item
+@item
All subprograms have a header giving the function name, with the following
format:
-@smallexample @c adanocomment
-@group
- -----------------
- -- My_Function --
- -----------------
+@example
+-----------------
+-- My_Function --
+-----------------
- procedure My_Function is
- begin
- ...
- end My_Function;
-@end group
-@end smallexample
+procedure My_Function is
+begin
+ ...
+end My_Function;
+@end example
-@noindent
Note that the name in the header is preceded by a single space,
not two spaces as for other comments. These headers are used on
nested subprograms as well as outer level subprograms. They may
also be used as headers for sections of comments, or collections
of declarations that are related.
-@item
-Every subprogram body must have a preceding @syntax{subprogram_declaration},
+@item
+Every subprogram body must have a preceding subprogram_declaration,
which includes proper client documentation so that you do not need to
read the subprogram body in order to understand what the subprogram does and
how to call it. All subprograms should be documented, without exceptions.
-@item
-@cindex Blank lines (in subprogram bodies)
+@geindex Blank lines (in subprogram bodies)
+
+@item
A sequence of declarations may optionally be separated from the following
begin by a blank line. Just as we optionally allow blank lines in general
between declarations, this blank line should be present only if it improves
small (one or two lines) and the body has no blank lines, and we include it
if the declarative part is long or if the body has blank lines.
-@item
+@item
If the declarations in a subprogram contain at least one nested
subprogram body, then just before the @code{begin} of the enclosing
subprogram, there is a comment line and a blank line:
-@smallexample @c adanocomment
-@group
- -- Start of processing for @var{Enclosing_Subprogram}
+@example
+-- Start of processing for Enclosing_Subprogram
- begin
- ...
- end @var{Enclosing_Subprogram};
-@end group
-@end smallexample
+begin
+ ...
+end Enclosing_Subprogram;
+@end example
-@item
+@item
When nested subprograms are present, variables that are referenced by any
nested subprogram should precede the nested subprogram specs. For variables
that are not referenced by nested procedures, the declarations can either also
generally used). Or then can come just before the begin, with a header. The
following example shows the two possible styles:
-@smallexample @c adanocomment
-@group
- procedure Style1 is
- Var_Referenced_In_Nested : Integer;
- Var_Referenced_Only_In_Style1 : Integer;
-
- proc Nested;
- -- Comments ...
-
+@example
+procedure Style1 is
+ Var_Referenced_In_Nested : Integer;
+ Var_Referenced_Only_In_Style1 : Integer;
- ------------
- -- Nested --
- ------------
+ proc Nested;
+ -- Comments ...
- procedure Nested is
- begin
- ...
- end Nested;
+ ------------
+ -- Nested --
+ ------------
- -- Start of processing for Style1
-
- begin
- ...
- end Style1;
+ procedure Nested is
+ begin
+ ...
+ end Nested;
-@end group
+-- Start of processing for Style1
-@group
- procedure Style2 is
- Var_Referenced_In_Nested : Integer;
+begin
+ ...
+end Style1;
- proc Nested;
- -- Comments ...
+procedure Style2 is
+ Var_Referenced_In_Nested : Integer;
- ------------
- -- Nested --
- ------------
+ proc Nested;
+ -- Comments ...
- procedure Nested is
- begin
- ...
- end Nested;
+ ------------
+ -- Nested --
+ ------------
- -- Local variables
+ procedure Nested is
+ begin
+ ...
+ end Nested;
- Var_Referenced_Only_In_Style2 : Integer;
+ -- Local variables
- -- Start of processing for Style2
+ Var_Referenced_Only_In_Style2 : Integer;
- begin
- ...
- end Style2;
+-- Start of processing for Style2
-@end group
-@end smallexample
+begin
+ ...
+end Style2;
+@end example
-@noindent
For new code, we generally prefer Style2, but we do not insist on
modifying all legacy occurrences of Style1, which is still much
more common in the sources.
-
@end itemize
+@node Packages and Visibility Rules,Program Structure and Compilation Issues,Subprograms,Top
+@anchor{gnat-style packages-and-visibility-rules}@anchor{14}
+@chapter Packages and Visibility Rules
+
-@c -------------------------------------------------------------------------
-@node Packages, Program Structure, Subprograms, Top
-@section Packages and Visibility Rules
-@c -------------------------------------------------------------------------
-@cindex Packages
-@itemize @bullet
-@item
+@itemize *
+
+@item
All program units and subprograms have their name at the end:
-@smallexample @c adanocomment
-@group
- package P is
- ...
- end P;
-@end group
-@end smallexample
+@example
+package P is
+ ...
+end P;
+@end example
-@item
-We will use the style of @code{use}-ing @code{with}-ed packages, with
+@item
+We will use the style of @code{use} -ing @code{with} -ed packages, with
the context clauses looking like:
-@cindex @code{use} clauses
-@smallexample @c adanocomment
-@group
- with A; use A;
- with B; use B;
-@end group
-@end smallexample
+@geindex use clauses
+
+@example
+with A; use A;
+with B; use B;
+@end example
-@item
+@item
Names declared in the visible part of packages should be
-unique, to prevent name clashes when the packages are @code{use}d.
-@cindex Name clash avoidance
-
-@smallexample @c adanocomment
-@group
- package Entity is
- type Entity_Kind is ...;
- ...
- end Entity;
-@end group
-@end smallexample
-
-@item
+unique, to prevent name clashes when the packages are @code{use} d.
+
+@geindex Name clash avoidance
+
+@example
+package Entity is
+ type Entity_Kind is ...;
+ ...
+end Entity;
+@end example
+
+@item
After the file header comment, the context clause and unit specification
-should be the first thing in a @syntax{program_unit}.
+should be the first thing in a program_unit.
-@item
+@item
Preelaborate, Pure and Elaborate_Body pragmas should be added right after the
package name, indented an extra level and using the parameterless form:
-@smallexample @c adanocomment
-@group
- package Preelaborate_Package is
- pragma Preelaborate;
- ...
- end Preelaborate_Package;
-@end group
-@end smallexample
-
+@example
+package Preelaborate_Package is
+ pragma Preelaborate;
+ ...
+end Preelaborate_Package;
+@end example
@end itemize
-@c -------------------------------------------------------------------------
-@node Program Structure, GNU Free Documentation License, Packages, Top
-@section Program Structure and Compilation Issues
-@c -------------------------------------------------------------------------
-@cindex Program structure
+@node Program Structure and Compilation Issues,Index,Packages and Visibility Rules,Top
+@anchor{gnat-style program-structure-and-compilation-issues}@anchor{15}
+@chapter Program Structure and Compilation Issues
-@itemize @bullet
-@item
-Every GNAT source file must be compiled with the @option{-gnatg}
+
+
+@itemize *
+
+@item
+Every GNAT source file must be compiled with the @code{-gnatg}
switch to check the coding style.
(Note that you should look at
-@file{style.adb} to see the lexical rules enforced by
-@option{-gnatg}).
-@cindex @option{-gnatg} option (to gcc)
-@cindex @file{style.adb} file
+style.adb to see the lexical rules enforced by @code{-gnatg} ).
+
+@geindex -gnatg option (to gcc)
+
+@geindex style.adb file
-@item
+@item
Each source file should contain only one compilation unit.
-@item
+@item
Filenames should be 8 or fewer characters, followed by the @code{.adb}
extension for a body or @code{.ads} for a spec.
-@cindex File name length
-@item
-Unit names should be distinct when ``krunch''ed to 8 characters
-(see @file{krunch.ads}) and the filenames should match the unit name,
+@geindex File name length
+
+@item
+Unit names should be distinct when ‘krunch’ed to 8 characters
+(see krunch.ads) and the filenames should match the unit name,
except that they are all lower case.
-@cindex @file{krunch.ads} file
+
+@geindex krunch.ads file
@end itemize
+@menu
+* GNU Free Documentation License::
+
+@end menu
-@c **********************************
-@c * GNU Free Documentation License *
-@c **********************************
-@node GNU Free Documentation License,Index, Program Structure, Top
-@unnumberedsec GNU Free Documentation License
-@set nodefaultgnufreedocumentationlicensenode
-@include fdl.texi
-@c GNU Free Documentation License
-@cindex GNU Free Documentation License
+@node GNU Free Documentation License,,,Program Structure and Compilation Issues
+@anchor{share/gnu_free_documentation_license doc}@anchor{16}@anchor{share/gnu_free_documentation_license gnu-fdl}@anchor{17}@anchor{share/gnu_free_documentation_license gnu-free-documentation-license}@anchor{18}
+@section GNU Free Documentation License
+
+
+Version 1.3, 3 November 2008
+
+Copyright 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc
+@indicateurl{http://fsf.org/}
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+@strong{Preamble}
+
+The purpose of this License is to make a manual, textbook, or other
+functional and useful document “free” in the sense of freedom: to
+assure everyone the effective freedom to copy and redistribute it,
+with or without modifying it, either commercially or noncommercially.
+Secondarily, this License preserves for the author and publisher a way
+to get credit for their work, while not being considered responsible
+for modifications made by others.
+
+This License is a kind of “copyleft”, which means that derivative
+works of the document must themselves be free in the same sense. It
+complements the GNU General Public License, which is a copyleft
+license designed for free software.
+
+We have designed this License in order to use it for manuals for free
+software, because free software needs free documentation: a free
+program should come with manuals providing the same freedoms that the
+software does. But this License is not limited to software manuals;
+it can be used for any textual work, regardless of subject matter or
+whether it is published as a printed book. We recommend this License
+principally for works whose purpose is instruction or reference.
+
+@strong{1. APPLICABILITY AND DEFINITIONS}
+
+This License applies to any manual or other work, in any medium, that
+contains a notice placed by the copyright holder saying it can be
+distributed under the terms of this License. Such a notice grants a
+world-wide, royalty-free license, unlimited in duration, to use that
+work under the conditions stated herein. The @strong{Document}, below,
+refers to any such manual or work. Any member of the public is a
+licensee, and is addressed as “@strong{you}”. You accept the license if you
+copy, modify or distribute the work in a way requiring permission
+under copyright law.
+
+A “@strong{Modified Version}” of the Document means any work containing the
+Document or a portion of it, either copied verbatim, or with
+modifications and/or translated into another language.
+
+A “@strong{Secondary Section}” is a named appendix or a front-matter section of
+the Document that deals exclusively with the relationship of the
+publishers or authors of the Document to the Document’s overall subject
+(or to related matters) and contains nothing that could fall directly
+within that overall subject. (Thus, if the Document is in part a
+textbook of mathematics, a Secondary Section may not explain any
+mathematics.) The relationship could be a matter of historical
+connection with the subject or with related matters, or of legal,
+commercial, philosophical, ethical or political position regarding
+them.
+
+The “@strong{Invariant Sections}” are certain Secondary Sections whose titles
+are designated, as being those of Invariant Sections, in the notice
+that says that the Document is released under this License. If a
+section does not fit the above definition of Secondary then it is not
+allowed to be designated as Invariant. The Document may contain zero
+Invariant Sections. If the Document does not identify any Invariant
+Sections then there are none.
+
+The “@strong{Cover Texts}” are certain short passages of text that are listed,
+as Front-Cover Texts or Back-Cover Texts, in the notice that says that
+the Document is released under this License. A Front-Cover Text may
+be at most 5 words, and a Back-Cover Text may be at most 25 words.
+
+A “@strong{Transparent}” copy of the Document means a machine-readable copy,
+represented in a format whose specification is available to the
+general public, that is suitable for revising the document
+straightforwardly with generic text editors or (for images composed of
+pixels) generic paint programs or (for drawings) some widely available
+drawing editor, and that is suitable for input to text formatters or
+for automatic translation to a variety of formats suitable for input
+to text formatters. A copy made in an otherwise Transparent file
+format whose markup, or absence of markup, has been arranged to thwart
+or discourage subsequent modification by readers is not Transparent.
+An image format is not Transparent if used for any substantial amount
+of text. A copy that is not “Transparent” is called @strong{Opaque}.
+
+Examples of suitable formats for Transparent copies include plain
+ASCII without markup, Texinfo input format, LaTeX input format, SGML
+or XML using a publicly available DTD, and standard-conforming simple
+HTML, PostScript or PDF designed for human modification. Examples of
+transparent image formats include PNG, XCF and JPG. Opaque formats
+include proprietary formats that can be read and edited only by
+proprietary word processors, SGML or XML for which the DTD and/or
+processing tools are not generally available, and the
+machine-generated HTML, PostScript or PDF produced by some word
+processors for output purposes only.
+
+The “@strong{Title Page}” means, for a printed book, the title page itself,
+plus such following pages as are needed to hold, legibly, the material
+this License requires to appear in the title page. For works in
+formats which do not have any title page as such, “Title Page” means
+the text near the most prominent appearance of the work’s title,
+preceding the beginning of the body of the text.
+
+The “@strong{publisher}” means any person or entity that distributes
+copies of the Document to the public.
+
+A section “@strong{Entitled XYZ}” means a named subunit of the Document whose
+title either is precisely XYZ or contains XYZ in parentheses following
+text that translates XYZ in another language. (Here XYZ stands for a
+specific section name mentioned below, such as “@strong{Acknowledgements}”,
+“@strong{Dedications}”, “@strong{Endorsements}”, or “@strong{History}”.)
+To “@strong{Preserve the Title}”
+of such a section when you modify the Document means that it remains a
+section “Entitled XYZ” according to this definition.
+
+The Document may include Warranty Disclaimers next to the notice which
+states that this License applies to the Document. These Warranty
+Disclaimers are considered to be included by reference in this
+License, but only as regards disclaiming warranties: any other
+implication that these Warranty Disclaimers may have is void and has
+no effect on the meaning of this License.
+
+@strong{2. VERBATIM COPYING}
+
+You may copy and distribute the Document in any medium, either
+commercially or noncommercially, provided that this License, the
+copyright notices, and the license notice saying this License applies
+to the Document are reproduced in all copies, and that you add no other
+conditions whatsoever to those of this License. You may not use
+technical measures to obstruct or control the reading or further
+copying of the copies you make or distribute. However, you may accept
+compensation in exchange for copies. If you distribute a large enough
+number of copies you must also follow the conditions in section 3.
+
+You may also lend copies, under the same conditions stated above, and
+you may publicly display copies.
+
+@strong{3. COPYING IN QUANTITY}
+
+If you publish printed copies (or copies in media that commonly have
+printed covers) of the Document, numbering more than 100, and the
+Document’s license notice requires Cover Texts, you must enclose the
+copies in covers that carry, clearly and legibly, all these Cover
+Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on
+the back cover. Both covers must also clearly and legibly identify
+you as the publisher of these copies. The front cover must present
+the full title with all words of the title equally prominent and
+visible. You may add other material on the covers in addition.
+Copying with changes limited to the covers, as long as they preserve
+the title of the Document and satisfy these conditions, can be treated
+as verbatim copying in other respects.
+
+If the required texts for either cover are too voluminous to fit
+legibly, you should put the first ones listed (as many as fit
+reasonably) on the actual cover, and continue the rest onto adjacent
+pages.
+
+If you publish or distribute Opaque copies of the Document numbering
+more than 100, you must either include a machine-readable Transparent
+copy along with each Opaque copy, or state in or with each Opaque copy
+a computer-network location from which the general network-using
+public has access to download using public-standard network protocols
+a complete Transparent copy of the Document, free of added material.
+If you use the latter option, you must take reasonably prudent steps,
+when you begin distribution of Opaque copies in quantity, to ensure
+that this Transparent copy will remain thus accessible at the stated
+location until at least one year after the last time you distribute an
+Opaque copy (directly or through your agents or retailers) of that
+edition to the public.
+
+It is requested, but not required, that you contact the authors of the
+Document well before redistributing any large number of copies, to give
+them a chance to provide you with an updated version of the Document.
+
+@strong{4. MODIFICATIONS}
+
+You may copy and distribute a Modified Version of the Document under
+the conditions of sections 2 and 3 above, provided that you release
+the Modified Version under precisely this License, with the Modified
+Version filling the role of the Document, thus licensing distribution
+and modification of the Modified Version to whoever possesses a copy
+of it. In addition, you must do these things in the Modified Version:
+
+
+@enumerate A
+
+@item
+Use in the Title Page (and on the covers, if any) a title distinct
+from that of the Document, and from those of previous versions
+(which should, if there were any, be listed in the History section
+of the Document). You may use the same title as a previous version
+if the original publisher of that version gives permission.
+
+@item
+List on the Title Page, as authors, one or more persons or entities
+responsible for authorship of the modifications in the Modified
+Version, together with at least five of the principal authors of the
+Document (all of its principal authors, if it has fewer than five),
+unless they release you from this requirement.
+
+@item
+State on the Title page the name of the publisher of the
+Modified Version, as the publisher.
+
+@item
+Preserve all the copyright notices of the Document.
+
+@item
+Add an appropriate copyright notice for your modifications
+adjacent to the other copyright notices.
+
+@item
+Include, immediately after the copyright notices, a license notice
+giving the public permission to use the Modified Version under the
+terms of this License, in the form shown in the Addendum below.
+
+@item
+Preserve in that license notice the full lists of Invariant Sections
+and required Cover Texts given in the Document’s license notice.
+
+@item
+Include an unaltered copy of this License.
+
+@item
+Preserve the section Entitled “History”, Preserve its Title, and add
+to it an item stating at least the title, year, new authors, and
+publisher of the Modified Version as given on the Title Page. If
+there is no section Entitled “History” in the Document, create one
+stating the title, year, authors, and publisher of the Document as
+given on its Title Page, then add an item describing the Modified
+Version as stated in the previous sentence.
+
+@item
+Preserve the network location, if any, given in the Document for
+public access to a Transparent copy of the Document, and likewise
+the network locations given in the Document for previous versions
+it was based on. These may be placed in the “History” section.
+You may omit a network location for a work that was published at
+least four years before the Document itself, or if the original
+publisher of the version it refers to gives permission.
+
+@item
+For any section Entitled “Acknowledgements” or “Dedications”,
+Preserve the Title of the section, and preserve in the section all
+the substance and tone of each of the contributor acknowledgements
+and/or dedications given therein.
+
+@item
+Preserve all the Invariant Sections of the Document,
+unaltered in their text and in their titles. Section numbers
+or the equivalent are not considered part of the section titles.
+
+@item
+Delete any section Entitled “Endorsements”. Such a section
+may not be included in the Modified Version.
+
+@item
+Do not retitle any existing section to be Entitled “Endorsements”
+or to conflict in title with any Invariant Section.
+
+@item
+Preserve any Warranty Disclaimers.
+@end enumerate
+
+If the Modified Version includes new front-matter sections or
+appendices that qualify as Secondary Sections and contain no material
+copied from the Document, you may at your option designate some or all
+of these sections as invariant. To do this, add their titles to the
+list of Invariant Sections in the Modified Version’s license notice.
+These titles must be distinct from any other section titles.
+
+You may add a section Entitled “Endorsements”, provided it contains
+nothing but endorsements of your Modified Version by various
+parties—for example, statements of peer review or that the text has
+been approved by an organization as the authoritative definition of a
+standard.
+
+You may add a passage of up to five words as a Front-Cover Text, and a
+passage of up to 25 words as a Back-Cover Text, to the end of the list
+of Cover Texts in the Modified Version. Only one passage of
+Front-Cover Text and one of Back-Cover Text may be added by (or
+through arrangements made by) any one entity. If the Document already
+includes a cover text for the same cover, previously added by you or
+by arrangement made by the same entity you are acting on behalf of,
+you may not add another; but you may replace the old one, on explicit
+permission from the previous publisher that added the old one.
+
+The author(s) and publisher(s) of the Document do not by this License
+give permission to use their names for publicity for or to assert or
+imply endorsement of any Modified Version.
+
+@strong{5. COMBINING DOCUMENTS}
+
+You may combine the Document with other documents released under this
+License, under the terms defined in section 4 above for modified
+versions, provided that you include in the combination all of the
+Invariant Sections of all of the original documents, unmodified, and
+list them all as Invariant Sections of your combined work in its
+license notice, and that you preserve all their Warranty Disclaimers.
+
+The combined work need only contain one copy of this License, and
+multiple identical Invariant Sections may be replaced with a single
+copy. If there are multiple Invariant Sections with the same name but
+different contents, make the title of each such section unique by
+adding at the end of it, in parentheses, the name of the original
+author or publisher of that section if known, or else a unique number.
+Make the same adjustment to the section titles in the list of
+Invariant Sections in the license notice of the combined work.
+
+In the combination, you must combine any sections Entitled “History”
+in the various original documents, forming one section Entitled
+“History”; likewise combine any sections Entitled “Acknowledgements”,
+and any sections Entitled “Dedications”. You must delete all sections
+Entitled “Endorsements”.
+
+@strong{6. COLLECTIONS OF DOCUMENTS}
+
+You may make a collection consisting of the Document and other documents
+released under this License, and replace the individual copies of this
+License in the various documents with a single copy that is included in
+the collection, provided that you follow the rules of this License for
+verbatim copying of each of the documents in all other respects.
+
+You may extract a single document from such a collection, and distribute
+it individually under this License, provided you insert a copy of this
+License into the extracted document, and follow this License in all
+other respects regarding verbatim copying of that document.
+
+@strong{7. AGGREGATION WITH INDEPENDENT WORKS}
+
+A compilation of the Document or its derivatives with other separate
+and independent documents or works, in or on a volume of a storage or
+distribution medium, is called an “aggregate” if the copyright
+resulting from the compilation is not used to limit the legal rights
+of the compilation’s users beyond what the individual works permit.
+When the Document is included in an aggregate, this License does not
+apply to the other works in the aggregate which are not themselves
+derivative works of the Document.
+
+If the Cover Text requirement of section 3 is applicable to these
+copies of the Document, then if the Document is less than one half of
+the entire aggregate, the Document’s Cover Texts may be placed on
+covers that bracket the Document within the aggregate, or the
+electronic equivalent of covers if the Document is in electronic form.
+Otherwise they must appear on printed covers that bracket the whole
+aggregate.
+
+@strong{8. TRANSLATION}
+
+Translation is considered a kind of modification, so you may
+distribute translations of the Document under the terms of section 4.
+Replacing Invariant Sections with translations requires special
+permission from their copyright holders, but you may include
+translations of some or all Invariant Sections in addition to the
+original versions of these Invariant Sections. You may include a
+translation of this License, and all the license notices in the
+Document, and any Warranty Disclaimers, provided that you also include
+the original English version of this License and the original versions
+of those notices and disclaimers. In case of a disagreement between
+the translation and the original version of this License or a notice
+or disclaimer, the original version will prevail.
+
+If a section in the Document is Entitled “Acknowledgements”,
+“Dedications”, or “History”, the requirement (section 4) to Preserve
+its Title (section 1) will typically require changing the actual
+title.
+
+@strong{9. TERMINATION}
+
+You may not copy, modify, sublicense, or distribute the Document
+except as expressly provided under this License. Any attempt
+otherwise to copy, modify, sublicense, or distribute it is void, and
+will automatically terminate your rights under this License.
+
+However, if you cease all violation of this License, then your license
+from a particular copyright holder is reinstated (a) provisionally,
+unless and until the copyright holder explicitly and finally
+terminates your license, and (b) permanently, if the copyright holder
+fails to notify you of the violation by some reasonable means prior to
+60 days after the cessation.
+
+Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License. If your rights have been terminated and not permanently
+reinstated, receipt of a copy of some or all of the same material does
+not give you any rights to use it.
+
+@strong{10. FUTURE REVISIONS OF THIS LICENSE}
+
+The Free Software Foundation may publish new, revised versions
+of the GNU Free Documentation License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns. See
+@indicateurl{http://www.gnu.org/copyleft/}.
+
+Each version of the License is given a distinguishing version number.
+If the Document specifies that a particular numbered version of this
+License “or any later version” applies to it, you have the option of
+following the terms and conditions either of that specified version or
+of any later version that has been published (not as a draft) by the
+Free Software Foundation. If the Document does not specify a version
+number of this License, you may choose any version ever published (not
+as a draft) by the Free Software Foundation. If the Document
+specifies that a proxy can decide which future versions of this
+License can be used, that proxy’s public statement of acceptance of a
+version permanently authorizes you to choose that version for the
+Document.
+
+@strong{11. RELICENSING}
+
+“Massive Multiauthor Collaboration Site” (or “MMC Site”) means any
+World Wide Web server that publishes copyrightable works and also
+provides prominent facilities for anybody to edit those works. A
+public wiki that anybody can edit is an example of such a server. A
+“Massive Multiauthor Collaboration” (or “MMC”) contained in the
+site means any set of copyrightable works thus published on the MMC
+site.
+
+“CC-BY-SA” means the Creative Commons Attribution-Share Alike 3.0
+license published by Creative Commons Corporation, a not-for-profit
+corporation with a principal place of business in San Francisco,
+California, as well as future copyleft versions of that license
+published by that same organization.
+
+“Incorporate” means to publish or republish a Document, in whole or
+in part, as part of another Document.
+
+An MMC is “eligible for relicensing” if it is licensed under this
+License, and if all works that were first published under this License
+somewhere other than this MMC, and subsequently incorporated in whole
+or in part into the MMC, (1) had no cover texts or invariant sections,
+and (2) were thus incorporated prior to November 1, 2008.
+
+The operator of an MMC Site may republish an MMC contained in the site
+under CC-BY-SA on the same site at any time before August 1, 2009,
+provided the MMC is eligible for relicensing.
+
+@strong{ADDENDUM: How to use this License for your documents}
+
+To use this License in a document you have written, include a copy of
+the License in the document and put the following copyright and
+license notices just after the title page:
+
+@quotation
+
+Copyright © YEAR YOUR NAME.
+Permission is granted to copy, distribute and/or modify this document
+under the terms of the GNU Free Documentation License, Version 1.3
+or any later version published by the Free Software Foundation;
+with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
+A copy of the license is included in the section entitled “GNU
+Free Documentation License”.
+@end quotation
-@node Index,,GNU Free Documentation License, Top
-@unnumberedsec Index
+If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts,
+replace the “with … Texts.” line with this:
-@printindex cp
+@quotation
+
+with the Invariant Sections being LIST THEIR TITLES, with the
+Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST.
+@end quotation
+
+If you have Invariant Sections without Cover Texts, or some other
+combination of the three, merge those two alternatives to suit the
+situation.
+
+If your document contains nontrivial examples of program code, we
+recommend releasing these examples in parallel under your choice of
+free software license, such as the GNU General Public License,
+to permit their use in free software.
+
+@node Index,,Program Structure and Compilation Issues,Top
+@unnumbered Index
+
+
+@printindex ge
-@contents
+@c %**end of body
@bye
@setfilename gnat_rm.info
@documentencoding UTF-8
@ifinfo
-@*Generated by Sphinx 1.4.6.@*
+@*Generated by Sphinx 4.0.2.@*
@end ifinfo
@settitle GNAT Reference Manual
@defindex ge
@copying
@quotation
-GNAT Reference Manual , Apr 12, 2021
+GNAT Reference Manual , Jun 23, 2021
AdaCore
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.3 or
any later version published by the Free Software Foundation; with no
-Invariant Sections, with the Front-Cover Texts being "GNAT Reference
-Manual", and with no Back-Cover Texts. A copy of the license is
+Invariant Sections, with the Front-Cover Texts being “GNAT Reference
+Manual”, and with no Back-Cover Texts. A copy of the license is
included in the section entitled @ref{1,,GNU Free Documentation License}.
@menu
* Aspect Initializes::
* Aspect Inline_Always::
* Aspect Invariant::
-* Aspect Invariant'Class::
+* Aspect Invariant’Class::
* Aspect Iterable::
* Aspect Linker_Section::
* Aspect Lock_Free::
* RM 3.5.5(8); Enumeration Values: RM 3 5 5 8 Enumeration Values.
* RM 3.5.7(17); Float Types: RM 3 5 7 17 Float Types.
* RM 3.6.2(11); Multidimensional Arrays: RM 3 6 2 11 Multidimensional Arrays.
-* RM 9.6(30-31); Duration'Small: RM 9 6 30-31 Duration'Small.
+* RM 9.6(30-31); Duration’Small: RM 9 6 30-31 Duration’Small.
* RM 10.2.1(12); Consistent Representation: RM 10 2 1 12 Consistent Representation.
* RM 11.4.1(19); Exception Information: RM 11 4 1 19 Exception Information.
* RM 11.5(28); Suppression of Checks: RM 11 5 28 Suppression of Checks.
@end menu
@node About This Guide,Implementation Defined Pragmas,Top,Top
-@anchor{gnat_rm/about_this_guide about-this-guide}@anchor{2}@anchor{gnat_rm/about_this_guide doc}@anchor{3}@anchor{gnat_rm/about_this_guide gnat-reference-manual}@anchor{4}@anchor{gnat_rm/about_this_guide id1}@anchor{5}
+@anchor{gnat_rm/about_this_guide doc}@anchor{2}@anchor{gnat_rm/about_this_guide about-this-guide}@anchor{3}@anchor{gnat_rm/about_this_guide gnat-reference-manual}@anchor{4}@anchor{gnat_rm/about_this_guide id1}@anchor{5}
@chapter About This Guide
By default, GNAT assumes Ada 2012,
but you can override with a compiler switch
to explicitly specify the language version.
-(Please refer to the @emph{GNAT User's Guide} for details on these switches.)
-Throughout this manual, references to 'Ada' without a year suffix
+(Please refer to the @emph{GNAT User’s Guide} for details on these switches.)
+Throughout this manual, references to ‘Ada’ without a year suffix
apply to all the Ada versions of the language.
Ada is designed to be highly portable.
@item
@ref{e,,Standard Library Routines}, provides a listing of packages and a
-brief description of the functionality that is provided by Ada's
+brief description of the functionality that is provided by Ada’s
extensive set of standard library routines as implemented by GNAT.
@item
@item
@ref{13,,Implementation of Specific Ada Features}, discusses issues related
-to GNAT's implementation of machine code insertions, tasking, and several
+to GNAT’s implementation of machine code insertions, tasking, and several
other features.
@item
@itemize *
@item
-@cite{GNAT User's Guide for Native Platforms},
+@cite{GNAT User’s Guide for Native Platforms},
which provides information on how to use the
GNAT development environment.
@end itemize
@node Implementation Defined Pragmas,Implementation Defined Aspects,About This Guide,Top
-@anchor{gnat_rm/implementation_defined_pragmas implementation-defined-pragmas}@anchor{7}@anchor{gnat_rm/implementation_defined_pragmas doc}@anchor{19}@anchor{gnat_rm/implementation_defined_pragmas id1}@anchor{1a}
+@anchor{gnat_rm/implementation_defined_pragmas doc}@anchor{19}@anchor{gnat_rm/implementation_defined_pragmas id1}@anchor{1a}@anchor{gnat_rm/implementation_defined_pragmas implementation-defined-pragmas}@anchor{7}
@chapter Implementation Defined Pragmas
@end example
@node Pragma Abstract_State,Pragma Ada_83,Pragma Abort_Defer,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-abstract-state}@anchor{1c}@anchor{gnat_rm/implementation_defined_pragmas id2}@anchor{1d}
+@anchor{gnat_rm/implementation_defined_pragmas id2}@anchor{1c}@anchor{gnat_rm/implementation_defined_pragmas pragma-abstract-state}@anchor{1d}
@section Pragma Abstract_State
in the two situations.
@node Pragma Annotate,Pragma Assert,Pragma Allow_Integer_Address,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-annotate}@anchor{26}@anchor{gnat_rm/implementation_defined_pragmas id3}@anchor{27}
+@anchor{gnat_rm/implementation_defined_pragmas id3}@anchor{26}@anchor{gnat_rm/implementation_defined_pragmas pragma-annotate}@anchor{27}
@section Pragma Annotate
names, e.g. @code{Pre} applies to the Pre aspect, and @code{Precondition}
applies to both the @code{Precondition} pragma
and the aspect @code{Precondition}. Note that the identifiers for
-pragmas Pre_Class and Post_Class are Pre'Class and Post'Class (not
+pragmas Pre_Class and Post_Class are Pre’Class and Post’Class (not
Pre_Class and Post_Class), since these pragmas are intended to be
identical to the corresponding aspects).
@code{IGNORE} except that it completely disables semantic
checking of the corresponding pragma or aspect. This is
useful when the pragma or aspect argument references subprograms
-in a with'ed package which is replaced by a dummy package
+in a with’ed package which is replaced by a dummy package
for the final build.
The implementation defined assertion kind @code{Assertions} applies to all
case, and it is recommended that these two options not be used together.
@node Pragma Async_Readers,Pragma Async_Writers,Pragma Assume_No_Invalid_Values,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-async-readers}@anchor{2d}@anchor{gnat_rm/implementation_defined_pragmas id4}@anchor{2e}
+@anchor{gnat_rm/implementation_defined_pragmas id4}@anchor{2d}@anchor{gnat_rm/implementation_defined_pragmas pragma-async-readers}@anchor{2e}
@section Pragma Async_Readers
of infinities in IEEE floating-point, and corresponds to the
efficient execution mode on most machines. GNAT will not raise
overflow exceptions on these machines; instead it will generate
-infinities and NaN's as defined in the IEEE standard.
+infinities and NaN’s as defined in the IEEE standard.
Generating infinities, although efficient, is not always desirable.
Often the preferable approach is to check for overflow, even at the
(perhaps considerable) expense of run-time performance.
-This can be accomplished by defining your own constrained floating-point subtypes -- i.e., by supplying explicit
-range constraints -- and indeed such a subtype
+This can be accomplished by defining your own constrained floating-point subtypes – i.e., by supplying explicit
+range constraints – and indeed such a subtype
can have the same base range as its base type. For example:
@example
pragma is not available.
@node Pragma Compile_Time_Error,Pragma Compile_Time_Warning,Pragma Common_Object,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-compile-time-error}@anchor{39}@anchor{gnat_rm/implementation_defined_pragmas compile-time-error}@anchor{3a}
+@anchor{gnat_rm/implementation_defined_pragmas compile-time-error}@anchor{39}@anchor{gnat_rm/implementation_defined_pragmas pragma-compile-time-error}@anchor{3a}
@section Pragma Compile_Time_Error
if the value of the expression is known to be True at compile time, not when
the value of the expression is not known at compile time.
Note that if this pragma is used in a package that
-is with'ed by a client, the client will get the warning even though it
-is issued by a with'ed package (normally warnings in with'ed units are
+is with’ed by a client, the client will get the warning even though it
+is issued by a with’ed package (normally warnings in with’ed units are
suppressed, but this is a special exception to that rule).
One typical use is within a generic where compile time known characteristics
In previous versions of the compiler, combining @emph{-gnatwe} with
Compile_Time_Warning resulted in a fatal error. Now the compiler always emits
-a warning. You can use @ref{3a,,Pragma Compile_Time_Error} to force the generation of
+a warning. You can use @ref{39,,Pragma Compile_Time_Error} to force the generation of
an error.
@node Pragma Compiler_Unit,Pragma Compiler_Unit_Warning,Pragma Compile_Time_Warning,Implementation Defined Pragmas
@strong{function} @code{Fname} @strong{return} T`
@item
-@strong{function} @code{Fname} @strong{return} T'Class
+@strong{function} @code{Fname} @strong{return} T’Class
@item
-@strong{function} @code{Fname} (...) @strong{return} T`
+@strong{function} @code{Fname} (…) @strong{return} T`
@item
-@strong{function} @code{Fname} (...) @strong{return} T'Class
+@strong{function} @code{Fname} (…) @strong{return} T’Class
@end itemize
where @code{T} is a limited record type imported from C++ with pragma
The first two forms import the default constructor, used when an object
of type @code{T} is created on the Ada side with no explicit constructor.
The latter two forms cover all the non-default constructors of the type.
-See the GNAT User's Guide for details.
+See the GNAT User’s Guide for details.
If no constructors are imported, it is impossible to create any objects
on the Ada side and the type is implicitly declared abstract.
See Ada 2012 Reference Manual for details.
@node Pragma Depends,Pragma Detect_Blocking,Pragma Default_Storage_Pool,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-depends}@anchor{53}@anchor{gnat_rm/implementation_defined_pragmas id9}@anchor{54}
+@anchor{gnat_rm/implementation_defined_pragmas id9}@anchor{53}@anchor{gnat_rm/implementation_defined_pragmas pragma-depends}@anchor{54}
@section Pragma Depends
This is a configuration pragma which specifies the elaboration model to be
used during compilation. For more information on the elaboration models of
-GNAT, consult the chapter on elaboration order handling in the @emph{GNAT User's
+GNAT, consult the chapter on elaboration order handling in the @emph{GNAT User’s
Guide}.
The pragma may appear in the following contexts:
Configuration pragmas file
@item
-Prior to the context clauses of a compilation unit's initial declaration
+Prior to the context clauses of a compilation unit’s initial declaration
@end itemize
Any other placement of the pragma will result in a warning and the effects of
and thus is considered part of the implementation.
To compile it you will have to use the @emph{-gnatg} switch
for compiling System units, as explained in the
-GNAT User's Guide.
+GNAT User’s Guide.
@node Pragma Extensions_Allowed,Pragma Extensions_Visible,Pragma Extend_System,Implementation Defined Pragmas
@anchor{gnat_rm/implementation_defined_pragmas pragma-extensions-allowed}@anchor{64}
The selector for a case statement may be of a composite type, subject to
some restrictions (described below). Aggregate syntax is used for choices
-of such a case statement; however, in cases where a "normal" aggregate would
+of such a case statement; however, in cases where a “normal” aggregate would
require a discrete value, a discrete subtype may be used instead; box
notation can also be used to match all values (but currently only
for discrete subcomponents).
If the set of values that match the choice(s) of an earlier alternative
overlaps the corresponding set of a later alternative, then the first
set shall be a proper subset of the second (and the later alternative
-will not be executed if the earlier alternative "matches"). All possible
+will not be executed if the earlier alternative “matches”). All possible
values of the composite type shall be covered. The composite type of the
selector shall be a nonlimited untagged undiscriminated record type, all
of whose subcomponent subtypes are either static discrete subtypes or
for binding a name to a component of a matching value for use within
an alternative of a case statement. For a component association
that occurs within a case choice, the expression may be followed by
-"is <identifier>". In the special case of a "box" component association,
+“is <identifier>”. In the special case of a “box” component association,
the identifier may instead be provided within the box. Either of these
indicates that the given identifer denotes (a constant view of) the matching
subcomponent of the case selector.
Unconstrained array types and subtypes can be specified with a lower bound
that is fixed to a certain value, by writing an index range that uses the
-syntax "<lower-bound-expression> .. <>". This guarantees that all objects
+syntax “<lower-bound-expression> .. <>”. This guarantees that all objects
of the type or subtype will have the specified lower bound.
For example, a matrix type with fixed lower bounds of zero for each
@end quotation
If a string slice is passed to a formal of subtype String_1 in a call to
-a subprogram S, the slice's bounds will "slide" so that the lower bound
+a subprogram S, the slice’s bounds will “slide” so that the lower bound
is 1. Within S, the lower bound of the formal is known to be 1, so, unlike
a normal unconstrained String formal, there is no need to worry about
accounting for other possible lower-bound values. Sliding of bounds also
Use of this feature increases safety by simplifying code, and can also
improve the efficiency of indexing operations, since the compiler statically
-knows the lower bound of unconstrained array formals when the formal's
+knows the lower bound of unconstrained array formals when the formal’s
subtype has index ranges with static fixed lower bounds.
@end itemize
@end itemize
@node Pragma Ghost,Pragma Global,Pragma Float_Representation,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-ghost}@anchor{6e}@anchor{gnat_rm/implementation_defined_pragmas id14}@anchor{6f}
+@anchor{gnat_rm/implementation_defined_pragmas id14}@anchor{6e}@anchor{gnat_rm/implementation_defined_pragmas pragma-ghost}@anchor{6f}
@section Pragma Ghost
2014 Reference Manual, section 6.9.
@node Pragma Global,Pragma Ident,Pragma Ghost,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-global}@anchor{70}@anchor{gnat_rm/implementation_defined_pragmas id15}@anchor{71}
+@anchor{gnat_rm/implementation_defined_pragmas id15}@anchor{70}@anchor{gnat_rm/implementation_defined_pragmas pragma-global}@anchor{71}
@section Pragma Global
another entry. Implementation kind By_Protected_Procedure transforms the
requeue into a dispatching call, thus eliminating the chance of blocking. Kind
By_Any shares the behavior of By_Entry and By_Protected_Procedure depending on
-the target's overriding subprogram kind.
+the target’s overriding subprogram kind.
@node Pragma Implicit_Packing,Pragma Import_Function,Pragma Implemented,Implementation Defined Pragmas
@anchor{gnat_rm/implementation_defined_pragmas pragma-implicit-packing}@anchor{76}
Initialization with a specific bit pattern.
@end itemize
-See the GNAT User's Guide for binder options for specifying these cases.
+See the GNAT User’s Guide for binder options for specifying these cases.
The bind-time approach is intended to provide fast turnaround for testing
with different values, without having to recompile the program.
@item
At execution time, the programmer can specify the invalid values using an
-environment variable. See the GNAT User's Guide for details.
+environment variable. See the GNAT User’s Guide for details.
The execution-time approach is intended to provide fast turnaround for
testing with different values, without having to recompile and rebind the
Note that pragma @code{Initialize_Scalars} is particularly useful in conjunction
with the enhanced validity checking that is now provided in GNAT, which checks
for invalid values under more conditions. Using this feature (see description
-of the @emph{-gnatV} flag in the GNAT User's Guide) in conjunction with pragma
+of the @emph{-gnatV} flag in the GNAT User’s Guide) in conjunction with pragma
@code{Initialize_Scalars} provides a powerful new tool to assist in the detection
of problems caused by uninitialized variables.
generated code. This may cause your code to be substantially larger. It may
also cause an increase in the amount of stack required, so it is probably a
good idea to turn on stack checking (see description of stack checking in the
-GNAT User's Guide) when using this pragma.
+GNAT User’s Guide) when using this pragma.
@node Pragma Initializes,Pragma Inline_Always,Pragma Initialize_Scalars,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-initializes}@anchor{80}@anchor{gnat_rm/implementation_defined_pragmas id17}@anchor{81}
+@anchor{gnat_rm/implementation_defined_pragmas id17}@anchor{80}@anchor{gnat_rm/implementation_defined_pragmas pragma-initializes}@anchor{81}
@section Pragma Initializes
declared in the spec of package @code{System.OS_Interface}.
Overriding the default state of signals used by the Ada runtime may interfere
-with an application's runtime behavior in the cases of the synchronous signals,
+with an application’s runtime behavior in the cases of the synchronous signals,
and in the case of the signal used to implement the @code{abort} statement.
@node Pragma Invariant,Pragma Keep_Names,Pragma Interrupt_State,Implementation Defined Pragmas
identifies the line on which the pragma appears is used.
It is permissible to have multiple Invariants for the same type entity, in
-which case they are and'ed together. It is permissible to use this pragma
+which case they are and’ed together. It is permissible to use this pragma
in Ada 2012 mode, but you cannot have both an invariant aspect and an
invariant pragma for the same entity.
A GNAT license header starts with a line containing 78 hyphens. The following
comment text is searched for the appearance of any of the following strings.
-If the string 'GNU General Public License' is found, then the unit is assumed
-to have GPL license, unless the string 'As a special exception' follows, in
+If the string ‘GNU General Public License’ is found, then the unit is assumed
+to have GPL license, unless the string ‘As a special exception’ follows, in
which case the license is assumed to be modified GPL.
If one of the strings
-'This specification is adapted from the Ada Semantic Interface' or
-'This specification is derived from the Ada Reference Manual' is found
+‘This specification is adapted from the Ada Semantic Interface’ or
+‘This specification is derived from the Ada Reference Manual’ is found
then the unit is assumed to be unrestricted.
These default actions means that a program with a restricted license pragma
linker section for the given entity. It is equivalent to
@code{__attribute__((section))} in GNU C and causes @code{LOCAL_NAME} to
be placed in the @code{static_string_EXPRESSION} section of the
-executable (assuming the linker doesn't rename the section).
+executable (assuming the linker doesn’t rename the section).
GNAT also provides an implementation defined aspect of the same name.
In the case of specifying this aspect for a type, the effect is to
of statements of a loop body, or nested inside block statements that
appear in the sequence of statements of a loop body.
The intention is that it be used to
-represent a "loop invariant" assertion, i.e. something that is true each
+represent a “loop invariant” assertion, i.e. something that is true each
time through the loop, and which can be used to show that the loop is
achieving its purpose.
declarations. This pragma is semantically equivalent to
@code{__attribute__((@emph{attribute_name}))} (if @code{info} is not
specified) or @code{__attribute__((@emph{attribute_name(info})))}
-or @code{__attribute__((@emph{attribute_name(info,...})))} in GNU C,
+or @code{__attribute__((@emph{attribute_name(info,…})))} in GNU C,
where @emph{attribute_name} is recognized by the compiler middle-end
or the @code{TARGET_ATTRIBUTE_TABLE} machine specific macro. Note
that a string literal for the optional parameter @code{info} or the
earlier versions of the package body.
@node Pragma No_Caching,Pragma No_Component_Reordering,Pragma No_Body,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-no-caching}@anchor{9e}@anchor{gnat_rm/implementation_defined_pragmas id23}@anchor{9f}
+@anchor{gnat_rm/implementation_defined_pragmas id23}@anchor{9e}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-caching}@anchor{9f}
@section Pragma No_Caching
same name) that establishes the restriction @code{No_Elaboration_Code} for
the current unit and any extended main source units (body and subunits).
It also has the effect of enforcing a transitive application of this
-aspect, so that if any unit is implicitly or explicitly with'ed by the
+aspect, so that if any unit is implicitly or explicitly with’ed by the
current unit, it must also have the No_Elaboration_Code_All aspect set.
It may be applied to package or subprogram specs or their generic versions.
declared in units to which the pragma applies. For a detailed
description of the strict aliasing optimization, and the situations
in which it must be suppressed, see the section on Optimization and Strict Aliasing
-in the @cite{GNAT User's Guide}.
+in the @cite{GNAT User’s Guide}.
This pragma currently has no effects on access to unconstrained array types.
@node Pragma No_Tagged_Streams,Pragma Normalize_Scalars,Pragma No_Strict_Aliasing,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-no-tagged-streams}@anchor{a8}@anchor{gnat_rm/implementation_defined_pragmas id26}@anchor{a9}
+@anchor{gnat_rm/implementation_defined_pragmas id26}@anchor{a8}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-tagged-streams}@anchor{a9}
@section Pragma No_Tagged_Streams
@item @emph{Standard.Character}
Objects whose root type is Standard.Character are initialized to
-Character'Last unless the subtype range excludes NUL (in which case
+Character’Last unless the subtype range excludes NUL (in which case
NUL is used). This choice will always generate an invalid value if
one exists.
@item @emph{Standard.Wide_Character}
Objects whose root type is Standard.Wide_Character are initialized to
-Wide_Character'Last unless the subtype range excludes NUL (in which case
+Wide_Character’Last unless the subtype range excludes NUL (in which case
NUL is used). This choice will always generate an invalid value if
one exists.
@end table
@node Pragma Obsolescent,Pragma Optimize_Alignment,Pragma Normalize_Scalars,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-obsolescent}@anchor{ab}@anchor{gnat_rm/implementation_defined_pragmas id27}@anchor{ac}
+@anchor{gnat_rm/implementation_defined_pragmas id27}@anchor{ab}@anchor{gnat_rm/implementation_defined_pragmas pragma-obsolescent}@anchor{ac}
@section Pragma Obsolescent
for the case of generic enumerated types.
For additional information please refer to the description of the
-@emph{-gnatw.u} switch in the GNAT User's Guide.
+@emph{-gnatw.u} switch in the GNAT User’s Guide.
@node Pragma Overflow_Mode,Pragma Overriding_Renamings,Pragma Ordered,Implementation Defined Pragmas
@anchor{gnat_rm/implementation_defined_pragmas pragma-overflow-mode}@anchor{af}
This pragma sets the current overflow mode to the given setting. For details
of the meaning of these modes, please refer to the
-'Overflow Check Handling in GNAT' appendix in the
-GNAT User's Guide. If only the @code{General} parameter is present,
+‘Overflow Check Handling in GNAT’ appendix in the
+GNAT User’s Guide. If only the @code{General} parameter is present,
the given mode applies to all expressions. If both parameters are present,
the @code{General} mode applies to expressions outside assertions, and
the @code{Eliminated} mode applies to expressions within assertions.
(since protected objects are available in place of passive tasks).
For more information on the subject of passive tasks, see the section
-'Passive Task Optimization' in the GNAT Users Guide.
+‘Passive Task Optimization’ in the GNAT Users Guide.
@node Pragma Persistent_BSS,Pragma Post,Pragma Passive,Implementation Defined Pragmas
@anchor{gnat_rm/implementation_defined_pragmas id29}@anchor{b5}@anchor{gnat_rm/implementation_defined_pragmas pragma-persistent-bss}@anchor{b6}
exception handlers).
In addition, the boolean expression which is the condition which
-must be true may contain references to function'Result in the case
+must be true may contain references to function’Result in the case
of a function to refer to the returned value.
@code{Postcondition} pragmas may appear either immediately following the
a message argument was supplied, then the given string
will be used as the exception message. If no message
argument was supplied, then the default message has
-the form "Postcondition failed at file_name:line". The
+the form “Postcondition failed at file_name:line”. The
exception is raised in the context of the subprogram
body, so it is possible to catch postcondition failures
within the subprogram body itself.
Renamed => Inline_Always);
@end example
-Then GNAT will treat "pragma Inline_Only ..." as if you had written
-"pragma Inline_Always ...".
+Then GNAT will treat “pragma Inline_Only …” as if you had written
+“pragma Inline_Always …”.
Pragma Inline_Only will not necessarily mean the same thing as the other Ada
-compiler; it's up to you to make sure the semantics are close enough.
+compiler; it’s up to you to make sure the semantics are close enough.
@node Pragma Pre,Pragma Precondition,Pragma Rename_Pragma,Implementation Defined Pragmas
@anchor{gnat_rm/implementation_defined_pragmas pragma-pre}@anchor{bb}
The @code{Precondition} pragma is similar to @code{Postcondition}
except that the corresponding checks take place immediately upon
entry to the subprogram, and if a precondition fails, the exception
-is raised in the context of the caller, and the attribute 'Result
+is raised in the context of the caller, and the attribute ‘Result
cannot be used within the precondition expression.
Otherwise, the placement and visibility rules are identical to those
compatibility purposes.
@node Pragma Predicate,Pragma Predicate_Failure,Pragma Precondition,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-predicate}@anchor{bd}@anchor{gnat_rm/implementation_defined_pragmas id30}@anchor{be}
+@anchor{gnat_rm/implementation_defined_pragmas id30}@anchor{bd}@anchor{gnat_rm/implementation_defined_pragmas pragma-predicate}@anchor{be}
@section Pragma Predicate
The motivation behind providing pragmas equivalent to
corresponding aspects is to allow a program to be written
using the pragmas, and then compiled with a compiler that
-will ignore the pragmas. That doesn't work in the case of
+will ignore the pragmas. That doesn’t work in the case of
static and dynamic predicates, since if the corresponding
pragmas are ignored, then the behavior of the program is
fundamentally changed (for example a membership test
@end itemize
This set of configuration pragmas and restrictions correspond to the
-definition of the 'Ravenscar Profile' for limited tasking, devised and
+definition of the ‘Ravenscar Profile’ for limited tasking, devised and
published by the @cite{International Real-Time Ada Workshop@comma{} 1997}.
A description is also available at
@indicateurl{http://www-users.cs.york.ac.uk/~burns/ravenscar.ps}.
Details on the rationale for @code{Jorvik} and implications for use may be
found in @cite{A New Ravenscar-Based Profile} by P. Rogers, J. Ruiz,
-T. Gingold and P. Bernardi, in @cite{Reliable Software Technologies -- Ada Europe 2017}, Springer-Verlag Lecture Notes in Computer Science,
+T. Gingold and P. Bernardi, in @cite{Reliable Software Technologies – Ada Europe 2017}, Springer-Verlag Lecture Notes in Computer Science,
Number 10300.
@item
five shift operators (Shift_Left, Shift_Right, Shift_Right_Arithmetic,
Rotate_Left and Rotate_Right) for the given type. It is similar to
including the function declarations for these five operators, together
-with the pragma Import (Intrinsic, ...) statements.
+with the pragma Import (Intrinsic, …) statements.
@node Pragma Psect_Object,Pragma Pure_Function,Pragma Provide_Shift_Operators,Implementation Defined Pragmas
@anchor{gnat_rm/implementation_defined_pragmas pragma-psect-object}@anchor{c8}
This pragma is identical in effect to pragma @code{Common_Object}.
@node Pragma Pure_Function,Pragma Rational,Pragma Psect_Object,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-pure-function}@anchor{c9}@anchor{gnat_rm/implementation_defined_pragmas id31}@anchor{ca}
+@anchor{gnat_rm/implementation_defined_pragmas id31}@anchor{c9}@anchor{gnat_rm/implementation_defined_pragmas pragma-pure-function}@anchor{ca}
@section Pragma Pure_Function
which is the preferred method of setting the @code{Ravenscar} profile.
@node Pragma Refined_Depends,Pragma Refined_Global,Pragma Ravenscar,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-depends}@anchor{cd}@anchor{gnat_rm/implementation_defined_pragmas id32}@anchor{ce}
+@anchor{gnat_rm/implementation_defined_pragmas id32}@anchor{cd}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-depends}@anchor{ce}
@section Pragma Refined_Depends
the SPARK 2014 Reference Manual, section 6.1.5.
@node Pragma Refined_Global,Pragma Refined_Post,Pragma Refined_Depends,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-global}@anchor{cf}@anchor{gnat_rm/implementation_defined_pragmas id33}@anchor{d0}
+@anchor{gnat_rm/implementation_defined_pragmas id33}@anchor{cf}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-global}@anchor{d0}
@section Pragma Refined_Global
the SPARK 2014 Reference Manual, section 6.1.4.
@node Pragma Refined_Post,Pragma Refined_State,Pragma Refined_Global,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-post}@anchor{d1}@anchor{gnat_rm/implementation_defined_pragmas id34}@anchor{d2}
+@anchor{gnat_rm/implementation_defined_pragmas id34}@anchor{d1}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-post}@anchor{d2}
@section Pragma Refined_Post
the SPARK 2014 Reference Manual, section 7.2.7.
@node Pragma Refined_State,Pragma Relative_Deadline,Pragma Refined_Post,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-state}@anchor{d3}@anchor{gnat_rm/implementation_defined_pragmas id35}@anchor{d4}
+@anchor{gnat_rm/implementation_defined_pragmas id35}@anchor{d3}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-state}@anchor{d4}
@section Pragma Refined_State
For most targets, the pragma does not apply as the secondary stack grows on
demand: allocated as a chain of blocks in the heap. The default size of these
blocks can be modified via the @code{-D} binder option as described in
-@cite{GNAT User's Guide}.
+@cite{GNAT User’s Guide}.
Note that no check is made to see if the secondary stack can fit inside the
primary stack.
is recognized but ignored by all current versions of GNAT.
@node Pragma Simple_Storage_Pool_Type,Pragma Source_File_Name,Pragma Short_Descriptors,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-simple-storage-pool-type}@anchor{e2}@anchor{gnat_rm/implementation_defined_pragmas id39}@anchor{e3}
+@anchor{gnat_rm/implementation_defined_pragmas id39}@anchor{e2}@anchor{gnat_rm/implementation_defined_pragmas pragma-simple-storage-pool-type}@anchor{e3}
@section Pragma Simple_Storage_Pool_Type
pragma Simple_Storage_Pool_Type (type_LOCAL_NAME);
@end example
-A type can be established as a 'simple storage pool type' by applying
+A type can be established as a ‘simple storage pool type’ by applying
the representation pragma @code{Simple_Storage_Pool_Type} to the type.
A type named in the pragma must be a library-level immutably limited record
type or limited tagged type declared immediately within a package declaration.
for further details.
@node Pragma Source_File_Name,Pragma Source_File_Name_Project,Pragma Simple_Storage_Pool_Type,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-source-file-name}@anchor{e5}@anchor{gnat_rm/implementation_defined_pragmas id40}@anchor{e6}
+@anchor{gnat_rm/implementation_defined_pragmas id40}@anchor{e5}@anchor{gnat_rm/implementation_defined_pragmas pragma-source-file-name}@anchor{e6}
@section Pragma Source_File_Name
For more details on the use of the @code{Source_File_Name} pragma, see the
sections on @cite{Using Other File Names} and @cite{Alternative File Naming Schemes}
-in the @cite{GNAT User's Guide}.
+in the @cite{GNAT User’s Guide}.
@node Pragma Source_File_Name_Project,Pragma Source_Reference,Pragma Source_File_Name,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-source-file-name-project}@anchor{e7}@anchor{gnat_rm/implementation_defined_pragmas id41}@anchor{e8}
+@anchor{gnat_rm/implementation_defined_pragmas id41}@anchor{e8}@anchor{gnat_rm/implementation_defined_pragmas pragma-source-file-name-project}@anchor{e7}
@section Pragma Source_File_Name_Project
This pragma has the same syntax and semantics as pragma Source_File_Name.
It is only allowed as a stand-alone configuration pragma.
-It cannot appear after a @ref{e5,,Pragma Source_File_Name}, and
+It cannot appear after a @ref{e6,,Pragma Source_File_Name}, and
most importantly, once pragma Source_File_Name_Project appears,
no further Source_File_Name pragmas are allowed.
is needed for error messages issued by all phases of the compiler.
@node Pragma SPARK_Mode,Pragma Static_Elaboration_Desired,Pragma Source_Reference,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-spark-mode}@anchor{ea}@anchor{gnat_rm/implementation_defined_pragmas id42}@anchor{eb}
+@anchor{gnat_rm/implementation_defined_pragmas id42}@anchor{ea}@anchor{gnat_rm/implementation_defined_pragmas pragma-spark-mode}@anchor{eb}
@section Pragma SPARK_Mode
that is active at the point it is declared. But this can be overridden
by pragma within the spec or body as above.
-The basic consistency rule is that you can't turn SPARK_Mode back
+The basic consistency rule is that you can’t turn SPARK_Mode back
@code{On}, once you have explicitly (with a pragma) turned if
@code{Off}. So the following rules apply:
then the representation of the item in the stream is in the same format that
would be used for @code{Standard.String'Output}, and this same representation
is expected when a value of this type is read from the stream. Note that the
-value written always includes the bounds, even for Unbounded_String'Write,
+value written always includes the bounds, even for Unbounded_String’Write,
since Unbounded_String is not an array type.
Note that the @code{Stream_Convert} pragma is not effective in the case of
The form @code{ALL_CHECKS} activates all standard checks (its use is equivalent
to the use of the @code{gnaty} switch with no options.
-See the @cite{GNAT User's Guide} for details.)
+See the @cite{GNAT User’s Guide} for details.)
Note: the behavior is slightly different in GNAT mode (@code{-gnatg} used).
In this case, @code{ALL_CHECKS} implies the standard set of GNAT mode style check
will generate checks if they are essentially free, even when they are
suppressed. In particular, if the compiler can prove that a certain
check will necessarily fail, it will generate code to do an
-unconditional 'raise', even if checks are suppressed. The compiler
+unconditional ‘raise’, even if checks are suppressed. The compiler
warns in this case.
Of course, run-time checks are omitted whenever the compiler can prove
as a normal configuration pragma is the preferred usage in GNAT.
@node Pragma Suppress_Debug_Info,Pragma Suppress_Exception_Locations,Pragma Suppress_All,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-debug-info}@anchor{f2}@anchor{gnat_rm/implementation_defined_pragmas id43}@anchor{f3}
+@anchor{gnat_rm/implementation_defined_pragmas id43}@anchor{f2}@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-debug-info}@anchor{f3}
@section Pragma Suppress_Debug_Info
type.
@node Pragma Test_Case,Pragma Thread_Local_Storage,Pragma Task_Storage,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-test-case}@anchor{f9}@anchor{gnat_rm/implementation_defined_pragmas id45}@anchor{fa}
+@anchor{gnat_rm/implementation_defined_pragmas id45}@anchor{f9}@anchor{gnat_rm/implementation_defined_pragmas pragma-test-case}@anchor{fa}
@section Pragma Test_Case
postcondition of the subprogram should be ignored for this test case.
@node Pragma Thread_Local_Storage,Pragma Time_Slice,Pragma Test_Case,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-thread-local-storage}@anchor{fb}@anchor{gnat_rm/implementation_defined_pragmas id46}@anchor{fc}
+@anchor{gnat_rm/implementation_defined_pragmas id46}@anchor{fb}@anchor{gnat_rm/implementation_defined_pragmas pragma-thread-local-storage}@anchor{fc}
@section Pragma Thread_Local_Storage
This pragma specifies that the specified entity, which must be
a variable declared in a library-level package, is to be marked as
-"Thread Local Storage" (@code{TLS}). On systems supporting this (which
+“Thread Local Storage” (@code{TLS}). On systems supporting this (which
include Windows, Solaris, GNU/Linux, and VxWorks 6), this causes each
thread (and hence each Ada task) to see a distinct copy of the variable.
specs of unimplemented packages in syntax or semantic checking mode.
@node Pragma Universal_Aliasing,Pragma Unmodified,Pragma Unimplemented_Unit,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-universal-aliasing}@anchor{105}@anchor{gnat_rm/implementation_defined_pragmas id48}@anchor{106}
+@anchor{gnat_rm/implementation_defined_pragmas id48}@anchor{105}@anchor{gnat_rm/implementation_defined_pragmas pragma-universal-aliasing}@anchor{106}
@section Pragma Universal_Aliasing
access types designating this type were subject to pragma No_Strict_Aliasing.
For a detailed description of the strict aliasing optimization, and the
situations in which it must be suppressed, see the section on
-@code{Optimization and Strict Aliasing} in the @cite{GNAT User's Guide}.
+@code{Optimization and Strict Aliasing} in the @cite{GNAT User’s Guide}.
@node Pragma Unmodified,Pragma Unreferenced,Pragma Universal_Aliasing,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-unmodified}@anchor{107}@anchor{gnat_rm/implementation_defined_pragmas id49}@anchor{108}
+@anchor{gnat_rm/implementation_defined_pragmas id49}@anchor{107}@anchor{gnat_rm/implementation_defined_pragmas pragma-unmodified}@anchor{108}
@section Pragma Unmodified
variables, though it is harmless to do so.
@node Pragma Unreferenced,Pragma Unreferenced_Objects,Pragma Unmodified,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-unreferenced}@anchor{109}@anchor{gnat_rm/implementation_defined_pragmas id50}@anchor{10a}
+@anchor{gnat_rm/implementation_defined_pragmas id50}@anchor{109}@anchor{gnat_rm/implementation_defined_pragmas pragma-unreferenced}@anchor{10a}
@section Pragma Unreferenced
regardless of whether they occur in the same unit as the subprogram
declaration, then this pragma should not be used (calls from another
unit would not be flagged); pragma Obsolescent can be used instead
-for this purpose, see @ref{ab,,Pragma Obsolescent}.
+for this purpose, see @ref{ac,,Pragma Obsolescent}.
The second form of pragma @code{Unreferenced} is used within a context
clause. In this case the arguments must be unit names of units previously
variables, though it is harmless to do so.
@node Pragma Unreferenced_Objects,Pragma Unreserve_All_Interrupts,Pragma Unreferenced,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-unreferenced-objects}@anchor{10b}@anchor{gnat_rm/implementation_defined_pragmas id51}@anchor{10c}
+@anchor{gnat_rm/implementation_defined_pragmas id51}@anchor{10b}@anchor{gnat_rm/implementation_defined_pragmas pragma-unreferenced-objects}@anchor{10c}
@section Pragma Unreferenced_Objects
@end example
This is a configuration pragma. In a unit to which it applies, any use
-of the 'Size attribute is automatically interpreted as a use of the
-'VADS_Size attribute. Note that this may result in incorrect semantic
+of the ‘Size attribute is automatically interpreted as a use of the
+‘VADS_Size attribute. Note that this may result in incorrect semantic
processing of valid Ada 95 or Ada 2005 programs. This is intended to aid in
the handling of existing code which depends on the interpretation of Size
as implemented in the VADS compiler. See description of the VADS_Size
attribute for further details.
@node Pragma Unused,Pragma Validity_Checks,Pragma Use_VADS_Size,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-unused}@anchor{110}@anchor{gnat_rm/implementation_defined_pragmas id52}@anchor{111}
+@anchor{gnat_rm/implementation_defined_pragmas id52}@anchor{110}@anchor{gnat_rm/implementation_defined_pragmas pragma-unused}@anchor{111}
@section Pragma Unused
reference manual settings, and then a string of letters in the string
specifies the exact set of options required. The form of this string
is exactly as described for the @emph{-gnatVx} compiler switch (see the
-GNAT User's Guide for details). For example the following two
+GNAT User’s Guide for details). For example the following two
methods can be used to enable validity checking for mode @code{in} and
@code{in out} subprogram parameters:
@end example
@node Pragma Volatile,Pragma Volatile_Full_Access,Pragma Validity_Checks,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-volatile}@anchor{113}@anchor{gnat_rm/implementation_defined_pragmas id53}@anchor{114}
+@anchor{gnat_rm/implementation_defined_pragmas id53}@anchor{113}@anchor{gnat_rm/implementation_defined_pragmas pragma-volatile}@anchor{114}
@section Pragma Volatile
which treats warnings as errors.
This pragma can apply to regular warnings (messages enabled by -gnatw)
-and to style warnings (messages that start with "(style)",
+and to style warnings (messages that start with “(style)”,
enabled by -gnaty).
The pattern may contain asterisks, which match zero or more characters
any way, it merely changes the effect of a matching warning if one
is produced as a result of other warnings options. As shown in this
example, if the pragma results in a warning being treated as an error,
-the tag is changed from "warning:" to "error:" and the string
-"[warning-as-error]" is appended to the end of the message.
+the tag is changed from “warning:” to “error:” and the string
+“[warning-as-error]” is appended to the end of the message.
@node Pragma Warnings,Pragma Weak_External,Pragma Warning_As_Error,Implementation Defined Pragmas
@anchor{gnat_rm/implementation_defined_pragmas id56}@anchor{11b}@anchor{gnat_rm/implementation_defined_pragmas pragma-warnings}@anchor{11a}
command with no arguments, which will generate usage information containing
the list of warnings switches supported. For
full details see the section on @code{Warning Message Control} in the
-@cite{GNAT User's Guide}.
+@cite{GNAT User’s Guide}.
This form can also be used as a configuration pragma.
The warnings controlled by the @code{-gnatw} switch are generated by the
The fourth form, with an @code{On|Off} parameter and a string, is used to
control individual messages, based on their text. The string argument
is a pattern that is used to match against the text of individual
-warning messages (not including the initial "warning: " tag).
+warning messages (not including the initial “warning: ” tag).
The pattern may contain asterisks, which match zero or more characters in
the message. For example, you can use
However, note that the pragma cannot immediately precede the relevant
wide character, because then the previous encoding will still be in
-effect, causing "illegal character" errors.
+effect, causing “illegal character” errors.
The argument can be an identifier or a character literal. In the identifier
case, it is one of @code{HEX}, @code{UPPER}, @code{SHIFT_JIS},
or subunits.
@node Implementation Defined Aspects,Implementation Defined Attributes,Implementation Defined Pragmas,Top
-@anchor{gnat_rm/implementation_defined_aspects implementation-defined-aspects}@anchor{11e}@anchor{gnat_rm/implementation_defined_aspects doc}@anchor{11f}@anchor{gnat_rm/implementation_defined_aspects id1}@anchor{120}
+@anchor{gnat_rm/implementation_defined_aspects doc}@anchor{11e}@anchor{gnat_rm/implementation_defined_aspects id1}@anchor{11f}@anchor{gnat_rm/implementation_defined_aspects implementation-defined-aspects}@anchor{120}
@chapter Implementation Defined Aspects
* Aspect Initializes::
* Aspect Inline_Always::
* Aspect Invariant::
-* Aspect Invariant'Class::
+* Aspect Invariant’Class::
* Aspect Iterable::
* Aspect Linker_Section::
* Aspect Lock_Free::
@geindex Abstract_State
-This aspect is equivalent to @ref{1c,,pragma Abstract_State}.
+This aspect is equivalent to @ref{1d,,pragma Abstract_State}.
@node Aspect Annotate,Aspect Async_Readers,Aspect Abstract_State,Implementation Defined Aspects
@anchor{gnat_rm/implementation_defined_aspects aspect-annotate}@anchor{122}
There are three forms of this aspect (where ID is an identifier,
and ARG is a general expression),
-corresponding to @ref{26,,pragma Annotate}.
+corresponding to @ref{27,,pragma Annotate}.
@table @asis
@geindex Async_Readers
-This boolean aspect is equivalent to @ref{2d,,pragma Async_Readers}.
+This boolean aspect is equivalent to @ref{2e,,pragma Async_Readers}.
@node Aspect Async_Writers,Aspect Constant_After_Elaboration,Aspect Async_Readers,Implementation Defined Aspects
@anchor{gnat_rm/implementation_defined_aspects aspect-async-writers}@anchor{124}
@geindex Depends
-This aspect is equivalent to @ref{53,,pragma Depends}.
+This aspect is equivalent to @ref{54,,pragma Depends}.
@node Aspect Default_Initial_Condition,Aspect Dimension,Aspect Depends,Implementation Defined Aspects
@anchor{gnat_rm/implementation_defined_aspects aspect-default-initial-condition}@anchor{128}
represent a theta character (avoiding the use of extended Latin-1
characters in this context).
-See section 'Performing Dimensionality Analysis in GNAT' in the GNAT Users
+See section ‘Performing Dimensionality Analysis in GNAT’ in the GNAT Users
Guide for detailed examples of use of the dimension system.
@node Aspect Disable_Controlled,Aspect Effective_Reads,Aspect Dimension_System,Implementation Defined Aspects
@geindex Ghost
-This aspect is equivalent to @ref{6e,,pragma Ghost}.
+This aspect is equivalent to @ref{6f,,pragma Ghost}.
@node Aspect Global,Aspect Initial_Condition,Aspect Ghost,Implementation Defined Aspects
@anchor{gnat_rm/implementation_defined_aspects aspect-global}@anchor{131}
@geindex Global
-This aspect is equivalent to @ref{70,,pragma Global}.
+This aspect is equivalent to @ref{71,,pragma Global}.
@node Aspect Initial_Condition,Aspect Initializes,Aspect Global,Implementation Defined Aspects
@anchor{gnat_rm/implementation_defined_aspects aspect-initial-condition}@anchor{132}
@geindex Initializes
-This aspect is equivalent to @ref{80,,pragma Initializes}.
+This aspect is equivalent to @ref{81,,pragma Initializes}.
@node Aspect Inline_Always,Aspect Invariant,Aspect Initializes,Implementation Defined Aspects
@anchor{gnat_rm/implementation_defined_aspects aspect-inline-always}@anchor{134}
This boolean aspect is equivalent to @ref{83,,pragma Inline_Always}.
-@node Aspect Invariant,Aspect Invariant'Class,Aspect Inline_Always,Implementation Defined Aspects
+@node Aspect Invariant,Aspect Invariant’Class,Aspect Inline_Always,Implementation Defined Aspects
@anchor{gnat_rm/implementation_defined_aspects aspect-invariant}@anchor{135}
@section Aspect Invariant
synonym for the language defined aspect @code{Type_Invariant} except
that it is separately controllable using pragma @code{Assertion_Policy}.
-@node Aspect Invariant'Class,Aspect Iterable,Aspect Invariant,Implementation Defined Aspects
+@node Aspect Invariant’Class,Aspect Iterable,Aspect Invariant,Implementation Defined Aspects
@anchor{gnat_rm/implementation_defined_aspects aspect-invariant-class}@anchor{136}
-@section Aspect Invariant'Class
+@section Aspect Invariant’Class
@geindex Invariant'Class
synonym for the language defined aspect @code{Type_Invariant'Class} except
that it is separately controllable using pragma @code{Assertion_Policy}.
-@node Aspect Iterable,Aspect Linker_Section,Aspect Invariant'Class,Implementation Defined Aspects
+@node Aspect Iterable,Aspect Linker_Section,Aspect Invariant’Class,Implementation Defined Aspects
@anchor{gnat_rm/implementation_defined_aspects aspect-iterable}@anchor{137}
@section Aspect Iterable
@geindex No_Caching
-This boolean aspect is equivalent to @ref{9e,,pragma No_Caching}.
+This boolean aspect is equivalent to @ref{9f,,pragma No_Caching}.
@node Aspect No_Elaboration_Code_All,Aspect No_Inline,Aspect No_Caching,Implementation Defined Aspects
@anchor{gnat_rm/implementation_defined_aspects aspect-no-elaboration-code-all}@anchor{13c}
@geindex No_Tagged_Streams
-This aspect is equivalent to @ref{a8,,pragma No_Tagged_Streams} with an
+This aspect is equivalent to @ref{a9,,pragma No_Tagged_Streams} with an
argument specifying a root tagged type (thus this aspect can only be
applied to such a type).
Applies to a type. If True, requires that the type and any descendants
do not have any task parts. The rules for this aspect are the same as
for the language-defined No_Controlled_Parts aspect (see RM-H.4.1),
-replacing "controlled" with "task".
+replacing “controlled” with “task”.
If No_Task_Parts is True for a type T, then the compiler can optimize
away certain tasking-related code that would otherwise be needed
-for T'Class, because descendants of T might contain tasks.
+for T’Class, because descendants of T might contain tasks.
@node Aspect Object_Size,Aspect Obsolescent,Aspect No_Task_Parts,Implementation Defined Aspects
@anchor{gnat_rm/implementation_defined_aspects aspect-object-size}@anchor{140}
@geindex Obsolsecent
-This aspect is equivalent to @ref{ab,,pragma Obsolescent}. Note that the
+This aspect is equivalent to @ref{ac,,pragma Obsolescent}. Note that the
evaluation of this aspect happens at the point of occurrence, it is not
delayed until the freeze point.
@geindex Predicate
-This aspect is equivalent to @ref{bd,,pragma Predicate}. It is thus
+This aspect is equivalent to @ref{be,,pragma Predicate}. It is thus
similar to the language defined aspects @code{Dynamic_Predicate}
and @code{Static_Predicate} except that whether the resulting
predicate is static or dynamic is controlled by the form of the
@geindex Pure_Function
-This boolean aspect is equivalent to @ref{c9,,pragma Pure_Function}.
+This boolean aspect is equivalent to @ref{ca,,pragma Pure_Function}.
@node Aspect Refined_Depends,Aspect Refined_Global,Aspect Pure_Function,Implementation Defined Aspects
@anchor{gnat_rm/implementation_defined_aspects aspect-refined-depends}@anchor{147}
@geindex Refined_Depends
-This aspect is equivalent to @ref{cd,,pragma Refined_Depends}.
+This aspect is equivalent to @ref{ce,,pragma Refined_Depends}.
@node Aspect Refined_Global,Aspect Refined_Post,Aspect Refined_Depends,Implementation Defined Aspects
@anchor{gnat_rm/implementation_defined_aspects aspect-refined-global}@anchor{148}
@geindex Refined_Global
-This aspect is equivalent to @ref{cf,,pragma Refined_Global}.
+This aspect is equivalent to @ref{d0,,pragma Refined_Global}.
@node Aspect Refined_Post,Aspect Refined_State,Aspect Refined_Global,Implementation Defined Aspects
@anchor{gnat_rm/implementation_defined_aspects aspect-refined-post}@anchor{149}
@geindex Refined_Post
-This aspect is equivalent to @ref{d1,,pragma Refined_Post}.
+This aspect is equivalent to @ref{d2,,pragma Refined_Post}.
@node Aspect Refined_State,Aspect Relaxed_Initialization,Aspect Refined_Post,Implementation Defined Aspects
@anchor{gnat_rm/implementation_defined_aspects aspect-refined-state}@anchor{14a}
@geindex Refined_State
-This aspect is equivalent to @ref{d3,,pragma Refined_State}.
+This aspect is equivalent to @ref{d4,,pragma Refined_State}.
@node Aspect Relaxed_Initialization,Aspect Remote_Access_Type,Aspect Refined_State,Implementation Defined Aspects
@anchor{gnat_rm/implementation_defined_aspects aspect-relaxed-initialization}@anchor{14b}
@geindex Simple_Storage_Pool_Type
-This boolean aspect is equivalent to @ref{e2,,pragma Simple_Storage_Pool_Type}.
+This boolean aspect is equivalent to @ref{e3,,pragma Simple_Storage_Pool_Type}.
@node Aspect SPARK_Mode,Aspect Suppress_Debug_Info,Aspect Simple_Storage_Pool_Type,Implementation Defined Aspects
@anchor{gnat_rm/implementation_defined_aspects aspect-spark-mode}@anchor{153}
@geindex SPARK_Mode
-This aspect is equivalent to @ref{ea,,pragma SPARK_Mode} and
+This aspect is equivalent to @ref{eb,,pragma SPARK_Mode} and
may be specified for either or both of the specification and body
of a subprogram or package.
@geindex Suppress_Debug_Info
-This boolean aspect is equivalent to @ref{f2,,pragma Suppress_Debug_Info}.
+This boolean aspect is equivalent to @ref{f3,,pragma Suppress_Debug_Info}.
@node Aspect Suppress_Initialization,Aspect Test_Case,Aspect Suppress_Debug_Info,Implementation Defined Aspects
@anchor{gnat_rm/implementation_defined_aspects aspect-suppress-initialization}@anchor{155}
@geindex Test_Case
-This aspect is equivalent to @ref{f9,,pragma Test_Case}.
+This aspect is equivalent to @ref{fa,,pragma Test_Case}.
@node Aspect Thread_Local_Storage,Aspect Universal_Aliasing,Aspect Test_Case,Implementation Defined Aspects
@anchor{gnat_rm/implementation_defined_aspects aspect-thread-local-storage}@anchor{157}
@geindex Thread_Local_Storage
-This boolean aspect is equivalent to @ref{fb,,pragma Thread_Local_Storage}.
+This boolean aspect is equivalent to @ref{fc,,pragma Thread_Local_Storage}.
@node Aspect Universal_Aliasing,Aspect Unmodified,Aspect Thread_Local_Storage,Implementation Defined Aspects
@anchor{gnat_rm/implementation_defined_aspects aspect-universal-aliasing}@anchor{158}
@geindex Universal_Aliasing
-This boolean aspect is equivalent to @ref{105,,pragma Universal_Aliasing}.
+This boolean aspect is equivalent to @ref{106,,pragma Universal_Aliasing}.
@node Aspect Unmodified,Aspect Unreferenced,Aspect Universal_Aliasing,Implementation Defined Aspects
@anchor{gnat_rm/implementation_defined_aspects aspect-unmodified}@anchor{159}
@geindex Unmodified
-This boolean aspect is equivalent to @ref{107,,pragma Unmodified}.
+This boolean aspect is equivalent to @ref{108,,pragma Unmodified}.
@node Aspect Unreferenced,Aspect Unreferenced_Objects,Aspect Unmodified,Implementation Defined Aspects
@anchor{gnat_rm/implementation_defined_aspects aspect-unreferenced}@anchor{15a}
@geindex Unreferenced
-This boolean aspect is equivalent to @ref{109,,pragma Unreferenced}.
+This boolean aspect is equivalent to @ref{10a,,pragma Unreferenced}.
When using the @code{-gnat2022} switch, this aspect is also supported on formal
parameters, which is in particular the only form possible for expression
@geindex Unreferenced_Objects
-This boolean aspect is equivalent to @ref{10b,,pragma Unreferenced_Objects}.
+This boolean aspect is equivalent to @ref{10c,,pragma Unreferenced_Objects}.
@node Aspect Value_Size,Aspect Volatile_Full_Access,Aspect Unreferenced_Objects,Implementation Defined Aspects
@anchor{gnat_rm/implementation_defined_aspects aspect-value-size}@anchor{15c}
is the entity.
@node Implementation Defined Attributes,Standard and Implementation Defined Restrictions,Implementation Defined Aspects,Top
-@anchor{gnat_rm/implementation_defined_attributes doc}@anchor{161}@anchor{gnat_rm/implementation_defined_attributes implementation-defined-attributes}@anchor{8}@anchor{gnat_rm/implementation_defined_attributes id1}@anchor{162}
+@anchor{gnat_rm/implementation_defined_attributes doc}@anchor{161}@anchor{gnat_rm/implementation_defined_attributes id1}@anchor{162}@anchor{gnat_rm/implementation_defined_attributes implementation-defined-attributes}@anchor{8}
@chapter Implementation Defined Attributes
@code{Standard'Address_Size} (@code{Standard} is the only allowed
prefix) is a static constant giving the number of bits in an
-@code{Address}. It is the same value as System.Address'Size,
+@code{Address}. It is the same value as System.Address’Size,
but has the advantage of being static, while a direct
-reference to System.Address'Size is nonstatic because Address
+reference to System.Address’Size is nonstatic because Address
is a private type.
@node Attribute Asm_Input,Attribute Asm_Output,Attribute Address_Size,Implementation Defined Attributes
@geindex Invalid_Value
-For every scalar type S, S'Invalid_Value returns an undefined value of the
+For every scalar type S, S’Invalid_Value returns an undefined value of the
type. If possible this value is an invalid representation for the type. The
value returned is identical to the value used to initialize an otherwise
uninitialized value of the type if pragma Initialize_Scalars is used,
whereas @code{X'Address} returns the address of the first
component.
-Here, we are interpreting 'storage pool' broadly to mean
+Here, we are interpreting ‘storage pool’ broadly to mean
@code{wherever the object is allocated}, which could be a
user-defined storage pool,
the global heap, on the stack, or in a static memory area.
This attribute allows compile time testing of restrictions that
are currently in effect. It is primarily intended for specializing
code in the run-time based on restrictions that are active (e.g.
-don't need to save fpt registers if restriction No_Floating_Point
+don’t need to save fpt registers if restriction No_Floating_Point
is known to be in effect), but can be used anywhere.
There are two forms:
this attribute.
@node Attribute Scalar_Storage_Order,Attribute Simple_Storage_Pool,Attribute Safe_Small,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes id4}@anchor{19c}@anchor{gnat_rm/implementation_defined_attributes attribute-scalar-storage-order}@anchor{14f}
+@anchor{gnat_rm/implementation_defined_attributes attribute-scalar-storage-order}@anchor{14f}@anchor{gnat_rm/implementation_defined_attributes id4}@anchor{19c}
@section Attribute Scalar_Storage_Order
For a record type @code{T}, if @code{T'Scalar_Storage_Order} is
specified explicitly, it shall be equal to @code{T'Bit_Order}. Note:
this means that if a @code{Scalar_Storage_Order} attribute definition
-clause is not confirming, then the type's @code{Bit_Order} shall be
+clause is not confirming, then the type’s @code{Bit_Order} shall be
specified explicitly and set to the same value.
Derived types inherit an explicitly set scalar storage order from their parent
The name given in an attribute_definition_clause for the
@code{Simple_Storage_Pool} attribute shall denote a variable of
-a 'simple storage pool type' (see pragma @cite{Simple_Storage_Pool_Type}).
+a ‘simple storage pool type’ (see pragma @cite{Simple_Storage_Pool_Type}).
The use of this attribute is only allowed for a prefix denoting a type
for which it has been specified. The type of the attribute is the type
The GNAT implementation of remote access-to-classwide types is
organized as described in AARM section E.4 (20.t): a value of an RACW type
(designating a remote object) is represented as a normal access
-value, pointing to a "stub" object which in turn contains the
+value, pointing to a “stub” object which in turn contains the
necessary information to contact the designated remote object. A
call on any dispatching operation of such a stub object does the
remote call, if necessary, using the information in the stub object
prefix) provides a static string value that identifies the target
for the current compilation. For GCC implementations, this is the
standard gcc target name without the terminating slash (for
-example, GNAT 5.0 on windows yields "i586-pc-mingw32msv").
+example, GNAT 5.0 on windows yields “i586-pc-mingw32msv”).
@node Attribute To_Address,Attribute To_Any,Attribute Target_Name,Implementation Defined Attributes
@anchor{gnat_rm/implementation_defined_attributes attribute-to-address}@anchor{1a5}
an access-to-unconstrained-array and returns that value to the caller,
the result will involve dangling pointers. In addition, it is only
valid to create pointers to unconstrained arrays using this attribute
-if the pointer has the normal default 'fat' representation where a
+if the pointer has the normal default ‘fat’ representation where a
pointer has two components, one points to the array and one points to
-the bounds. If a size clause is used to force 'thin' representation
+the bounds. If a size clause is used to force ‘thin’ representation
for a pointer to unconstrained where there is only space for a single
pointer, then the resulting pointer is not usable.
end;
@end example
-In general this is a risky approach. It may appear to "work" but such uses of
+In general this is a risky approach. It may appear to “work” but such uses of
@code{Unrestricted_Access} are potentially non-portable, even from one version
of GNAT to another, so are best avoided if possible.
the corresponding type.
@node Attribute Value_Size,Attribute Wchar_T_Size,Attribute VADS_Size,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes id6}@anchor{1b1}@anchor{gnat_rm/implementation_defined_attributes attribute-value-size}@anchor{15d}
+@anchor{gnat_rm/implementation_defined_attributes attribute-value-size}@anchor{15d}@anchor{gnat_rm/implementation_defined_attributes id6}@anchor{1b1}
@section Attribute Value_Size
a static constant.
@node Standard and Implementation Defined Restrictions,Implementation Advice,Implementation Defined Attributes,Top
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions standard-and-implementation-defined-restrictions}@anchor{9}@anchor{gnat_rm/standard_and_implementation_defined_restrictions doc}@anchor{1b4}@anchor{gnat_rm/standard_and_implementation_defined_restrictions id1}@anchor{1b5}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions doc}@anchor{1b4}@anchor{gnat_rm/standard_and_implementation_defined_restrictions id1}@anchor{1b5}@anchor{gnat_rm/standard_and_implementation_defined_restrictions standard-and-implementation-defined-restrictions}@anchor{9}
@chapter Standard and Implementation Defined Restrictions
@end menu
@node Partition-Wide Restrictions,Program Unit Level Restrictions,,Standard and Implementation Defined Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions partition-wide-restrictions}@anchor{1b6}@anchor{gnat_rm/standard_and_implementation_defined_restrictions id2}@anchor{1b7}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions id2}@anchor{1b6}@anchor{gnat_rm/standard_and_implementation_defined_restrictions partition-wide-restrictions}@anchor{1b7}
@section Partition-Wide Restrictions
@geindex Max_Storage_At_Blocking
-[RM D.7] Specifies the maximum portion (in storage elements) of a task's
+[RM D.7] Specifies the maximum portion (in storage elements) of a task’s
Storage_Size that can be retained by a blocked task. A violation of this
restriction causes Storage_Error to be raised.
[GNAT] This restriction prohibits any instance of default initialization
of variables. The binder implements a consistency rule which prevents
-any unit compiled without the restriction from with'ing a unit with the
+any unit compiled without the restriction from with’ing a unit with the
restriction (this allows the generation of initialization procedures to
be skipped, since you can be sure that no call is ever generated to an
initialization procedure in a unit with the restriction active). If used
@geindex trampoline
-[GNAT] This restriction prevents the compiler from building 'trampolines'.
+[GNAT] This restriction prevents the compiler from building ‘trampolines’.
This is a structure that is built on the stack and contains dynamic
code to be executed at run time. On some targets, a trampoline is
built for the following features: @code{Access},
Trampolines are also quite slow at run time.
On many targets, trampolines have been largely eliminated. Look at the
-version of system.ads for your target --- if it has
+version of system.ads for your target — if it has
Always_Compatible_Rep equal to False, then trampolines are largely
eliminated. In particular, a trampoline is built for the following
features: @code{Address} of a nested subprogram;
[GNAT] This partition-wide restriction forbids any explicit reference to
type Standard.Long_Long_Integer, and also forbids declaring range types whose
implicit base type is Long_Long_Integer, and modular types whose size exceeds
-Long_Integer'Size.
+Long_Integer’Size.
@node No_Multiple_Elaboration,No_Nested_Finalization,No_Long_Long_Integers,Partition-Wide Restrictions
@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-multiple-elaboration}@anchor{1e4}
implicitly defined comparison operators,
@item
-uses of the Standard."not" operator,
+uses of the Standard.”not” operator,
@item
short-circuit operator,
in a Storage_Size pragma or attribute definition clause is static.
@node Program Unit Level Restrictions,,Partition-Wide Restrictions,Standard and Implementation Defined Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions program-unit-level-restrictions}@anchor{203}@anchor{gnat_rm/standard_and_implementation_defined_restrictions id3}@anchor{204}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions id3}@anchor{203}@anchor{gnat_rm/standard_and_implementation_defined_restrictions program-unit-level-restrictions}@anchor{204}
@section Program Unit Level Restrictions
optimizer can figure this out.
Note that this the implementation of this restriction requires full
-code generation. If it is used in conjunction with "semantics only"
+code generation. If it is used in conjunction with “semantics only”
checking, then some cases of violations may be missed.
When this restriction is active, we are not requesting control-flow
@geindex No_Implicit_Aliasing
[GNAT] This restriction, which is not required to be partition-wide consistent,
-requires an explicit aliased keyword for an object to which 'Access,
-'Unchecked_Access, or 'Address is applied, and forbids entirely the use of
-the 'Unrestricted_Access attribute for objects. Note: the reason that
+requires an explicit aliased keyword for an object to which ‘Access,
+‘Unchecked_Access, or ‘Address is applied, and forbids entirely the use of
+the ‘Unrestricted_Access attribute for objects. Note: the reason that
Unrestricted_Access is forbidden is that it would require the prefix
to be aliased, and in such cases, it can always be replaced by
the standard attribute Unchecked_Access which is preferable.
@end example
@node Implementation Advice,Implementation Defined Characteristics,Standard and Implementation Defined Restrictions,Top
-@anchor{gnat_rm/implementation_advice doc}@anchor{214}@anchor{gnat_rm/implementation_advice implementation-advice}@anchor{a}@anchor{gnat_rm/implementation_advice id1}@anchor{215}
+@anchor{gnat_rm/implementation_advice doc}@anchor{214}@anchor{gnat_rm/implementation_advice id1}@anchor{215}@anchor{gnat_rm/implementation_advice implementation-advice}@anchor{a}
@chapter Implementation Advice
these requirements.
In addition, there are sections throughout the Ada Reference Manual headed
-by the phrase 'Implementation advice'. These sections are not normative,
+by the phrase ‘Implementation advice’. These sections are not normative,
i.e., they do not specify requirements that all compilers must
follow. Rather they provide advice on generally desirable behavior.
They are not requirements, because they describe behavior that cannot
the advice. The contents of each section consists of the RM text within
quotation marks,
followed by the GNAT interpretation of the advice. Most often, this simply says
-'followed', which means that GNAT follows the advice. However, in a
+‘followed’, which means that GNAT follows the advice. However, in a
number of cases, GNAT deliberately deviates from this advice, in which
case the text describes what GNAT does and why.
* RM 3.5.5(8); Enumeration Values: RM 3 5 5 8 Enumeration Values.
* RM 3.5.7(17); Float Types: RM 3 5 7 17 Float Types.
* RM 3.6.2(11); Multidimensional Arrays: RM 3 6 2 11 Multidimensional Arrays.
-* RM 9.6(30-31); Duration'Small: RM 9 6 30-31 Duration'Small.
+* RM 9.6(30-31); Duration’Small: RM 9 6 30-31 Duration’Small.
* RM 10.2.1(12); Consistent Representation: RM 10 2 1 12 Consistent Representation.
* RM 11.4.1(19); Exception Information: RM 11 4 1 19 Exception Information.
* RM 11.5(28); Suppression of Checks: RM 11 5 28 Suppression of Checks.
@quotation
-"If an implementation detects the use of an unsupported Specialized Needs
+“If an implementation detects the use of an unsupported Specialized Needs
Annex feature at run time, it should raise @code{Program_Error} if
-feasible."
+feasible.”
@end quotation
Not relevant. All specialized needs annex features are either supported,
@quotation
-"If an implementation wishes to provide implementation-defined
+“If an implementation wishes to provide implementation-defined
extensions to the functionality of a language-defined library unit, it
-should normally do so by adding children to the library unit."
+should normally do so by adding children to the library unit.”
@end quotation
Followed.
@quotation
-"If an implementation detects a bounded error or erroneous
-execution, it should raise @code{Program_Error}."
+“If an implementation detects a bounded error or erroneous
+execution, it should raise @code{Program_Error}.”
@end quotation
Followed in all cases in which the implementation detects a bounded
@quotation
-"Normally, implementation-defined pragmas should have no semantic effect
+“Normally, implementation-defined pragmas should have no semantic effect
for error-free programs; that is, if the implementation-defined pragmas
are removed from a working program, the program should still be legal,
-and should still have the same semantics."
+and should still have the same semantics.”
@end quotation
The following implementation defined pragmas are exceptions to this
@quotation
-"Normally, an implementation should not define pragmas that can
+“Normally, an implementation should not define pragmas that can
make an illegal program legal, except as follows:
@item
A pragma used to configure the environment by adding, removing, or
-replacing @code{library_items}."
+replacing @code{library_items}.”
@end itemize
@end quotation
@quotation
-"If an implementation supports a mode with alternative interpretations
+“If an implementation supports a mode with alternative interpretations
for @code{Character} and @code{Wide_Character}, the set of graphic
characters of @code{Character} should nevertheless remain a proper
subset of the set of graphic characters of @code{Wide_Character}. Any
-character set 'localizations' should be reflected in the results of
+character set ‘localizations’ should be reflected in the results of
the subprograms defined in the language-defined package
@code{Characters.Handling} (see A.3) available in such a mode. In a mode with
an alternative interpretation of @code{Character}, the implementation should
also support a corresponding change in what is a legal
-@code{identifier_letter}."
+@code{identifier_letter}.”
@end quotation
Not all wide character modes follow this advice, in particular the JIS
@quotation
-"An implementation should support @code{Long_Integer} in addition to
+“An implementation should support @code{Long_Integer} in addition to
@code{Integer} if the target machine supports 32-bit (or longer)
arithmetic. No other named integer subtypes are recommended for package
@code{Standard}. Instead, appropriate named integer subtypes should be
-provided in the library package @code{Interfaces} (see B.2)."
+provided in the library package @code{Interfaces} (see B.2).”
@end quotation
@code{Long_Integer} is supported. Other standard integer types are supported
@quotation
-"An implementation for a two's complement machine should support
+“An implementation for a two’s complement machine should support
modular types with a binary modulus up to @code{System.Max_Int*2+2}. An
-implementation should support a non-binary modules up to @code{Integer'Last}."
+implementation should support a non-binary modules up to @code{Integer'Last}.”
@end quotation
Followed.
@quotation
-"For the evaluation of a call on @code{S'Pos} for an enumeration
+“For the evaluation of a call on @code{S'Pos} for an enumeration
subtype, if the value of the operand does not correspond to the internal
code for any enumeration literal of its type (perhaps due to an
un-initialized variable), then the implementation should raise
@code{Program_Error}. This is particularly important for enumeration
types with noncontiguous internal codes specified by an
-enumeration_representation_clause."
+enumeration_representation_clause.”
@end quotation
Followed.
@quotation
-"An implementation should support @code{Long_Float} in addition to
+“An implementation should support @code{Long_Float} in addition to
@code{Float} if the target machine supports 11 or more digits of
precision. No other named floating point subtypes are recommended for
package @code{Standard}. Instead, appropriate named floating point subtypes
-should be provided in the library package @code{Interfaces} (see B.2)."
+should be provided in the library package @code{Interfaces} (see B.2).”
@end quotation
@code{Short_Float} and @code{Long_Long_Float} are also provided. The
@geindex Arrays
@geindex multidimensional
-@node RM 3 6 2 11 Multidimensional Arrays,RM 9 6 30-31 Duration'Small,RM 3 5 7 17 Float Types,Implementation Advice
+@node RM 3 6 2 11 Multidimensional Arrays,RM 9 6 30-31 Duration’Small,RM 3 5 7 17 Float Types,Implementation Advice
@anchor{gnat_rm/implementation_advice rm-3-6-2-11-multidimensional-arrays}@anchor{221}
@section RM 3.6.2(11): Multidimensional Arrays
@quotation
-"An implementation should normally represent multidimensional arrays in
+“An implementation should normally represent multidimensional arrays in
row-major order, consistent with the notation used for multidimensional
array aggregates (see 4.3.3). However, if a pragma @code{Convention}
-(@code{Fortran}, ...) applies to a multidimensional array type, then
-column-major order should be used instead (see B.5, @emph{Interfacing with Fortran})."
+(@code{Fortran}, …) applies to a multidimensional array type, then
+column-major order should be used instead (see B.5, @emph{Interfacing with Fortran}).”
@end quotation
Followed.
@geindex Duration'Small
-@node RM 9 6 30-31 Duration'Small,RM 10 2 1 12 Consistent Representation,RM 3 6 2 11 Multidimensional Arrays,Implementation Advice
+@node RM 9 6 30-31 Duration’Small,RM 10 2 1 12 Consistent Representation,RM 3 6 2 11 Multidimensional Arrays,Implementation Advice
@anchor{gnat_rm/implementation_advice rm-9-6-30-31-duration-small}@anchor{222}
-@section RM 9.6(30-31): Duration'Small
+@section RM 9.6(30-31): Duration’Small
@quotation
-"Whenever possible in an implementation, the value of @code{Duration'Small}
-should be no greater than 100 microseconds."
+“Whenever possible in an implementation, the value of @code{Duration'Small}
+should be no greater than 100 microseconds.”
@end quotation
Followed. (@code{Duration'Small} = 10**(-9)).
@quotation
-"The time base for @code{delay_relative_statements} should be monotonic;
-it need not be the same time base as used for @code{Calendar.Clock}."
+“The time base for @code{delay_relative_statements} should be monotonic;
+it need not be the same time base as used for @code{Calendar.Clock}.”
@end quotation
Followed.
-@node RM 10 2 1 12 Consistent Representation,RM 11 4 1 19 Exception Information,RM 9 6 30-31 Duration'Small,Implementation Advice
+@node RM 10 2 1 12 Consistent Representation,RM 11 4 1 19 Exception Information,RM 9 6 30-31 Duration’Small,Implementation Advice
@anchor{gnat_rm/implementation_advice rm-10-2-1-12-consistent-representation}@anchor{223}
@section RM 10.2.1(12): Consistent Representation
@quotation
-"In an implementation, a type declared in a pre-elaborated package should
+“In an implementation, a type declared in a pre-elaborated package should
have the same representation in every elaboration of a given version of
the package, whether the elaborations occur in distinct executions of
the same program, or in executions of distinct programs or partitions
-that include the given version."
+that include the given version.”
@end quotation
Followed, except in the case of tagged types. Tagged types involve
@quotation
-"@code{Exception_Message} by default and @code{Exception_Information}
+“@code{Exception_Message} by default and @code{Exception_Information}
should produce information useful for
debugging. @code{Exception_Message} should be short, about one
line. @code{Exception_Information} can be long. @code{Exception_Message}
should not include the
@code{Exception_Name}. @code{Exception_Information} should include both
-the @code{Exception_Name} and the @code{Exception_Message}."
+the @code{Exception_Name} and the @code{Exception_Message}.”
@end quotation
-Followed. For each exception that doesn't have a specified
+Followed. For each exception that doesn’t have a specified
@code{Exception_Message}, the compiler generates one containing the location
-of the raise statement. This location has the form 'file_name:line', where
+of the raise statement. This location has the form ‘file_name:line’, where
file_name is the short file name (without path information) and line is the line
number in the file. Note that in the case of the Zero Cost Exception
mechanism, these messages become redundant with the Exception_Information that
@quotation
-"The implementation should minimize the code executed for checks that
-have been suppressed."
+“The implementation should minimize the code executed for checks that
+have been suppressed.”
@end quotation
Followed.
@quotation
-"The recommended level of support for all representation items is
+“The recommended level of support for all representation items is
qualified as follows:
An implementation need not support representation items containing
nonstatic expressions, except that an implementation should support a
representation item for a given entity if each nonstatic expression in
the representation item is a name that statically denotes a constant
-declared before the entity."
+declared before the entity.”
@end quotation
Followed. In fact, GNAT goes beyond the recommended level of support
@quotation
-"An aliased component, or a component whose type is by-reference, should
-always be allocated at an addressable location."
+“An aliased component, or a component whose type is by-reference, should
+always be allocated at an addressable location.”
@end quotation
Followed.
@quotation
-"If a type is packed, then the implementation should try to minimize
+“If a type is packed, then the implementation should try to minimize
storage allocated to objects of the type, possibly at the expense of
speed of accessing components, subject to reasonable complexity in
addressing calculations.
any @emph{record_representation_clause} that applies to the type; the
implementation may, but need not, reorder components or cross aligned
word boundaries to improve the packing. A component whose @code{Size} is
-greater than the word size may be allocated an integral number of words."
+greater than the word size may be allocated an integral number of words.”
@end quotation
Followed. Tight packing of arrays is supported for all component sizes
@quotation
-"An implementation should support Address clauses for imported
-subprograms."
+“An implementation should support Address clauses for imported
+subprograms.”
@end quotation
Followed.
@quotation
-"For an array @code{X}, @code{X'Address} should point at the first
-component of the array, and not at the array bounds."
+“For an array @code{X}, @code{X'Address} should point at the first
+component of the array, and not at the array bounds.”
@end quotation
Followed.
@quotation
-"The recommended level of support for the @code{Address} attribute is:
+“The recommended level of support for the @code{Address} attribute is:
@code{X'Address} should produce a useful result if @code{X} is an
object that is aliased or of a by-reference type, or is an entity whose
-@code{Address} has been specified."
+@code{Address} has been specified.”
@end quotation
Followed. A valid address will be produced even if none of those
@quotation
-"An implementation should support @code{Address} clauses for imported
-subprograms."
+“An implementation should support @code{Address} clauses for imported
+subprograms.”
@end quotation
Followed.
@quotation
-"Objects (including subcomponents) that are aliased or of a by-reference
-type should be allocated on storage element boundaries."
+“Objects (including subcomponents) that are aliased or of a by-reference
+type should be allocated on storage element boundaries.”
@end quotation
Followed.
@quotation
-"If the @code{Address} of an object is specified, or it is imported or exported,
+“If the @code{Address} of an object is specified, or it is imported or exported,
then the implementation should not perform optimizations based on
-assumptions of no aliases."
+assumptions of no aliases.”
@end quotation
Followed.
@quotation
-"The recommended level of support for the @code{Alignment} attribute for
+“The recommended level of support for the @code{Alignment} attribute for
subtypes is:
An implementation should support specified Alignments that are factors
and multiples of the number of storage elements per word, subject to the
-following:"
+following:”
@end quotation
Followed.
@quotation
-"An implementation need not support specified Alignments for
+“An implementation need not support specified Alignments for
combinations of Sizes and Alignments that cannot be easily
-loaded and stored by available machine instructions."
+loaded and stored by available machine instructions.”
@end quotation
Followed.
@quotation
-"An implementation need not support specified Alignments that are
+“An implementation need not support specified Alignments that are
greater than the maximum @code{Alignment} the implementation ever returns by
-default."
+default.”
@end quotation
Followed.
@quotation
-"The recommended level of support for the @code{Alignment} attribute for
+“The recommended level of support for the @code{Alignment} attribute for
objects is:
-Same as above, for subtypes, but in addition:"
+Same as above, for subtypes, but in addition:”
@end quotation
Followed.
@quotation
-"For stand-alone library-level objects of statically constrained
+“For stand-alone library-level objects of statically constrained
subtypes, the implementation should support all alignments
supported by the target linker. For example, page alignment is likely to
-be supported for such objects, but not for subtypes."
+be supported for such objects, but not for subtypes.”
@end quotation
Followed.
@quotation
-"The recommended level of support for the @code{Size} attribute of
+“The recommended level of support for the @code{Size} attribute of
objects is:
A @code{Size} clause should be supported for an object if the specified
-@code{Size} is at least as large as its subtype's @code{Size}, and
+@code{Size} is at least as large as its subtype’s @code{Size}, and
corresponds to a size in storage elements that is a multiple of the
-object's @code{Alignment} (if the @code{Alignment} is nonzero)."
+object’s @code{Alignment} (if the @code{Alignment} is nonzero).”
@end quotation
Followed.
@quotation
-"If the @code{Size} of a subtype is specified, and allows for efficient
+“If the @code{Size} of a subtype is specified, and allows for efficient
independent addressability (see 9.10) on the target architecture, then
the @code{Size} of the following objects of the subtype should equal the
@code{Size} of the subtype:
-Aliased objects (including components)."
+Aliased objects (including components).”
@end quotation
Followed.
@quotation
-"@cite{Size} clause on a composite subtype should not affect the
-internal layout of components."
+“@cite{Size} clause on a composite subtype should not affect the
+internal layout of components.”
@end quotation
Followed. But note that this can be overridden by use of the implementation
@quotation
-"The recommended level of support for the @code{Size} attribute of subtypes is:
+“The recommended level of support for the @code{Size} attribute of subtypes is:
The @code{Size} (if not specified) of a static discrete or fixed point
subtype should be the number of bits needed to represent each value
belonging to the subtype using an unbiased representation, leaving space
for a sign bit only if the subtype contains negative values. If such a
subtype is a first subtype, then an implementation should support a
-specified @code{Size} for it that reflects this representation."
+specified @code{Size} for it that reflects this representation.”
@end quotation
Followed.
@quotation
-"For a subtype implemented with levels of indirection, the @code{Size}
+“For a subtype implemented with levels of indirection, the @code{Size}
should include the size of the pointers, but not the size of what they
-point at."
+point at.”
@end quotation
Followed.
@quotation
-"The recommended level of support for the @code{Component_Size}
+“The recommended level of support for the @code{Component_Size}
attribute is:
An implementation need not support specified @code{Component_Sizes} that are
-less than the @code{Size} of the component subtype."
+less than the @code{Size} of the component subtype.”
@end quotation
Followed.
@quotation
-"An implementation should support specified Component_Sizes that
+“An implementation should support specified Component_Sizes that
are factors and multiples of the word size. For such
Component_Sizes, the array should contain no gaps between
components. For other Component_Sizes (if supported), the array
should contain no gaps between components when packing is also
specified; the implementation should forbid this combination in cases
-where it cannot support a no-gaps representation."
+where it cannot support a no-gaps representation.”
@end quotation
Followed.
@quotation
-"The recommended level of support for enumeration representation clauses
+“The recommended level of support for enumeration representation clauses
is:
An implementation need not support enumeration representation clauses
for boolean types, but should at minimum support the internal codes in
-the range @code{System.Min_Int .. System.Max_Int}."
+the range @code{System.Min_Int .. System.Max_Int}.”
@end quotation
Followed.
@quotation
-"The recommended level of support for
+“The recommended level of support for
@emph{record_representation_clause}s is:
An implementation should support storage places that can be extracted
with a load, mask, shift sequence of machine code, and set with a load,
shift, mask, store sequence, given the available machine instructions
-and run-time model."
+and run-time model.”
@end quotation
Followed.
@quotation
-"A storage place should be supported if its size is equal to the
+“A storage place should be supported if its size is equal to the
@code{Size} of the component subtype, and it starts and ends on a
-boundary that obeys the @code{Alignment} of the component subtype."
+boundary that obeys the @code{Alignment} of the component subtype.”
@end quotation
Followed.
@quotation
-"If the default bit ordering applies to the declaration of a given type,
-then for a component whose subtype's @code{Size} is less than the word
+“If the default bit ordering applies to the declaration of a given type,
+then for a component whose subtype’s @code{Size} is less than the word
size, any storage place that does not cross an aligned word boundary
-should be supported."
+should be supported.”
@end quotation
Followed.
@quotation
-"An implementation may reserve a storage place for the tag field of a
-tagged type, and disallow other components from overlapping that place."
+“An implementation may reserve a storage place for the tag field of a
+tagged type, and disallow other components from overlapping that place.”
@end quotation
Followed. The storage place for the tag field is the beginning of the tagged
-record, and its size is Address'Size. GNAT will reject an explicit component
+record, and its size is Address’Size. GNAT will reject an explicit component
clause for the tag field.
@quotation
-"An implementation need not support a @emph{component_clause} for a
+“An implementation need not support a @emph{component_clause} for a
component of an extension part if the storage place is not after the
storage places of all components of the parent type, whether or not
-those storage places had been specified."
+those storage places had been specified.”
@end quotation
Followed. The above advice on record representation clauses is followed,
@quotation
-"If a component is represented using some form of pointer (such as an
+“If a component is represented using some form of pointer (such as an
offset) to the actual data of the component, and this data is contiguous
with the rest of the object, then the storage place attributes should
reflect the place of the actual data, not the pointer. If a component is
allocated discontinuously from the rest of the object, then a warning
should be generated upon reference to one of its storage place
-attributes."
+attributes.”
@end quotation
Followed. There are no such components in GNAT.
@quotation
-"The recommended level of support for the non-default bit ordering is:
+“The recommended level of support for the non-default bit ordering is:
If @code{Word_Size} = @code{Storage_Unit}, then the implementation
should support the non-default bit ordering in addition to the default
-bit ordering."
+bit ordering.”
@end quotation
Followed. Word size does not equal storage size in this implementation.
@quotation
-"@cite{Address} should be of a private type."
+“@cite{Address} should be of a private type.”
@end quotation
Followed.
@quotation
-"Operations in @code{System} and its children should reflect the target
+“Operations in @code{System} and its children should reflect the target
environment semantics as closely as is reasonable. For example, on most
-machines, it makes sense for address arithmetic to 'wrap around'.
-Operations that do not make sense should raise @code{Program_Error}."
+machines, it makes sense for address arithmetic to ‘wrap around’.
+Operations that do not make sense should raise @code{Program_Error}.”
@end quotation
Followed. Address arithmetic is modular arithmetic that wraps around. No
@quotation
-"The @code{Size} of an array object should not include its bounds; hence,
-the bounds should not be part of the converted data."
+“The @code{Size} of an array object should not include its bounds; hence,
+the bounds should not be part of the converted data.”
@end quotation
Followed.
@quotation
-"The implementation should not generate unnecessary run-time checks to
+“The implementation should not generate unnecessary run-time checks to
ensure that the representation of @code{S} is a representation of the
target type. It should take advantage of the permission to return by
reference when possible. Restrictions on unchecked conversions should be
-avoided unless required by the target environment."
+avoided unless required by the target environment.”
@end quotation
Followed. There are no restrictions on unchecked conversion. A warning is
@quotation
-"The recommended level of support for unchecked conversions is:
+“The recommended level of support for unchecked conversions is:
Unchecked conversions should be supported and should be reversible in
the cases where this clause defines the result. To enable meaningful use
elementary subtypes, for statically constrained array subtypes whose
component subtype is one of the subtypes described in this paragraph,
and for record subtypes without discriminants whose component subtypes
-are described in this paragraph."
+are described in this paragraph.”
@end quotation
Followed.
@quotation
-"An implementation should document any cases in which it dynamically
+“An implementation should document any cases in which it dynamically
allocates heap storage for a purpose other than the evaluation of an
-allocator."
+allocator.”
@end quotation
Followed, the only other points at which heap storage is dynamically
@quotation
-"A default (implementation-provided) storage pool for an
+“A default (implementation-provided) storage pool for an
access-to-constant type should not have overhead to support deallocation of
-individual objects."
+individual objects.”
@end quotation
Followed.
@quotation
-"A storage pool for an anonymous access type should be created at the
+“A storage pool for an anonymous access type should be created at the
point of an allocator for the type, and be reclaimed when the designated
-object becomes inaccessible."
+object becomes inaccessible.”
@end quotation
Followed.
@quotation
-"For a standard storage pool, @code{Free} should actually reclaim the
-storage."
+“For a standard storage pool, @code{Free} should actually reclaim the
+storage.”
@end quotation
Followed.
@quotation
-"If not specified, the value of Stream_Size for an elementary type
+“If not specified, the value of Stream_Size for an elementary type
should be the number of bits that corresponds to the minimum number of
stream elements required by the first subtype of the type, rounded up
to the nearest factor or multiple of the word size that is also a
-multiple of the stream element size."
+multiple of the stream element size.”
@end quotation
Followed, except that the number of stream elements is 1, 2, 3, 4 or 8.
@quotation
-"If an implementation provides additional named predefined integer types,
+“If an implementation provides additional named predefined integer types,
then the names should end with @code{Integer} as in
@code{Long_Integer}. If an implementation provides additional named
predefined floating point types, then the names should end with
-@code{Float} as in @code{Long_Float}."
+@code{Float} as in @code{Long_Float}.”
@end quotation
Followed.
@quotation
-"If an implementation provides a localized definition of @code{Character}
+“If an implementation provides a localized definition of @code{Character}
or @code{Wide_Character}, then the effects of the subprograms in
@code{Characters.Handling} should reflect the localizations.
-See also 3.5.2."
+See also 3.5.2.”
@end quotation
Followed. GNAT provides no such localized definitions.
@quotation
-"Bounded string objects should not be implemented by implicit pointers
-and dynamic allocation."
+“Bounded string objects should not be implemented by implicit pointers
+and dynamic allocation.”
@end quotation
Followed. No implicit pointers or dynamic allocation are used.
@quotation
-"Any storage associated with an object of type @code{Generator} should be
-reclaimed on exit from the scope of the object."
+“Any storage associated with an object of type @code{Generator} should be
+reclaimed on exit from the scope of the object.”
@end quotation
Followed.
@quotation
-"If the generator period is sufficiently long in relation to the number
+“If the generator period is sufficiently long in relation to the number
of distinct initiator values, then each possible value of
@code{Initiator} passed to @code{Reset} should initiate a sequence of
random numbers that does not, in a practical sense, overlap the sequence
initiated by any other value. If this is not possible, then the mapping
between initiator values and generator states should be a rapidly
-varying function of the initiator value."
+varying function of the initiator value.”
@end quotation
Followed. The generator period is sufficiently long for the first
@quotation
-"The @code{Get_Immediate} procedures should be implemented with
+“The @code{Get_Immediate} procedures should be implemented with
unbuffered input. For a device such as a keyboard, input should be
available if a key has already been typed, whereas for a disk
file, input should always be available except at end of file. For a file
associated with a keyboard-like device, any line-editing features of the
underlying operating system should be disabled during the execution of
-@code{Get_Immediate}."
+@code{Get_Immediate}.”
@end quotation
Followed on all targets except VxWorks. For VxWorks, there is no way to
@quotation
-"Bounded ordered set objects should be implemented without implicit pointers or dynamic allocation. "
+“Bounded ordered set objects should be implemented without implicit pointers or dynamic allocation. “
@end quotation
The implementations of the two Reference_Preserving_Key functions of
@quotation
-"If an implementation supports pragma @code{Export} to a given language,
+“If an implementation supports pragma @code{Export} to a given language,
then it should also allow the main subprogram to be written in that
language. It should support some mechanism for invoking the elaboration
of the Ada library units included in the system, and for invoking the
@code{adainit} and @code{adafinal}. @code{adainit} should contain the
elaboration code for library units. @code{adafinal} should contain the
finalization code. These subprograms should have no effect the second
-and subsequent time they are called."
+and subsequent time they are called.”
@end quotation
Followed.
@quotation
-"Automatic elaboration of pre-elaborated packages should be
-provided when pragma @code{Export} is supported."
+“Automatic elaboration of pre-elaborated packages should be
+provided when pragma @code{Export} is supported.”
@end quotation
Followed when the main program is in Ada. If the main program is in a
@quotation
-"For each supported convention @emph{L} other than @code{Intrinsic}, an
+“For each supported convention @emph{L} other than @code{Intrinsic}, an
implementation should support @code{Import} and @code{Export} pragmas
for objects of @emph{L}-compatible types and for subprograms, and pragma
@cite{Convention} for @emph{L}-eligible types and for subprograms,
presuming the other language has corresponding features. Pragma
-@code{Convention} need not be supported for scalar types."
+@code{Convention} need not be supported for scalar types.”
@end quotation
Followed.
@quotation
-"For each implementation-defined convention identifier, there should be a
+“For each implementation-defined convention identifier, there should be a
child package of package Interfaces with the corresponding name. This
package should contain any declarations that would be useful for
interfacing to the language (implementation) represented by the
convention. Any declarations useful for interfacing to any language on
the given hardware architecture should be provided directly in
-@code{Interfaces}."
+@code{Interfaces}.”
@end quotation
Followed.
@quotation
-"An implementation supporting an interface to C, COBOL, or Fortran should
+“An implementation supporting an interface to C, COBOL, or Fortran should
provide the corresponding package or packages described in the following
-clauses."
+clauses.”
@end quotation
Followed. GNAT provides all the packages described in this section.
@quotation
-"An implementation should support the following interface correspondences
-between Ada and C."
+“An implementation should support the following interface correspondences
+between Ada and C.”
@end quotation
Followed.
@quotation
-"An Ada procedure corresponds to a void-returning C function."
+“An Ada procedure corresponds to a void-returning C function.”
@end quotation
Followed.
@quotation
-"An Ada function corresponds to a non-void C function."
+“An Ada function corresponds to a non-void C function.”
@end quotation
Followed.
@quotation
-"An Ada @code{in} scalar parameter is passed as a scalar argument to a C
-function."
+“An Ada @code{in} scalar parameter is passed as a scalar argument to a C
+function.”
@end quotation
Followed.
@quotation
-"An Ada @code{in} parameter of an access-to-object type with designated
+“An Ada @code{in} parameter of an access-to-object type with designated
type @code{T} is passed as a @code{t*} argument to a C function,
-where @code{t} is the C type corresponding to the Ada type @code{T}."
+where @code{t} is the C type corresponding to the Ada type @code{T}.”
@end quotation
Followed.
@quotation
-"An Ada access @code{T} parameter, or an Ada @code{out} or @code{in out}
+“An Ada access @code{T} parameter, or an Ada @code{out} or @code{in out}
parameter of an elementary type @code{T}, is passed as a @code{t*}
argument to a C function, where @code{t} is the C type corresponding to
the Ada type @code{T}. In the case of an elementary @code{out} or
@code{in out} parameter, a pointer to a temporary copy is used to
-preserve by-copy semantics."
+preserve by-copy semantics.”
@end quotation
Followed.
@quotation
-"An Ada parameter of a record type @code{T}, of any mode, is passed as a
+“An Ada parameter of a record type @code{T}, of any mode, is passed as a
@code{t*} argument to a C function, where @code{t} is the C
-structure corresponding to the Ada type @code{T}."
+structure corresponding to the Ada type @code{T}.”
@end quotation
Followed. This convention may be overridden by the use of the C_Pass_By_Copy
@quotation
-"An Ada parameter of an array type with component type @code{T}, of any
+“An Ada parameter of an array type with component type @code{T}, of any
mode, is passed as a @code{t*} argument to a C function, where
-@code{t} is the C type corresponding to the Ada type @code{T}."
+@code{t} is the C type corresponding to the Ada type @code{T}.”
@end quotation
Followed.
@quotation
-"An Ada parameter of an access-to-subprogram type is passed as a pointer
+“An Ada parameter of an access-to-subprogram type is passed as a pointer
to a C function whose prototype corresponds to the designated
-subprogram's specification."
+subprogram’s specification.”
@end quotation
Followed.
@quotation
-"An Ada implementation should support the following interface
-correspondences between Ada and COBOL."
+“An Ada implementation should support the following interface
+correspondences between Ada and COBOL.”
@end quotation
Followed.
@quotation
-"An Ada access @code{T} parameter is passed as a @code{BY REFERENCE} data item of
-the COBOL type corresponding to @code{T}."
+“An Ada access @code{T} parameter is passed as a @code{BY REFERENCE} data item of
+the COBOL type corresponding to @code{T}.”
@end quotation
Followed.
@quotation
-"An Ada in scalar parameter is passed as a @code{BY CONTENT} data item of
-the corresponding COBOL type."
+“An Ada in scalar parameter is passed as a @code{BY CONTENT} data item of
+the corresponding COBOL type.”
@end quotation
Followed.
@quotation
-"Any other Ada parameter is passed as a @code{BY REFERENCE} data item of the
+“Any other Ada parameter is passed as a @code{BY REFERENCE} data item of the
COBOL type corresponding to the Ada parameter type; for scalars, a local
-copy is used if necessary to ensure by-copy semantics."
+copy is used if necessary to ensure by-copy semantics.”
@end quotation
Followed.
@quotation
-"An Ada implementation should support the following interface
-correspondences between Ada and Fortran:"
+“An Ada implementation should support the following interface
+correspondences between Ada and Fortran:”
@end quotation
Followed.
@quotation
-"An Ada procedure corresponds to a Fortran subroutine."
+“An Ada procedure corresponds to a Fortran subroutine.”
@end quotation
Followed.
@quotation
-"An Ada function corresponds to a Fortran function."
+“An Ada function corresponds to a Fortran function.”
@end quotation
Followed.
@quotation
-"An Ada parameter of an elementary, array, or record type @code{T} is
+“An Ada parameter of an elementary, array, or record type @code{T} is
passed as a @code{T} argument to a Fortran procedure, where @code{T} is
the Fortran type corresponding to the Ada type @code{T}, and where the
INTENT attribute of the corresponding dummy argument matches the Ada
-formal parameter mode; the Fortran implementation's parameter passing
+formal parameter mode; the Fortran implementation’s parameter passing
conventions are used. For elementary types, a local copy is used if
-necessary to ensure by-copy semantics."
+necessary to ensure by-copy semantics.”
@end quotation
Followed.
@quotation
-"An Ada parameter of an access-to-subprogram type is passed as a
+“An Ada parameter of an access-to-subprogram type is passed as a
reference to a Fortran procedure whose interface corresponds to the
-designated subprogram's specification."
+designated subprogram’s specification.”
@end quotation
Followed.
@quotation
-"The machine code or intrinsic support should allow access to all
+“The machine code or intrinsic support should allow access to all
operations normally available to assembly language programmers for the
-target environment, including privileged instructions, if any."
+target environment, including privileged instructions, if any.”
@end quotation
Followed.
@quotation
-"The interfacing pragmas (see Annex B) should support interface to
+“The interfacing pragmas (see Annex B) should support interface to
assembler; the default assembler should be associated with the
-convention identifier @code{Assembler}."
+convention identifier @code{Assembler}.”
@end quotation
Followed.
@quotation
-"If an entity is exported to assembly language, then the implementation
+“If an entity is exported to assembly language, then the implementation
should allocate it at an addressable location, and should ensure that it
is retained by the linking process, even if not otherwise referenced
from the Ada code. The implementation should assume that any call to a
machine code or assembler subprogram is allowed to read or update every
-object that is specified as exported."
+object that is specified as exported.”
@end quotation
Followed.
@quotation
-"The implementation should ensure that little or no overhead is
-associated with calling intrinsic and machine-code subprograms."
+“The implementation should ensure that little or no overhead is
+associated with calling intrinsic and machine-code subprograms.”
@end quotation
Followed for both intrinsics and machine-code subprograms.
@quotation
-"It is recommended that intrinsic subprograms be provided for convenient
+“It is recommended that intrinsic subprograms be provided for convenient
access to any machine operations that provide special capabilities or
efficiency and that are not otherwise available through the language
-constructs."
+constructs.”
@end quotation
Followed. A full set of machine operation intrinsic subprograms is provided.
@quotation
-"Atomic read-modify-write operations---e.g., test and set, compare and
-swap, decrement and test, enqueue/dequeue."
+“Atomic read-modify-write operations—e.g., test and set, compare and
+swap, decrement and test, enqueue/dequeue.”
@end quotation
Followed on any target supporting such operations.
@quotation
-"Standard numeric functions---e.g.:, sin, log."
+“Standard numeric functions—e.g.:, sin, log.”
@end quotation
Followed on any target supporting such operations.
@quotation
-"String manipulation operations---e.g.:, translate and test."
+“String manipulation operations—e.g.:, translate and test.”
@end quotation
Followed on any target supporting such operations.
@quotation
-"Vector operations---e.g.:, compare vector against thresholds."
+“Vector operations—e.g.:, compare vector against thresholds.”
@end quotation
Followed on any target supporting such operations.
@quotation
-"Direct operations on I/O ports."
+“Direct operations on I/O ports.”
@end quotation
Followed on any target supporting such operations.
@quotation
-"If the @code{Ceiling_Locking} policy is not in effect, the
+“If the @code{Ceiling_Locking} policy is not in effect, the
implementation should provide means for the application to specify which
interrupts are to be blocked during protected actions, if the underlying
-system allows for a finer-grain control of interrupt blocking."
+system allows for a finer-grain control of interrupt blocking.”
@end quotation
Followed. The underlying system does not allow for finer-grain control
@quotation
-"Whenever possible, the implementation should allow interrupt handlers to
-be called directly by the hardware."
+“Whenever possible, the implementation should allow interrupt handlers to
+be called directly by the hardware.”
@end quotation
Followed on any target where the underlying operating system permits
@quotation
-"Whenever practical, violations of any
-implementation-defined restrictions should be detected before run time."
+“Whenever practical, violations of any
+implementation-defined restrictions should be detected before run time.”
@end quotation
Followed. Compile time warnings are given when possible.
@quotation
-"If implementation-defined forms of interrupt handler procedures are
+“If implementation-defined forms of interrupt handler procedures are
supported, such as protected procedures with parameters, then for each
such form of a handler, a type analogous to @code{Parameterless_Handler}
should be specified in a child package of @code{Interrupts}, with the
-same operations as in the predefined package Interrupts."
+same operations as in the predefined package Interrupts.”
@end quotation
Followed.
@quotation
-"It is recommended that pre-elaborated packages be implemented in such a
+“It is recommended that pre-elaborated packages be implemented in such a
way that there should be little or no code executed at run time for the
elaboration of entities not already covered by the Implementation
-Requirements."
+Requirements.”
@end quotation
Followed. Executable code is generated in some cases, e.g., loops
@quotation
-"If the pragma applies to an entity, then the implementation should
+“If the pragma applies to an entity, then the implementation should
reduce the amount of storage used for storing names associated with that
-entity."
+entity.”
@end quotation
Followed.
@quotation
-"Some implementations are targeted to domains in which memory use at run
+“Some implementations are targeted to domains in which memory use at run
time must be completely deterministic. For such implementations, it is
recommended that the storage for task attributes will be pre-allocated
statically and not from the heap. This can be accomplished by either
-placing restrictions on the number and the size of the task's
+placing restrictions on the number and the size of the task’s
attributes, or by using the pre-allocated storage for the first @code{N}
attribute objects, and the heap for the others. In the latter case,
-@code{N} should be documented."
+@code{N} should be documented.”
@end quotation
Not followed. This implementation is not targeted to such a domain.
@quotation
-"The implementation should use names that end with @code{_Locking} for
-locking policies defined by the implementation."
+“The implementation should use names that end with @code{_Locking} for
+locking policies defined by the implementation.”
@end quotation
Followed. Two implementation-defined locking policies are defined,
@quotation
-"Names that end with @code{_Queuing} should be used
-for all implementation-defined queuing policies."
+“Names that end with @code{_Queuing} should be used
+for all implementation-defined queuing policies.”
@end quotation
Followed. No such implementation-defined queuing policies exist.
@quotation
-"Even though the @emph{abort_statement} is included in the list of
+“Even though the @emph{abort_statement} is included in the list of
potentially blocking operations (see 9.5.1), it is recommended that this
statement be implemented in a way that never requires the task executing
-the @emph{abort_statement} to block."
+the @emph{abort_statement} to block.”
@end quotation
Followed.
@quotation
-"On a multi-processor, the delay associated with aborting a task on
+“On a multi-processor, the delay associated with aborting a task on
another processor should be bounded; the implementation should use
-periodic polling, if necessary, to achieve this."
+periodic polling, if necessary, to achieve this.”
@end quotation
Followed.
@quotation
-"When feasible, the implementation should take advantage of the specified
-restrictions to produce a more efficient implementation."
+“When feasible, the implementation should take advantage of the specified
+restrictions to produce a more efficient implementation.”
@end quotation
GNAT currently takes advantage of these restrictions by providing an optimized
@quotation
-"When appropriate, implementations should provide configuration
-mechanisms to change the value of @code{Tick}."
+“When appropriate, implementations should provide configuration
+mechanisms to change the value of @code{Tick}.”
@end quotation
Such configuration mechanisms are not appropriate to this implementation
@quotation
-"It is recommended that @code{Calendar.Clock} and @code{Real_Time.Clock}
-be implemented as transformations of the same time base."
+“It is recommended that @code{Calendar.Clock} and @code{Real_Time.Clock}
+be implemented as transformations of the same time base.”
@end quotation
Followed.
@quotation
-"It is recommended that the best time base which exists in
+“It is recommended that the best time base which exists in
the underlying system be available to the application through
-@code{Clock}. @cite{Best} may mean highest accuracy or largest range."
+@code{Clock}. @cite{Best} may mean highest accuracy or largest range.”
@end quotation
Followed.
@quotation
-"Whenever possible, the PCS on the called partition should allow for
+“Whenever possible, the PCS on the called partition should allow for
multiple tasks to call the RPC-receiver with different messages and
should allow them to block until the corresponding subprogram body
-returns."
+returns.”
@end quotation
Followed by GLADE, a separately supplied PCS that can be used with
@quotation
-"The @code{Write} operation on a stream of type @code{Params_Stream_Type}
+“The @code{Write} operation on a stream of type @code{Params_Stream_Type}
should raise @code{Storage_Error} if it runs out of space trying to
-write the @code{Item} into the stream."
+write the @code{Item} into the stream.”
@end quotation
Followed by GLADE, a separately supplied PCS that can be used with
@quotation
-"If COBOL (respectively, C) is widely supported in the target
+“If COBOL (respectively, C) is widely supported in the target
environment, implementations supporting the Information Systems Annex
should provide the child package @code{Interfaces.COBOL} (respectively,
@code{Interfaces.C}) specified in Annex B and should support a
@code{convention_identifier} of COBOL (respectively, C) in the interfacing
pragmas (see Annex B), thus allowing Ada programs to interface with
-programs written in that language."
+programs written in that language.”
@end quotation
Followed.
@quotation
-"Packed decimal should be used as the internal representation for objects
-of subtype @code{S} when @code{S}'Machine_Radix = 10."
+“Packed decimal should be used as the internal representation for objects
+of subtype @code{S} when @code{S}’Machine_Radix = 10.”
@end quotation
-Not followed. GNAT ignores @code{S}'Machine_Radix and always uses binary
+Not followed. GNAT ignores @code{S}’Machine_Radix and always uses binary
representations.
@geindex Numerics
@quotation
-"If Fortran (respectively, C) is widely supported in the target
+“If Fortran (respectively, C) is widely supported in the target
environment, implementations supporting the Numerics Annex
should provide the child package @code{Interfaces.Fortran} (respectively,
@code{Interfaces.C}) specified in Annex B and should support a
@code{convention_identifier} of Fortran (respectively, C) in the interfacing
pragmas (see Annex B), thus allowing Ada programs to interface with
-programs written in that language."
+programs written in that language.”
@end quotation
Followed.
@quotation
-"Because the usual mathematical meaning of multiplication of a complex
+“Because the usual mathematical meaning of multiplication of a complex
operand and a real operand is that of the scaling of both components of
the former by the latter, an implementation should not perform this
operation by first promoting the real operand to complex type and then
that propagates into the final result.) Analogous advice applies in the
case of multiplication of a complex operand and a pure-imaginary
operand, and in the case of division of a complex operand by a real or
-pure-imaginary operand."
+pure-imaginary operand.”
@end quotation
Not followed.
@quotation
-"Similarly, because the usual mathematical meaning of addition of a
+“Similarly, because the usual mathematical meaning of addition of a
complex operand and a real operand is that the imaginary operand remains
unchanged, an implementation should not perform this operation by first
promoting the real operand to complex type and then performing a full
zero to the zero obtained during promotion yields a positive zero.)
Analogous advice applies in the case of addition of a complex operand
and a pure-imaginary operand, and in the case of subtraction of a
-complex operand and a real or pure-imaginary operand."
+complex operand and a real or pure-imaginary operand.”
@end quotation
Not followed.
@quotation
-"Implementations in which @code{Real'Signed_Zeros} is @code{True} should
+“Implementations in which @code{Real'Signed_Zeros} is @code{True} should
attempt to provide a rational treatment of the signs of zero results and
result components. As one example, the result of the @code{Argument}
function should have the sign of the imaginary component of the
of the @code{Compose_From_Polar} function should be the same as
(respectively, the opposite of) that of the @code{Argument} parameter when that
parameter has a value of zero and the @code{Modulus} parameter has a
-nonnegative (respectively, negative) value."
+nonnegative (respectively, negative) value.”
@end quotation
Followed.
@quotation
-"Implementations in which @code{Complex_Types.Real'Signed_Zeros} is
+“Implementations in which @code{Complex_Types.Real'Signed_Zeros} is
@code{True} should attempt to provide a rational treatment of the signs
of zero results and result components. For example, many of the complex
elementary functions have components that are odd functions of one of
have the sign of the parameter component at the origin. Other complex
elementary functions have zero components whose sign is opposite that of
a parameter component at the origin, or is always positive or always
-negative."
+negative.”
@end quotation
Followed.
@quotation
-"The versions of the forward trigonometric functions without a
+“The versions of the forward trigonometric functions without a
@code{Cycle} parameter should not be implemented by calling the
corresponding version with a @code{Cycle} parameter of
@code{2.0*Numerics.Pi}, since this will not provide the required
accuracy in some portions of the domain. For the same reason, the
version of @code{Log} without a @code{Base} parameter should not be
implemented by calling the corresponding version with a @code{Base}
-parameter of @code{Numerics.e}."
+parameter of @code{Numerics.e}.”
@end quotation
Followed.
@quotation
-"The version of the @code{Compose_From_Polar} function without a
+“The version of the @code{Compose_From_Polar} function without a
@code{Cycle} parameter should not be implemented by calling the
corresponding version with a @code{Cycle} parameter of
@code{2.0*Numerics.Pi}, since this will not provide the required
-accuracy in some portions of the domain."
+accuracy in some portions of the domain.”
@end quotation
Followed.
@quotation
-"If the partition elaboration policy is @code{Sequential} and the
+“If the partition elaboration policy is @code{Sequential} and the
Environment task becomes permanently blocked during elaboration then the
partition is deadlocked and it is recommended that the partition be
-immediately terminated."
+immediately terminated.”
@end quotation
Not followed.
@node Implementation Defined Characteristics,Intrinsic Subprograms,Implementation Advice,Top
-@anchor{gnat_rm/implementation_defined_characteristics implementation-defined-characteristics}@anchor{b}@anchor{gnat_rm/implementation_defined_characteristics doc}@anchor{258}@anchor{gnat_rm/implementation_defined_characteristics id1}@anchor{259}
+@anchor{gnat_rm/implementation_defined_characteristics doc}@anchor{258}@anchor{gnat_rm/implementation_defined_characteristics id1}@anchor{259}@anchor{gnat_rm/implementation_defined_characteristics implementation-defined-characteristics}@anchor{b}
@chapter Implementation Defined Characteristics
@itemize *
@item
-"Whether or not each recommendation given in Implementation
-Advice is followed. See 1.1.2(37)."
+“Whether or not each recommendation given in Implementation
+Advice is followed. See 1.1.2(37).”
@end itemize
See @ref{a,,Implementation Advice}.
@itemize *
@item
-"Capacity limitations of the implementation. See 1.1.3(3)."
+“Capacity limitations of the implementation. See 1.1.3(3).”
@end itemize
The complexity of programs that can be processed is limited only by the
@itemize *
@item
-"Variations from the standard that are impractical to avoid
-given the implementation's execution environment. See 1.1.3(6)."
+“Variations from the standard that are impractical to avoid
+given the implementation’s execution environment. See 1.1.3(6).”
@end itemize
There are no variations from the standard.
@itemize *
@item
-"Which code_statements cause external
-interactions. See 1.1.3(10)."
+“Which code_statements cause external
+interactions. See 1.1.3(10).”
@end itemize
Any @emph{code_statement} can potentially cause external interactions.
@itemize *
@item
-"The coded representation for the text of an Ada
-program. See 2.1(4)."
+“The coded representation for the text of an Ada
+program. See 2.1(4).”
@end itemize
See separate section on source representation.
@itemize *
@item
-"The control functions allowed in comments. See 2.1(14)."
+“The control functions allowed in comments. See 2.1(14).”
@end itemize
See separate section on source representation.
@itemize *
@item
-"The representation for an end of line. See 2.2(2)."
+“The representation for an end of line. See 2.2(2).”
@end itemize
See separate section on source representation.
@itemize *
@item
-"Maximum supported line length and lexical element
-length. See 2.2(15)."
+“Maximum supported line length and lexical element
+length. See 2.2(15).”
@end itemize
The maximum line length is 255 characters and the maximum length of
@itemize *
@item
-"Implementation defined pragmas. See 2.8(14)."
+“Implementation defined pragmas. See 2.8(14).”
@end itemize
See @ref{7,,Implementation Defined Pragmas}.
@itemize *
@item
-"Effect of pragma @code{Optimize}. See 2.8(27)."
+“Effect of pragma @code{Optimize}. See 2.8(27).”
@end itemize
Pragma @code{Optimize}, if given with a @code{Time} or @code{Space}
@itemize *
@item
-"The sequence of characters of the value returned by
+“The sequence of characters of the value returned by
@code{S'Image} when some of the graphic characters of
@code{S'Wide_Image} are not defined in @code{Character}. See
-3.5(37)."
+3.5(37).”
@end itemize
The sequence of characters is as defined by the wide character encoding
@itemize *
@item
-"The predefined integer types declared in
-@code{Standard}. See 3.5.4(25)."
+“The predefined integer types declared in
+@code{Standard}. See 3.5.4(25).”
@end itemize
@itemize *
@item
-"Any nonstandard integer types and the operators defined
-for them. See 3.5.4(26)."
+“Any nonstandard integer types and the operators defined
+for them. See 3.5.4(26).”
@end itemize
There are no nonstandard integer types.
@itemize *
@item
-"Any nonstandard real types and the operators defined for
-them. See 3.5.6(8)."
+“Any nonstandard real types and the operators defined for
+them. See 3.5.6(8).”
@end itemize
There are no nonstandard real types.
@itemize *
@item
-"What combinations of requested decimal precision and range
-are supported for floating point types. See 3.5.7(7)."
+“What combinations of requested decimal precision and range
+are supported for floating point types. See 3.5.7(7).”
@end itemize
The precision and range are defined by the IEEE Standard for Floating-Point
@itemize *
@item
-"The predefined floating point types declared in
-@code{Standard}. See 3.5.7(16)."
+“The predefined floating point types declared in
+@code{Standard}. See 3.5.7(16).”
@end itemize
@itemize *
@item
-"The small of an ordinary fixed point type. See 3.5.9(8)."
+“The small of an ordinary fixed point type. See 3.5.9(8).”
@end itemize
The small is the largest power of two that does not exceed the delta.
@itemize *
@item
-"What combinations of small, range, and digits are
-supported for fixed point types. See 3.5.9(10)."
+“What combinations of small, range, and digits are
+supported for fixed point types. See 3.5.9(10).”
@end itemize
For an ordinary fixed point type, on 32-bit platforms, the small must lie in
@itemize *
@item
-"The result of @code{Tags.Expanded_Name} for types declared
-within an unnamed @emph{block_statement}. See 3.9(10)."
+“The result of @code{Tags.Expanded_Name} for types declared
+within an unnamed @emph{block_statement}. See 3.9(10).”
@end itemize
Block numbers of the form @code{B@emph{nnn}}, where @emph{nnn} is a
@itemize *
@item
-"Implementation-defined attributes. See 4.1.4(12)."
+“Implementation-defined attributes. See 4.1.4(12).”
@end itemize
See @ref{8,,Implementation Defined Attributes}.
@itemize *
@item
-"Any implementation-defined time types. See 9.6(6)."
+“Any implementation-defined time types. See 9.6(6).”
@end itemize
There are no implementation-defined time types.
@itemize *
@item
-"The time base associated with relative delays."
+“The time base associated with relative delays.”
@end itemize
See 9.6(20). The time base used is that provided by the C library
@itemize *
@item
-"The time base of the type @code{Calendar.Time}. See
-9.6(23)."
+“The time base of the type @code{Calendar.Time}. See
+9.6(23).”
@end itemize
The time base used is that provided by the C library function
@itemize *
@item
-"The time zone used for package @code{Calendar}
-operations. See 9.6(24)."
+“The time zone used for package @code{Calendar}
+operations. See 9.6(24).”
@end itemize
The time zone used by package @code{Calendar} is the current system time zone
@itemize *
@item
-"Any limit on @emph{delay_until_statements} of
-@emph{select_statements}. See 9.6(29)."
+“Any limit on @emph{delay_until_statements} of
+@emph{select_statements}. See 9.6(29).”
@end itemize
There are no such limits.
@itemize *
@item
-"Whether or not two non-overlapping parts of a composite
+“Whether or not two non-overlapping parts of a composite
object are independently addressable, in the case where packing, record
layout, or @code{Component_Size} is specified for the object. See
-9.10(1)."
+9.10(1).”
@end itemize
Separate components are independently addressable if they do not share
@itemize *
@item
-"The representation for a compilation. See 10.1(2)."
+“The representation for a compilation. See 10.1(2).”
@end itemize
A compilation is represented by a sequence of files presented to the
@itemize *
@item
-"Any restrictions on compilations that contain multiple
-compilation_units. See 10.1(4)."
+“Any restrictions on compilations that contain multiple
+compilation_units. See 10.1(4).”
@end itemize
No single file can contain more than one compilation unit, but any
@itemize *
@item
-"The mechanisms for creating an environment and for adding
-and replacing compilation units. See 10.1.4(3)."
+“The mechanisms for creating an environment and for adding
+and replacing compilation units. See 10.1.4(3).”
@end itemize
See separate section on compilation model.
@itemize *
@item
-"The manner of explicitly assigning library units to a
-partition. See 10.2(2)."
+“The manner of explicitly assigning library units to a
+partition. See 10.2(2).”
@end itemize
If a unit contains an Ada main program, then the Ada units for the partition
inclusion in the partition (all units needed by these units will also
be included automatically). For full details on the use of these
options, refer to @emph{GNAT Make Program gnatmake} in the
-@cite{GNAT User's Guide}.
+@cite{GNAT User’s Guide}.
@itemize *
@item
-"The implementation-defined means, if any, of specifying
+“The implementation-defined means, if any, of specifying
which compilation units are needed by a given compilation unit. See
-10.2(2)."
+10.2(2).”
@end itemize
The units needed by a given compilation unit are as defined in
@itemize *
@item
-"The manner of designating the main subprogram of a
-partition. See 10.2(7)."
+“The manner of designating the main subprogram of a
+partition. See 10.2(7).”
@end itemize
The main program is designated by providing the name of the
@itemize *
@item
-"The order of elaboration of @emph{library_items}. See
-10.2(18)."
+“The order of elaboration of @emph{library_items}. See
+10.2(18).”
@end itemize
The first constraint on ordering is that it meets the requirements of
@itemize *
@item
-"Parameter passing and function return for the main
-subprogram. See 10.2(21)."
+“Parameter passing and function return for the main
+subprogram. See 10.2(21).”
@end itemize
The main program has no parameters. It may be a procedure, or a function
@itemize *
@item
-"The mechanisms for building and running partitions. See
-10.2(24)."
+“The mechanisms for building and running partitions. See
+10.2(24).”
@end itemize
GNAT itself supports programs with only a single partition. The GNATDIST
@itemize *
@item
-"The details of program execution, including program
-termination. See 10.2(25)."
+“The details of program execution, including program
+termination. See 10.2(25).”
@end itemize
See separate section on compilation model.
@itemize *
@item
-"The semantics of any non-active partitions supported by the
-implementation. See 10.2(28)."
+“The semantics of any non-active partitions supported by the
+implementation. See 10.2(28).”
@end itemize
Passive partitions are supported on targets where shared memory is
@itemize *
@item
-"The information returned by @code{Exception_Message}. See
-11.4.1(10)."
+“The information returned by @code{Exception_Message}. See
+11.4.1(10).”
@end itemize
Exception message returns the null string unless a specific message has
@itemize *
@item
-"The result of @code{Exceptions.Exception_Name} for types
-declared within an unnamed @emph{block_statement}. See 11.4.1(12)."
+“The result of @code{Exceptions.Exception_Name} for types
+declared within an unnamed @emph{block_statement}. See 11.4.1(12).”
@end itemize
Blocks have implementation defined names of the form @code{B@emph{nnn}}
@itemize *
@item
-"The information returned by
-@code{Exception_Information}. See 11.4.1(13)."
+“The information returned by
+@code{Exception_Information}. See 11.4.1(13).”
@end itemize
@code{Exception_Information} returns a string in the following format:
The Load address line, the Call stack traceback locations line and the
following values are present only if at least one traceback location was
recorded. The Load address indicates the address at which the main executable
-was loaded; this line may not be present if operating system hasn't relocated
+was loaded; this line may not be present if operating system hasn’t relocated
the main executable. The values are given in C style format, with lower case
letters for a-f, and only as many digits present as are necessary.
The line terminator sequence at the end of each line, including
@itemize *
@item
-"Implementation-defined check names. See 11.5(27)."
+“Implementation-defined check names. See 11.5(27).”
@end itemize
The implementation defined check names include Alignment_Check,
@itemize *
@item
-"The interpretation of each aspect of representation. See
-13.1(20)."
+“The interpretation of each aspect of representation. See
+13.1(20).”
@end itemize
See separate section on data representations.
@itemize *
@item
-"Any restrictions placed upon representation items. See
-13.1(20)."
+“Any restrictions placed upon representation items. See
+13.1(20).”
@end itemize
See separate section on data representations.
@itemize *
@item
-"The meaning of @code{Size} for indefinite subtypes. See
-13.3(48)."
+“The meaning of @code{Size} for indefinite subtypes. See
+13.3(48).”
@end itemize
Size for an indefinite subtype is the maximum possible size, except that
@itemize *
@item
-"The default external representation for a type tag. See
-13.3(75)."
+“The default external representation for a type tag. See
+13.3(75).”
@end itemize
The default external representation for a type tag is the fully expanded
@itemize *
@item
-"What determines whether a compilation unit is the same in
-two different partitions. See 13.3(76)."
+“What determines whether a compilation unit is the same in
+two different partitions. See 13.3(76).”
@end itemize
A compilation unit is the same in two different partitions if and only
@itemize *
@item
-"Implementation-defined components. See 13.5.1(15)."
+“Implementation-defined components. See 13.5.1(15).”
@end itemize
The only implementation defined component is the tag for a tagged type,
@itemize *
@item
-"If @code{Word_Size} = @code{Storage_Unit}, the default bit
-ordering. See 13.5.3(5)."
+“If @code{Word_Size} = @code{Storage_Unit}, the default bit
+ordering. See 13.5.3(5).”
@end itemize
@code{Word_Size} (32) is not the same as @code{Storage_Unit} (8) for this
@itemize *
@item
-"The contents of the visible part of package @code{System}
-and its language-defined children. See 13.7(2)."
+“The contents of the visible part of package @code{System}
+and its language-defined children. See 13.7(2).”
@end itemize
See the definition of these packages in files @code{system.ads} and
@itemize *
@item
-"The contents of the visible part of package
+“The contents of the visible part of package
@code{System.Machine_Code}, and the meaning of
-@emph{code_statements}. See 13.8(7)."
+@emph{code_statements}. See 13.8(7).”
@end itemize
See the definition and documentation in file @code{s-maccod.ads}.
@itemize *
@item
-"The effect of unchecked conversion. See 13.9(11)."
+“The effect of unchecked conversion. See 13.9(11).”
@end itemize
Unchecked conversion between types of the same size
@itemize *
@item
-"The semantics of operations on invalid representations.
-See 13.9.2(10-11)."
+“The semantics of operations on invalid representations.
+See 13.9.2(10-11).”
@end itemize
For assignments and other operations where the use of invalid values cannot
@itemize *
@item
-"The manner of choosing a storage pool for an access type
-when @code{Storage_Pool} is not specified for the type. See 13.11(17)."
+“The manner of choosing a storage pool for an access type
+when @code{Storage_Pool} is not specified for the type. See 13.11(17).”
@end itemize
There are 3 different standard pools used by the compiler when
@itemize *
@item
-"Whether or not the implementation provides user-accessible
-names for the standard pool type(s). See 13.11(17)."
+“Whether or not the implementation provides user-accessible
+names for the standard pool type(s). See 13.11(17).”
@end itemize
See documentation in the sources of the run time mentioned in the previous
@itemize *
@item
-"The meaning of @code{Storage_Size}. See 13.11(18)."
+“The meaning of @code{Storage_Size}. See 13.11(18).”
@end itemize
@code{Storage_Size} is measured in storage units, and refers to the
@itemize *
@item
-"Implementation-defined aspects of storage pools. See
-13.11(22)."
+“Implementation-defined aspects of storage pools. See
+13.11(22).”
@end itemize
See documentation in the sources of the run time mentioned in the
@itemize *
@item
-"The set of restrictions allowed in a pragma
-@code{Restrictions}. See 13.12(7)."
+“The set of restrictions allowed in a pragma
+@code{Restrictions}. See 13.12(7).”
@end itemize
See @ref{9,,Standard and Implementation Defined Restrictions}.
@itemize *
@item
-"The consequences of violating limitations on
-@code{Restrictions} pragmas. See 13.12(9)."
+“The consequences of violating limitations on
+@code{Restrictions} pragmas. See 13.12(9).”
@end itemize
Restrictions that can be checked at compile time result in illegalities
@itemize *
@item
-"The representation used by the @code{Read} and
+“The representation used by the @code{Read} and
@code{Write} attributes of elementary types in terms of stream
-elements. See 13.13.2(9)."
+elements. See 13.13.2(9).”
@end itemize
The representation is the in-memory representation of the base type of
@itemize *
@item
-"The names and characteristics of the numeric subtypes
-declared in the visible part of package @code{Standard}. See A.1(3)."
+“The names and characteristics of the numeric subtypes
+declared in the visible part of package @code{Standard}. See A.1(3).”
@end itemize
See items describing the integer and floating-point types supported.
@itemize *
@item
-"The string returned by @code{Character_Set_Version}.
-See A.3.5(3)."
+“The string returned by @code{Character_Set_Version}.
+See A.3.5(3).”
@end itemize
@code{Ada.Wide_Characters.Handling.Character_Set_Version} returns
-the string "Unicode 4.0", referring to version 4.0 of the
+the string “Unicode 4.0”, referring to version 4.0 of the
Unicode specification.
@itemize *
@item
-"The accuracy actually achieved by the elementary
-functions. See A.5.1(1)."
+“The accuracy actually achieved by the elementary
+functions. See A.5.1(1).”
@end itemize
The elementary functions correspond to the functions available in the C
@itemize *
@item
-"The sign of a zero result from some of the operators or
+“The sign of a zero result from some of the operators or
functions in @code{Numerics.Generic_Elementary_Functions}, when
-@code{Float_Type'Signed_Zeros} is @code{True}. See A.5.1(46)."
+@code{Float_Type'Signed_Zeros} is @code{True}. See A.5.1(46).”
@end itemize
The sign of zeroes follows the requirements of the IEEE 754 standard on
@itemize *
@item
-"The value of
-@code{Numerics.Float_Random.Max_Image_Width}. See A.5.2(27)."
+“The value of
+@code{Numerics.Float_Random.Max_Image_Width}. See A.5.2(27).”
@end itemize
Maximum image width is 6864, see library file @code{s-rannum.ads}.
@itemize *
@item
-"The value of
-@code{Numerics.Discrete_Random.Max_Image_Width}. See A.5.2(27)."
+“The value of
+@code{Numerics.Discrete_Random.Max_Image_Width}. See A.5.2(27).”
@end itemize
Maximum image width is 6864, see library file @code{s-rannum.ads}.
@itemize *
@item
-"The algorithms for random number generation. See
-A.5.2(32)."
+“The algorithms for random number generation. See
+A.5.2(32).”
@end itemize
The algorithm is the Mersenne Twister, as documented in the source file
@itemize *
@item
-"The string representation of a random number generator's
-state. See A.5.2(38)."
+“The string representation of a random number generator’s
+state. See A.5.2(38).”
@end itemize
The value returned by the Image function is the concatenation of
@itemize *
@item
-"The minimum time interval between calls to the
+“The minimum time interval between calls to the
time-dependent Reset procedure that are guaranteed to initiate different
-random number sequences. See A.5.2(45)."
+random number sequences. See A.5.2(45).”
@end itemize
The minimum period between reset calls to guarantee distinct series of
@itemize *
@item
-"The values of the @code{Model_Mantissa},
+“The values of the @code{Model_Mantissa},
@code{Model_Emin}, @code{Model_Epsilon}, @code{Model},
@code{Safe_First}, and @code{Safe_Last} attributes, if the Numerics
-Annex is not supported. See A.5.3(72)."
+Annex is not supported. See A.5.3(72).”
@end itemize
Run the compiler with @emph{-gnatS} to produce a listing of package
@itemize *
@item
-"Any implementation-defined characteristics of the
-input-output packages. See A.7(14)."
+“Any implementation-defined characteristics of the
+input-output packages. See A.7(14).”
@end itemize
There are no special implementation defined characteristics for these
@itemize *
@item
-"The value of @code{Buffer_Size} in @code{Storage_IO}. See
-A.9(10)."
+“The value of @code{Buffer_Size} in @code{Storage_IO}. See
+A.9(10).”
@end itemize
All type representations are contiguous, and the @code{Buffer_Size} is
@itemize *
@item
-"External files for standard input, standard output, and
-standard error See A.10(5)."
+“External files for standard input, standard output, and
+standard error See A.10(5).”
@end itemize
These files are mapped onto the files provided by the C streams
@itemize *
@item
-"The accuracy of the value produced by @code{Put}. See
-A.10.9(36)."
+“The accuracy of the value produced by @code{Put}. See
+A.10.9(36).”
@end itemize
If more digits are requested in the output than are represented by the
@itemize *
@item
-"The meaning of @code{Argument_Count}, @code{Argument}, and
-@code{Command_Name}. See A.15(1)."
+“The meaning of @code{Argument_Count}, @code{Argument}, and
+@code{Command_Name}. See A.15(1).”
@end itemize
These are mapped onto the @code{argv} and @code{argc} parameters of the
@itemize *
@item
-"The interpretation of the @code{Form} parameter in procedure
-@code{Create_Directory}. See A.16(56)."
+“The interpretation of the @code{Form} parameter in procedure
+@code{Create_Directory}. See A.16(56).”
@end itemize
The @code{Form} parameter is not used.
@itemize *
@item
-"The interpretation of the @code{Form} parameter in procedure
-@code{Create_Path}. See A.16(60)."
+“The interpretation of the @code{Form} parameter in procedure
+@code{Create_Path}. See A.16(60).”
@end itemize
The @code{Form} parameter is not used.
@itemize *
@item
-"The interpretation of the @code{Form} parameter in procedure
-@code{Copy_File}. See A.16(68)."
+“The interpretation of the @code{Form} parameter in procedure
+@code{Copy_File}. See A.16(68).”
@end itemize
The @code{Form} parameter is case-insensitive.
*mode=<value>*
@end example
-<value> starts immediately after the character '=' and ends with the
-character immediately preceding the next comma (',') or with the last
+<value> starts immediately after the character ‘=’ and ends with the
+character immediately preceding the next comma (‘,’) or with the last
character of the parameter.
The only possible values for preserve= are:
@itemize *
@item
-"The interpretation of the @code{Pattern} parameter, when not the null string,
+“The interpretation of the @code{Pattern} parameter, when not the null string,
in the @code{Start_Search} and @code{Search} procedures.
-See A.16(104) and A.16(112)."
+See A.16(104) and A.16(112).”
@end itemize
When the @code{Pattern} parameter is not the null string, it is interpreted
@itemize *
@item
-"Implementation-defined convention names. See B.1(11)."
+“Implementation-defined convention names. See B.1(11).”
@end itemize
The following convention names are supported
@itemize *
@item
-"The meaning of link names. See B.1(36)."
+“The meaning of link names. See B.1(36).”
@end itemize
Link names are the actual names used by the linker.
@itemize *
@item
-"The manner of choosing link names when neither the link
+“The manner of choosing link names when neither the link
name nor the address of an imported or exported entity is specified. See
-B.1(36)."
+B.1(36).”
@end itemize
The default linker name is that which would be assigned by the relevant
@itemize *
@item
-"The effect of pragma @code{Linker_Options}. See B.1(37)."
+“The effect of pragma @code{Linker_Options}. See B.1(37).”
@end itemize
The string passed to @code{Linker_Options} is presented uninterpreted as
@itemize *
@item
-"The contents of the visible part of package
-@code{Interfaces} and its language-defined descendants. See B.2(1)."
+“The contents of the visible part of package
+@code{Interfaces} and its language-defined descendants. See B.2(1).”
@end itemize
See files with prefix @code{i-} in the distributed library.
@itemize *
@item
-"Implementation-defined children of package
+“Implementation-defined children of package
@code{Interfaces}. The contents of the visible part of package
-@code{Interfaces}. See B.2(11)."
+@code{Interfaces}. See B.2(11).”
@end itemize
See files with prefix @code{i-} in the distributed library.
@itemize *
@item
-"The types @code{Floating}, @code{Long_Floating},
+“The types @code{Floating}, @code{Long_Floating},
@code{Binary}, @code{Long_Binary}, @code{Decimal_ Element}, and
@code{COBOL_Character}; and the initialization of the variables
@code{Ada_To_COBOL} and @code{COBOL_To_Ada}, in
-@code{Interfaces.COBOL}. See B.4(50)."
+@code{Interfaces.COBOL}. See B.4(50).”
@end itemize
@itemize *
@item
-"Support for access to machine instructions. See C.1(1)."
+“Support for access to machine instructions. See C.1(1).”
@end itemize
See documentation in file @code{s-maccod.ads} in the distributed library.
@itemize *
@item
-"Implementation-defined aspects of access to machine
-operations. See C.1(9)."
+“Implementation-defined aspects of access to machine
+operations. See C.1(9).”
@end itemize
See documentation in file @code{s-maccod.ads} in the distributed library.
@itemize *
@item
-"Implementation-defined aspects of interrupts. See C.3(2)."
+“Implementation-defined aspects of interrupts. See C.3(2).”
@end itemize
Interrupts are mapped to signals or conditions as appropriate. See
@itemize *
@item
-"Implementation-defined aspects of pre-elaboration. See
-C.4(13)."
+“Implementation-defined aspects of pre-elaboration. See
+C.4(13).”
@end itemize
GNAT does not permit a partition to be restarted without reloading,
@itemize *
@item
-"The semantics of pragma @code{Discard_Names}. See C.5(7)."
+“The semantics of pragma @code{Discard_Names}. See C.5(7).”
@end itemize
Pragma @code{Discard_Names} causes names of enumeration literals to
@itemize *
@item
-"The result of the @code{Task_Identification.Image}
-attribute. See C.7.1(7)."
+“The result of the @code{Task_Identification.Image}
+attribute. See C.7.1(7).”
@end itemize
The result of this attribute is a string that identifies
@itemize *
@item
-"The value of @code{Current_Task} when in a protected entry
-or interrupt handler. See C.7.1(17)."
+“The value of @code{Current_Task} when in a protected entry
+or interrupt handler. See C.7.1(17).”
@end itemize
Protected entries or interrupt handlers can be executed by any
@itemize *
@item
-"The effect of calling @code{Current_Task} from an entry
-body or interrupt handler. See C.7.1(19)."
+“The effect of calling @code{Current_Task} from an entry
+body or interrupt handler. See C.7.1(19).”
@end itemize
When GNAT can determine statically that @code{Current_Task} is called directly in
@itemize *
@item
-"Implementation-defined aspects of
-@code{Task_Attributes}. See C.7.2(19)."
+“Implementation-defined aspects of
+@code{Task_Attributes}. See C.7.2(19).”
@end itemize
There are no implementation-defined aspects of @code{Task_Attributes}.
@itemize *
@item
-"Values of all @code{Metrics}. See D(2)."
+“Values of all @code{Metrics}. See D(2).”
@end itemize
The metrics information for GNAT depends on the performance of the
@itemize *
@item
-"The declarations of @code{Any_Priority} and
-@code{Priority}. See D.1(11)."
+“The declarations of @code{Any_Priority} and
+@code{Priority}. See D.1(11).”
@end itemize
See declarations in file @code{system.ads}.
@itemize *
@item
-"Implementation-defined execution resources. See D.1(15)."
+“Implementation-defined execution resources. See D.1(15).”
@end itemize
There are no implementation-defined execution resources.
@itemize *
@item
-"Whether, on a multiprocessor, a task that is waiting for
-access to a protected object keeps its processor busy. See D.2.1(3)."
+“Whether, on a multiprocessor, a task that is waiting for
+access to a protected object keeps its processor busy. See D.2.1(3).”
@end itemize
On a multi-processor, a task that is waiting for access to a protected
@itemize *
@item
-"The affect of implementation defined execution resources
-on task dispatching. See D.2.1(9)."
+“The affect of implementation defined execution resources
+on task dispatching. See D.2.1(9).”
@end itemize
Tasks map to threads in the threads package used by GNAT. Where possible
@itemize *
@item
-"Implementation-defined @emph{policy_identifiers} allowed
-in a pragma @code{Task_Dispatching_Policy}. See D.2.2(3)."
+“Implementation-defined @emph{policy_identifiers} allowed
+in a pragma @code{Task_Dispatching_Policy}. See D.2.2(3).”
@end itemize
There are no implementation-defined policy-identifiers allowed in this
@itemize *
@item
-"Implementation-defined aspects of priority inversion. See
-D.2.2(16)."
+“Implementation-defined aspects of priority inversion. See
+D.2.2(16).”
@end itemize
Execution of a task cannot be preempted by the implementation processing
@itemize *
@item
-"Implementation-defined task dispatching. See D.2.2(18)."
+“Implementation-defined task dispatching. See D.2.2(18).”
@end itemize
The policy is the same as that of the underlying threads implementation.
@itemize *
@item
-"Implementation-defined @emph{policy_identifiers} allowed
-in a pragma @code{Locking_Policy}. See D.3(4)."
+“Implementation-defined @emph{policy_identifiers} allowed
+in a pragma @code{Locking_Policy}. See D.3(4).”
@end itemize
The two implementation defined policies permitted in GNAT are
@itemize *
@item
-"Default ceiling priorities. See D.3(10)."
+“Default ceiling priorities. See D.3(10).”
@end itemize
The ceiling priority of protected objects of the type
@itemize *
@item
-"The ceiling of any protected object used internally by
-the implementation. See D.3(16)."
+“The ceiling of any protected object used internally by
+the implementation. See D.3(16).”
@end itemize
The ceiling priority of internal protected objects is
@itemize *
@item
-"Implementation-defined queuing policies. See D.4(1)."
+“Implementation-defined queuing policies. See D.4(1).”
@end itemize
There are no implementation-defined queuing policies.
@itemize *
@item
-"On a multiprocessor, any conditions that cause the
+“On a multiprocessor, any conditions that cause the
completion of an aborted construct to be delayed later than what is
-specified for a single processor. See D.6(3)."
+specified for a single processor. See D.6(3).”
@end itemize
The semantics for abort on a multi-processor is the same as on a single
@itemize *
@item
-"Any operations that implicitly require heap storage
-allocation. See D.7(8)."
+“Any operations that implicitly require heap storage
+allocation. See D.7(8).”
@end itemize
The only operation that implicitly requires heap storage allocation is
@itemize *
@item
-"What happens when a task terminates in the presence of
-pragma @code{No_Task_Termination}. See D.7(15)."
+“What happens when a task terminates in the presence of
+pragma @code{No_Task_Termination}. See D.7(15).”
@end itemize
Execution is erroneous in that case.
@itemize *
@item
-"Implementation-defined aspects of pragma
-@code{Restrictions}. See D.7(20)."
+“Implementation-defined aspects of pragma
+@code{Restrictions}. See D.7(20).”
@end itemize
There are no such implementation-defined aspects.
@itemize *
@item
-"Implementation-defined aspects of package
-@code{Real_Time}. See D.8(17)."
+“Implementation-defined aspects of package
+@code{Real_Time}. See D.8(17).”
@end itemize
There are no implementation defined aspects of package @code{Real_Time}.
@itemize *
@item
-"Implementation-defined aspects of
-@emph{delay_statements}. See D.9(8)."
+“Implementation-defined aspects of
+@emph{delay_statements}. See D.9(8).”
@end itemize
Any difference greater than one microsecond will cause the task to be
@itemize *
@item
-"The upper bound on the duration of interrupt blocking
-caused by the implementation. See D.12(5)."
+“The upper bound on the duration of interrupt blocking
+caused by the implementation. See D.12(5).”
@end itemize
The upper bound is determined by the underlying operating system. In
@itemize *
@item
-"The means for creating and executing distributed
-programs. See E(5)."
+“The means for creating and executing distributed
+programs. See E(5).”
@end itemize
The GLADE package provides a utility GNATDIST for creating and executing
@itemize *
@item
-"Any events that can result in a partition becoming
-inaccessible. See E.1(7)."
+“Any events that can result in a partition becoming
+inaccessible. See E.1(7).”
@end itemize
See the GLADE reference manual for full details on such events.
@itemize *
@item
-"The scheduling policies, treatment of priorities, and
+“The scheduling policies, treatment of priorities, and
management of shared resources between partitions in certain cases. See
-E.1(11)."
+E.1(11).”
@end itemize
See the GLADE reference manual for full details on these aspects of
@itemize *
@item
-"Events that cause the version of a compilation unit to
-change. See E.3(5)."
+“Events that cause the version of a compilation unit to
+change. See E.3(5).”
@end itemize
Editing the source file of a compilation unit, or the source files of
@itemize *
@item
-"Whether the execution of the remote subprogram is
-immediately aborted as a result of cancellation. See E.4(13)."
+“Whether the execution of the remote subprogram is
+immediately aborted as a result of cancellation. See E.4(13).”
@end itemize
See the GLADE reference manual for details on the effect of abort in
@itemize *
@item
-"Implementation-defined aspects of the PCS. See E.5(25)."
+“Implementation-defined aspects of the PCS. See E.5(25).”
@end itemize
See the GLADE reference manual for a full description of all implementation
@itemize *
@item
-"Implementation-defined interfaces in the PCS. See
-E.5(26)."
+“Implementation-defined interfaces in the PCS. See
+E.5(26).”
@end itemize
See the GLADE reference manual for a full description of all
@itemize *
@item
-"The values of named numbers in the package
-@code{Decimal}. See F.2(7)."
+“The values of named numbers in the package
+@code{Decimal}. See F.2(7).”
@end itemize
@itemize *
@item
-"The value of @code{Max_Picture_Length} in the package
-@code{Text_IO.Editing}. See F.3.3(16)."
+“The value of @code{Max_Picture_Length} in the package
+@code{Text_IO.Editing}. See F.3.3(16).”
@end itemize
64
@itemize *
@item
-"The value of @code{Max_Picture_Length} in the package
-@code{Wide_Text_IO.Editing}. See F.3.4(5)."
+“The value of @code{Max_Picture_Length} in the package
+@code{Wide_Text_IO.Editing}. See F.3.4(5).”
@end itemize
64
@itemize *
@item
-"The accuracy actually achieved by the complex elementary
-functions and by other complex arithmetic operations. See G.1(1)."
+“The accuracy actually achieved by the complex elementary
+functions and by other complex arithmetic operations. See G.1(1).”
@end itemize
Standard library functions are used for the complex arithmetic
@itemize *
@item
-"The sign of a zero result (or a component thereof) from
+“The sign of a zero result (or a component thereof) from
any operator or function in @code{Numerics.Generic_Complex_Types}, when
-@code{Real'Signed_Zeros} is True. See G.1.1(53)."
+@code{Real'Signed_Zeros} is True. See G.1.1(53).”
@end itemize
The signs of zero values are as recommended by the relevant
@itemize *
@item
-"The sign of a zero result (or a component thereof) from
+“The sign of a zero result (or a component thereof) from
any operator or function in
@code{Numerics.Generic_Complex_Elementary_Functions}, when
-@code{Real'Signed_Zeros} is @code{True}. See G.1.2(45)."
+@code{Real'Signed_Zeros} is @code{True}. See G.1.2(45).”
@end itemize
The signs of zero values are as recommended by the relevant
@itemize *
@item
-"Whether the strict mode or the relaxed mode is the
-default. See G.2(2)."
+“Whether the strict mode or the relaxed mode is the
+default. See G.2(2).”
@end itemize
The strict mode is the default. There is no separate relaxed mode. GNAT
@itemize *
@item
-"The result interval in certain cases of fixed-to-float
-conversion. See G.2.1(10)."
+“The result interval in certain cases of fixed-to-float
+conversion. See G.2.1(10).”
@end itemize
For cases where the result interval is implementation dependent, the
@itemize *
@item
-"The result of a floating point arithmetic operation in
+“The result of a floating point arithmetic operation in
overflow situations, when the @code{Machine_Overflows} attribute of the
-result type is @code{False}. See G.2.1(13)."
+result type is @code{False}. See G.2.1(13).”
@end itemize
Infinite and NaN values are produced as dictated by the IEEE
@itemize *
@item
-"The result interval for division (or exponentiation by a
+“The result interval for division (or exponentiation by a
negative exponent), when the floating point hardware implements division
-as multiplication by a reciprocal. See G.2.1(16)."
+as multiplication by a reciprocal. See G.2.1(16).”
@end itemize
Not relevant, division is IEEE exact.
@itemize *
@item
-"The definition of close result set, which determines the
+“The definition of close result set, which determines the
accuracy of certain fixed point multiplications and divisions. See
-G.2.3(5)."
+G.2.3(5).”
@end itemize
Operations in the close result set are performed using IEEE long format
@itemize *
@item
-"Conditions on a @emph{universal_real} operand of a fixed
+“Conditions on a @emph{universal_real} operand of a fixed
point multiplication or division for which the result shall be in the
-perfect result set. See G.2.3(22)."
+perfect result set. See G.2.3(22).”
@end itemize
The result is only defined to be in the perfect result set if the result
@itemize *
@item
-"The result of a fixed point arithmetic operation in
+“The result of a fixed point arithmetic operation in
overflow situations, when the @code{Machine_Overflows} attribute of the
-result type is @code{False}. See G.2.3(27)."
+result type is @code{False}. See G.2.3(27).”
@end itemize
Not relevant, @code{Machine_Overflows} is @code{True} for fixed-point
@itemize *
@item
-"The result of an elementary function reference in
+“The result of an elementary function reference in
overflow situations, when the @code{Machine_Overflows} attribute of the
-result type is @code{False}. See G.2.4(4)."
+result type is @code{False}. See G.2.4(4).”
@end itemize
IEEE infinite and Nan values are produced as appropriate.
@itemize *
@item
-"The value of the angle threshold, within which certain
+“The value of the angle threshold, within which certain
elementary functions, complex arithmetic operations, and complex
elementary functions yield results conforming to a maximum relative
-error bound. See G.2.4(10)."
+error bound. See G.2.4(10).”
@end itemize
Information on this subject is not yet available.
@itemize *
@item
-"The accuracy of certain elementary functions for
-parameters beyond the angle threshold. See G.2.4(10)."
+“The accuracy of certain elementary functions for
+parameters beyond the angle threshold. See G.2.4(10).”
@end itemize
Information on this subject is not yet available.
@itemize *
@item
-"The result of a complex arithmetic operation or complex
+“The result of a complex arithmetic operation or complex
elementary function reference in overflow situations, when the
@code{Machine_Overflows} attribute of the corresponding real type is
-@code{False}. See G.2.6(5)."
+@code{False}. See G.2.6(5).”
@end itemize
IEEE infinite and Nan values are produced as appropriate.
@itemize *
@item
-"The accuracy of certain complex arithmetic operations and
+“The accuracy of certain complex arithmetic operations and
certain complex elementary functions for parameters (or components
-thereof) beyond the angle threshold. See G.2.6(8)."
+thereof) beyond the angle threshold. See G.2.6(8).”
@end itemize
Information on those subjects is not yet available.
@itemize *
@item
-"Information regarding bounded errors and erroneous
-execution. See H.2(1)."
+“Information regarding bounded errors and erroneous
+execution. See H.2(1).”
@end itemize
Information on this subject is not yet available.
@itemize *
@item
-"Implementation-defined aspects of pragma
-@code{Inspection_Point}. See H.3.2(8)."
+“Implementation-defined aspects of pragma
+@code{Inspection_Point}. See H.3.2(8).”
@end itemize
Pragma @code{Inspection_Point} ensures that the variable is live and can
@itemize *
@item
-"Implementation-defined aspects of pragma
-@code{Restrictions}. See H.4(25)."
+“Implementation-defined aspects of pragma
+@code{Restrictions}. See H.4(25).”
@end itemize
There are no implementation-defined aspects of pragma @code{Restrictions}. The
@itemize *
@item
-"Any restrictions on pragma @code{Restrictions}. See
-H.4(27)."
+“Any restrictions on pragma @code{Restrictions}. See
+H.4(27).”
@end itemize
There are no restrictions on pragma @code{Restrictions}.
@node Intrinsic Subprograms,Representation Clauses and Pragmas,Implementation Defined Characteristics,Top
-@anchor{gnat_rm/intrinsic_subprograms doc}@anchor{25b}@anchor{gnat_rm/intrinsic_subprograms intrinsic-subprograms}@anchor{c}@anchor{gnat_rm/intrinsic_subprograms id1}@anchor{25c}
+@anchor{gnat_rm/intrinsic_subprograms doc}@anchor{25b}@anchor{gnat_rm/intrinsic_subprograms id1}@anchor{25c}@anchor{gnat_rm/intrinsic_subprograms intrinsic-subprograms}@anchor{c}
@chapter Intrinsic Subprograms
pragma Import (Intrinsic, "+");
@end example
-This declaration would permit 'mixed mode' arithmetic on items
+This declaration would permit ‘mixed mode’ arithmetic on items
of the differing types @code{Int1} and @code{Int2}.
It is also possible to specify such operators for private types, if the
full views are appropriate arithmetic types.
@node Compilation_ISO_Date,Compilation_Date,Intrinsic Operators,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms id3}@anchor{25f}@anchor{gnat_rm/intrinsic_subprograms compilation-iso-date}@anchor{260}
+@anchor{gnat_rm/intrinsic_subprograms compilation-iso-date}@anchor{25f}@anchor{gnat_rm/intrinsic_subprograms id3}@anchor{260}
@section Compilation_ISO_Date
the current compilation (in local time format HH:MM:SS).
@node Enclosing_Entity,Exception_Information,Compilation_Time,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms id6}@anchor{265}@anchor{gnat_rm/intrinsic_subprograms enclosing-entity}@anchor{266}
+@anchor{gnat_rm/intrinsic_subprograms enclosing-entity}@anchor{265}@anchor{gnat_rm/intrinsic_subprograms id6}@anchor{266}
@section Enclosing_Entity
the current subprogram, package, task, entry, or protected subprogram.
@node Exception_Information,Exception_Message,Enclosing_Entity,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms id7}@anchor{267}@anchor{gnat_rm/intrinsic_subprograms exception-information}@anchor{268}
+@anchor{gnat_rm/intrinsic_subprograms exception-information}@anchor{267}@anchor{gnat_rm/intrinsic_subprograms id7}@anchor{268}
@section Exception_Information
the name of the current exception.
@node File,Line,Exception_Name,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms id10}@anchor{26d}@anchor{gnat_rm/intrinsic_subprograms file}@anchor{26e}
+@anchor{gnat_rm/intrinsic_subprograms file}@anchor{26d}@anchor{gnat_rm/intrinsic_subprograms id10}@anchor{26e}
@section File
source line.
@node Shifts and Rotates,Source_Location,Line,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms shifts-and-rotates}@anchor{271}@anchor{gnat_rm/intrinsic_subprograms id12}@anchor{272}
+@anchor{gnat_rm/intrinsic_subprograms id12}@anchor{271}@anchor{gnat_rm/intrinsic_subprograms shifts-and-rotates}@anchor{272}
@section Shifts and Rotates
The function name must be one of
Shift_Left, Shift_Right, Shift_Right_Arithmetic, Rotate_Left, or
-Rotate_Right. T must be an integer type. T'Size must be
+Rotate_Right. T must be an integer type. T’Size must be
8, 16, 32 or 64 bits; if T is modular, the modulus
must be 2**8, 2**16, 2**32 or 2**64.
The result type must be the same as the type of @code{Value}.
A more convenient way of providing these shift operators is to use the
Provide_Shift_Operators pragma, which provides the function declarations and
-corresponding pragma Import's for all five shift functions. For signed types
+corresponding pragma Import’s for all five shift functions. For signed types
the semantics of these operators is to interpret the bitwise result of the
corresponding operator for modular type. In particular, shifting a negative
number may change its sign bit to positive.
@node Source_Location,,Shifts and Rotates,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms source-location}@anchor{273}@anchor{gnat_rm/intrinsic_subprograms id13}@anchor{274}
+@anchor{gnat_rm/intrinsic_subprograms id13}@anchor{273}@anchor{gnat_rm/intrinsic_subprograms source-location}@anchor{274}
@section Source_Location
source file location.
@node Representation Clauses and Pragmas,Standard Library Routines,Intrinsic Subprograms,Top
-@anchor{gnat_rm/representation_clauses_and_pragmas representation-clauses-and-pragmas}@anchor{d}@anchor{gnat_rm/representation_clauses_and_pragmas doc}@anchor{275}@anchor{gnat_rm/representation_clauses_and_pragmas id1}@anchor{276}
+@anchor{gnat_rm/representation_clauses_and_pragmas doc}@anchor{275}@anchor{gnat_rm/representation_clauses_and_pragmas id1}@anchor{276}@anchor{gnat_rm/representation_clauses_and_pragmas representation-clauses-and-pragmas}@anchor{d}
@chapter Representation Clauses and Pragmas
@end menu
@node Alignment Clauses,Size Clauses,,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas id2}@anchor{277}@anchor{gnat_rm/representation_clauses_and_pragmas alignment-clauses}@anchor{278}
+@anchor{gnat_rm/representation_clauses_and_pragmas alignment-clauses}@anchor{277}@anchor{gnat_rm/representation_clauses_and_pragmas id2}@anchor{278}
@section Alignment Clauses
@quotation
-"A @code{Size} clause should be supported for an object if the specified
-@code{Size} is at least as large as its subtype's @code{Size}, and corresponds
-to a size in storage elements that is a multiple of the object's
-@code{Alignment} (if the @code{Alignment} is nonzero)."
+“A @code{Size} clause should be supported for an object if the specified
+@code{Size} is at least as large as its subtype’s @code{Size}, and corresponds
+to a size in storage elements that is a multiple of the object’s
+@code{Alignment} (if the @code{Alignment} is nonzero).”
@end quotation
An explicit size clause may be used to override the default size by
type Integer.
@node Storage_Size Clauses,Size of Variant Record Objects,Size Clauses,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas storage-size-clauses}@anchor{27b}@anchor{gnat_rm/representation_clauses_and_pragmas id4}@anchor{27c}
+@anchor{gnat_rm/representation_clauses_and_pragmas id4}@anchor{27b}@anchor{gnat_rm/representation_clauses_and_pragmas storage-size-clauses}@anchor{27c}
@section Storage_Size Clauses
variant value.
@node Biased Representation,Value_Size and Object_Size Clauses,Size of Variant Record Objects,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas id6}@anchor{27f}@anchor{gnat_rm/representation_clauses_and_pragmas biased-representation}@anchor{280}
+@anchor{gnat_rm/representation_clauses_and_pragmas biased-representation}@anchor{27f}@anchor{gnat_rm/representation_clauses_and_pragmas id6}@anchor{280}
@section Biased Representation
The @code{Object_Size} is used for determining the default size of
objects and components. This size value can be referred to using the
-@code{Object_Size} attribute. The phrase 'is used' here means that it is
+@code{Object_Size} attribute. The phrase ‘is used’ here means that it is
the basis of the determination of the size. The backend is free to
pad this up if necessary for efficiency, e.g., an 8-bit stand-alone
character might be stored in 32 bits on a machine with no efficient
@item
If a subtype statically matches the first subtype of a given type, then it has
by default the same @code{Value_Size} as the first subtype. This is a
-consequence of RM 13.1(14): "if two subtypes statically match,
-then their subtype-specific aspects are the same".)
+consequence of RM 13.1(14): “if two subtypes statically match,
+then their subtype-specific aspects are the same”.)
@item
All other subtypes have a @code{Value_Size} corresponding to the minimum
@end multitable
-Note: the entries marked '*' are not actually specified by the Ada
+Note: the entries marked ‘*’ are not actually specified by the Ada
Reference Manual, which has nothing to say about size in the dynamic
case. What GNAT does is to allocate sufficient bits to accommodate any
possible dynamic values for the bounds at run-time.
component will require four-byte alignment because that is what type
Integer requires, whereas the Y component, a Character, will only
require 1-byte alignment. Since the alignment required for X is the
-greatest of all the components' alignments, that is the alignment
+greatest of all the components’ alignments, that is the alignment
required for the enclosing record type, i.e., 4 bytes or 32 bits. As
indicated above, the actual object size must be rounded up so that it is
a multiple of the alignment value. Therefore, 40 bits rounded up to the
warning can be turned off using @code{-gnatw.B}.
@node Component_Size Clauses,Bit_Order Clauses,Value_Size and Object_Size Clauses,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas id8}@anchor{283}@anchor{gnat_rm/representation_clauses_and_pragmas component-size-clauses}@anchor{284}
+@anchor{gnat_rm/representation_clauses_and_pragmas component-size-clauses}@anchor{283}@anchor{gnat_rm/representation_clauses_and_pragmas id8}@anchor{284}
@section Component_Size Clauses
details regarding the issue of byte ordering.
@node Effect of Bit_Order on Byte Ordering,Pragma Pack for Arrays,Bit_Order Clauses,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas id10}@anchor{287}@anchor{gnat_rm/representation_clauses_and_pragmas effect-of-bit-order-on-byte-ordering}@anchor{288}
+@anchor{gnat_rm/representation_clauses_and_pragmas effect-of-bit-order-on-byte-ordering}@anchor{287}@anchor{gnat_rm/representation_clauses_and_pragmas id10}@anchor{288}
@section Effect of Bit_Order on Byte Ordering
@quotation
-"2 A bit ordering is a method of interpreting the meaning of
-the storage place attributes."
+“2 A bit ordering is a method of interpreting the meaning of
+the storage place attributes.”
@end quotation
To understand the precise definition of storage place attributes in
@quotation
-"13 A record_representation_clause (without the mod_clause)
+“13 A record_representation_clause (without the mod_clause)
specifies the layout. The storage place attributes (see 13.5.2)
are taken from the values of the position, first_bit, and last_bit
expressions after normalizing those values so that first_bit is
-less than Storage_Unit."
+less than Storage_Unit.”
@end quotation
The critical point here is that storage places are taken from
@quotation
-"2 A bit ordering is a method of interpreting the meaning of
+“2 A bit ordering is a method of interpreting the meaning of
the storage place attributes. High_Order_First (known in the
-vernacular as 'big endian') means that the first bit of a
+vernacular as ‘big endian’) means that the first bit of a
storage element (bit 0) is the most significant bit (interpreting
the sequence of bits that represent a component as an unsigned
integer value). Low_Order_First (known in the vernacular as
-'little endian') means the opposite: the first bit is the
-least significant."
+‘little endian’) means the opposite: the first bit is the
+least significant.”
@end quotation
Note that the numbering is with respect to the bits of a storage
record is called Master, and the second byte is called Slave.
The left most (most significant bit is called Control for each byte, and
-the remaining 7 bits are called V1, V2, ... V7, where V7 is the rightmost
+the remaining 7 bits are called V1, V2, … V7, where V7 is the rightmost
(least significant) bit.
On a big-endian machine, we can write the following representation clause
an appropriate manner.
@node Pragma Pack for Arrays,Pragma Pack for Records,Effect of Bit_Order on Byte Ordering,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas pragma-pack-for-arrays}@anchor{289}@anchor{gnat_rm/representation_clauses_and_pragmas id11}@anchor{28a}
+@anchor{gnat_rm/representation_clauses_and_pragmas id11}@anchor{289}@anchor{gnat_rm/representation_clauses_and_pragmas pragma-pack-for-arrays}@anchor{28a}
@section Pragma Pack for Arrays
since in this case the programmer intention is clear.
@node Pragma Pack for Records,Record Representation Clauses,Pragma Pack for Arrays,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas pragma-pack-for-records}@anchor{28b}@anchor{gnat_rm/representation_clauses_and_pragmas id12}@anchor{28c}
+@anchor{gnat_rm/representation_clauses_and_pragmas id12}@anchor{28b}@anchor{gnat_rm/representation_clauses_and_pragmas pragma-pack-for-records}@anchor{28c}
@section Pragma Pack for Records
@geindex Handling of Records with Holes
-As a result of alignment considerations, records may contain "holes"
+As a result of alignment considerations, records may contain “holes”
or gaps which do not correspond to the data bits of any of the components.
Record representation clauses can also result in holes in records.
positional values, (i.e., the value delivered by the @code{Pos} attribute).
@node Address Clauses,Use of Address Clauses for Memory-Mapped I/O,Enumeration Clauses,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas id16}@anchor{293}@anchor{gnat_rm/representation_clauses_and_pragmas address-clauses}@anchor{294}
+@anchor{gnat_rm/representation_clauses_and_pragmas address-clauses}@anchor{293}@anchor{gnat_rm/representation_clauses_and_pragmas id16}@anchor{294}
@section Address Clauses
@quotation
-"An implementation need not support representation
+“An implementation need not support representation
items containing nonstatic expressions, except that
an implementation should support a representation item
for a given entity if each nonstatic expression in the
representation item is a name that statically denotes
-a constant declared before the entity."
+a constant declared before the entity.”
@end quotation
In practice this is applicable only to address clauses, since this is the
22.a Reason: This is to avoid the following sort of thing:
-22.b X : Integer := F(...);
-Y : Address := G(...);
-for X'Address use Y;
+22.b X : Integer := F(…);
+Y : Address := G(…);
+for X’Address use Y;
22.c In the above, we have to evaluate the
initialization expression for X before we
22.d The above code should instead be written
like this:
-22.e Y : constant Address := G(...);
-X : Integer := F(...);
-for X'Address use Y;
+22.e Y : constant Address := G(…);
+X : Integer := F(…);
+for X’Address use Y;
-22.f This allows the expression 'Y' to be safely
+22.f This allows the expression ‘Y’ to be safely
evaluated before X is created.
22.g The constant could be a formal parameter of mode in.
As noted above in section 22.h, address values are typically nonstatic. In
particular the To_Address function, even if applied to a literal value, is
a nonstatic function call. To avoid this minor annoyance, GNAT provides
-the implementation defined attribute 'To_Address. The following two
+the implementation defined attribute ‘To_Address. The following two
expressions have identical values:
@geindex Attribute
@quotation
-"19 If the Address of an object is specified, or it is imported
+“19 If the Address of an object is specified, or it is imported
or exported, then the implementation should not perform
-optimizations based on assumptions of no aliases."
+optimizations based on assumptions of no aliases.”
@end quotation
GNAT follows this recommendation, and goes further by also applying
this recommendation to the overlaid variable (@code{A} in the above example)
-in this case. This means that the overlay works "as expected", in that
+in this case. This means that the overlay works “as expected”, in that
a modification to one of the variables will affect the value of the other.
More generally, GNAT interprets this recommendation conservatively for
pragma @code{Atomic} and will give the additional guarantee.
@node Effect of Convention on Representation,Conventions and Anonymous Access Types,Use of Address Clauses for Memory-Mapped I/O,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas id18}@anchor{297}@anchor{gnat_rm/representation_clauses_and_pragmas effect-of-convention-on-representation}@anchor{298}
+@anchor{gnat_rm/representation_clauses_and_pragmas effect-of-convention-on-representation}@anchor{297}@anchor{gnat_rm/representation_clauses_and_pragmas id18}@anchor{298}
@section Effect of Convention on Representation
seems to make sense since it is anomolous in any case to have a
different convention for an object and its type, and there is clearly
no way to explicitly specify a convention for an anonymous type, since
-it doesn't have a name to specify!
+it doesn’t have a name to specify!
Furthermore, we decide that if a convention is applied to a record type,
then this convention is inherited by any of its components that are of an
@end example
@node Determining the Representations chosen by GNAT,,Conventions and Anonymous Access Types,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas id20}@anchor{29b}@anchor{gnat_rm/representation_clauses_and_pragmas determining-the-representations-chosen-by-gnat}@anchor{29c}
+@anchor{gnat_rm/representation_clauses_and_pragmas determining-the-representations-chosen-by-gnat}@anchor{29b}@anchor{gnat_rm/representation_clauses_and_pragmas id20}@anchor{29c}
@section Determining the Representations chosen by GNAT
the actual representation to be used.
@node Standard Library Routines,The Implementation of Standard I/O,Representation Clauses and Pragmas,Top
-@anchor{gnat_rm/standard_library_routines standard-library-routines}@anchor{e}@anchor{gnat_rm/standard_library_routines doc}@anchor{29d}@anchor{gnat_rm/standard_library_routines id1}@anchor{29e}
+@anchor{gnat_rm/standard_library_routines doc}@anchor{29d}@anchor{gnat_rm/standard_library_routines id1}@anchor{29e}@anchor{gnat_rm/standard_library_routines standard-library-routines}@anchor{e}
@chapter Standard Library Routines
This package provides constants describing the range of decimal numbers
implemented, and also a decimal divide routine (analogous to the COBOL
-verb DIVIDE ... GIVING ... REMAINDER ...)
+verb DIVIDE … GIVING … REMAINDER …)
@item @code{Ada.Direct_IO} @emph{(A.8.4)}
Not implemented in GNAT.
-@item @code{Ada.Execution_Time.Timers} @emph{(D.14.1)'}
+@item @code{Ada.Execution_Time.Timers} @emph{(D.14.1)’}
Not implemented in GNAT.
available in GNAT, see the Ada 2012 RM for full details.
@node The Implementation of Standard I/O,The GNAT Library,Standard Library Routines,Top
-@anchor{gnat_rm/the_implementation_of_standard_i_o the-implementation-of-standard-i-o}@anchor{f}@anchor{gnat_rm/the_implementation_of_standard_i_o doc}@anchor{29f}@anchor{gnat_rm/the_implementation_of_standard_i_o id1}@anchor{2a0}
+@anchor{gnat_rm/the_implementation_of_standard_i_o doc}@anchor{29f}@anchor{gnat_rm/the_implementation_of_standard_i_o id1}@anchor{2a0}@anchor{gnat_rm/the_implementation_of_standard_i_o the-implementation-of-standard-i-o}@anchor{f}
@chapter The Implementation of Standard I/O
@end menu
@node Standard I/O Packages,FORM Strings,,The Implementation of Standard I/O
-@anchor{gnat_rm/the_implementation_of_standard_i_o standard-i-o-packages}@anchor{2a1}@anchor{gnat_rm/the_implementation_of_standard_i_o id2}@anchor{2a2}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id2}@anchor{2a1}@anchor{gnat_rm/the_implementation_of_standard_i_o standard-i-o-packages}@anchor{2a2}
@section Standard I/O Packages
necessary to accommodate whatever records are written to the file.
@node Sequential_IO,Text_IO,Direct_IO,The Implementation of Standard I/O
-@anchor{gnat_rm/the_implementation_of_standard_i_o sequential-io}@anchor{2a7}@anchor{gnat_rm/the_implementation_of_standard_i_o id5}@anchor{2a8}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id5}@anchor{2a7}@anchor{gnat_rm/the_implementation_of_standard_i_o sequential-io}@anchor{2a8}
@section Sequential_IO
situations.
@node Reading and Writing Non-Regular Files,Get_Immediate,Stream Pointer Positioning,Text_IO
-@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files}@anchor{2ad}@anchor{gnat_rm/the_implementation_of_standard_i_o id8}@anchor{2ae}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id8}@anchor{2ad}@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files}@anchor{2ae}
@subsection Reading and Writing Non-Regular Files
piped to another Ada program.
Another important discrepancy when reading non-regular files is that the end
-of file indication is not 'sticky'. If an end of file is entered, e.g., by
+of file indication is not ‘sticky’. If an end of file is entered, e.g., by
pressing the @code{EOT} key,
then end of file
is signaled once (i.e., the test @code{End_Of_File}
@end itemize
@node Text_IO Facilities for Unbounded Strings,,Text_IO Extensions,Text_IO
-@anchor{gnat_rm/the_implementation_of_standard_i_o text-io-facilities-for-unbounded-strings}@anchor{2b5}@anchor{gnat_rm/the_implementation_of_standard_i_o id12}@anchor{2b6}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id12}@anchor{2b5}@anchor{gnat_rm/the_implementation_of_standard_i_o text-io-facilities-for-unbounded-strings}@anchor{2b6}
@subsection Text_IO Facilities for Unbounded Strings
@code{Wide_Wide_Text_IO} functionality for unbounded wide wide strings.
@node Wide_Text_IO,Wide_Wide_Text_IO,Text_IO,The Implementation of Standard I/O
-@anchor{gnat_rm/the_implementation_of_standard_i_o wide-text-io}@anchor{2b7}@anchor{gnat_rm/the_implementation_of_standard_i_o id13}@anchor{2b8}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id13}@anchor{2b7}@anchor{gnat_rm/the_implementation_of_standard_i_o wide-text-io}@anchor{2b8}
@section Wide_Text_IO
If brackets notation is used, then any occurrence of a left bracket
in the input file which is not the start of a valid wide character
sequence will cause Constraint_Error to be raised. It is possible to
-encode a left bracket as ["5B"] and Wide_Text_IO and Wide_Wide_Text_IO
+encode a left bracket as [“5B”] and Wide_Text_IO and Wide_Wide_Text_IO
input will interpret this as a left bracket.
However, when a left bracket is output, it will be output as a left bracket
-and not as ["5B"]. We make this decision because for normal use of
+and not as [“5B”]. We make this decision because for normal use of
Wide_Text_IO for outputting messages, it is unpleasant to clobber left
brackets. For example, if we write:
@quotation
In practice brackets encoding is reasonably useful for normal Put_Line use
-since we won't get confused between left brackets and wide character
+since we won’t get confused between left brackets and wide character
sequences in the output. But for input, or when files are written out
and read back in, it really makes better sense to use one of the standard
encoding methods such as UTF-8.
@end menu
@node Stream Pointer Positioning<2>,Reading and Writing Non-Regular Files<2>,,Wide_Text_IO
-@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning-1}@anchor{2b9}@anchor{gnat_rm/the_implementation_of_standard_i_o id14}@anchor{2ba}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id14}@anchor{2b9}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning-1}@anchor{2ba}
@subsection Stream Pointer Positioning
can be observed if the wide text file shares a stream with another file.
@node Reading and Writing Non-Regular Files<2>,,Stream Pointer Positioning<2>,Wide_Text_IO
-@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files-1}@anchor{2bb}@anchor{gnat_rm/the_implementation_of_standard_i_o id15}@anchor{2bc}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id15}@anchor{2bb}@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files-1}@anchor{2bc}
@subsection Reading and Writing Non-Regular Files
@end menu
@node Stream Pointer Positioning<3>,Reading and Writing Non-Regular Files<3>,,Wide_Wide_Text_IO
-@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning-2}@anchor{2bf}@anchor{gnat_rm/the_implementation_of_standard_i_o id17}@anchor{2c0}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id17}@anchor{2bf}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning-2}@anchor{2c0}
@subsection Stream Pointer Positioning
This encoding is only supported on the Windows platform.
@node Open Modes,Operations on C Streams,File content encoding,The Implementation of Standard I/O
-@anchor{gnat_rm/the_implementation_of_standard_i_o open-modes}@anchor{2cd}@anchor{gnat_rm/the_implementation_of_standard_i_o id24}@anchor{2ce}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id24}@anchor{2cd}@anchor{gnat_rm/the_implementation_of_standard_i_o open-modes}@anchor{2ce}
@section Open Modes
@tab
-"r+"
+“r+”
@tab
-"w+"
+“w+”
@item
@tab
-"r"
+“r”
@tab
-"w+"
+“w+”
@item
@tab
-"r+"
+“r+”
@tab
-"w"
+“w”
@item
@tab
-"w"
+“w”
@tab
-"w"
+“w”
@item
@tab
-"r+"
+“r+”
@tab
-"w+"
+“w+”
@end multitable
then the file is reopened in @code{r+} mode to permit the required operation.
@node Operations on C Streams,Interfacing to C Streams,Open Modes,The Implementation of Standard I/O
-@anchor{gnat_rm/the_implementation_of_standard_i_o operations-on-c-streams}@anchor{2cf}@anchor{gnat_rm/the_implementation_of_standard_i_o id25}@anchor{2d0}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id25}@anchor{2cf}@anchor{gnat_rm/the_implementation_of_standard_i_o operations-on-c-streams}@anchor{2d0}
@section Operations on C Streams
@end example
@node Interfacing to C Streams,,Operations on C Streams,The Implementation of Standard I/O
-@anchor{gnat_rm/the_implementation_of_standard_i_o interfacing-to-c-streams}@anchor{2d1}@anchor{gnat_rm/the_implementation_of_standard_i_o id26}@anchor{2d2}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id26}@anchor{2d1}@anchor{gnat_rm/the_implementation_of_standard_i_o interfacing-to-c-streams}@anchor{2d2}
@section Interfacing to C Streams
existing C file.
@node The GNAT Library,Interfacing to Other Languages,The Implementation of Standard I/O,Top
-@anchor{gnat_rm/the_gnat_library the-gnat-library}@anchor{10}@anchor{gnat_rm/the_gnat_library doc}@anchor{2d3}@anchor{gnat_rm/the_gnat_library id1}@anchor{2d4}
+@anchor{gnat_rm/the_gnat_library doc}@anchor{2d3}@anchor{gnat_rm/the_gnat_library id1}@anchor{2d4}@anchor{gnat_rm/the_gnat_library the-gnat-library}@anchor{10}
@chapter The GNAT Library
@end menu
@node Ada Characters Latin_9 a-chlat9 ads,Ada Characters Wide_Latin_1 a-cwila1 ads,,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id2}@anchor{2d5}@anchor{gnat_rm/the_gnat_library ada-characters-latin-9-a-chlat9-ads}@anchor{2d6}
+@anchor{gnat_rm/the_gnat_library ada-characters-latin-9-a-chlat9-ads}@anchor{2d5}@anchor{gnat_rm/the_gnat_library id2}@anchor{2d6}
@section @code{Ada.Characters.Latin_9} (@code{a-chlat9.ads})
(RM A.3.3(27)).
@node Ada Characters Wide_Latin_9 a-cwila1 ads,Ada Characters Wide_Wide_Latin_1 a-chzla1 ads,Ada Characters Wide_Latin_1 a-cwila1 ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id4}@anchor{2d9}@anchor{gnat_rm/the_gnat_library ada-characters-wide-latin-9-a-cwila1-ads}@anchor{2da}
+@anchor{gnat_rm/the_gnat_library ada-characters-wide-latin-9-a-cwila1-ads}@anchor{2d9}@anchor{gnat_rm/the_gnat_library id4}@anchor{2da}
@section @code{Ada.Characters.Wide_Latin_9} (@code{a-cwila1.ads})
(RM A.3.3(27)).
@node Ada Containers Formal_Doubly_Linked_Lists a-cfdlli ads,Ada Containers Formal_Hashed_Maps a-cfhama ads,Ada Characters Wide_Wide_Latin_9 a-chzla9 ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id7}@anchor{2df}@anchor{gnat_rm/the_gnat_library ada-containers-formal-doubly-linked-lists-a-cfdlli-ads}@anchor{2e0}
+@anchor{gnat_rm/the_gnat_library ada-containers-formal-doubly-linked-lists-a-cfdlli-ads}@anchor{2df}@anchor{gnat_rm/the_gnat_library id7}@anchor{2e0}
@section @code{Ada.Containers.Formal_Doubly_Linked_Lists} (@code{a-cfdlli.ads})
does not have the complex overhead required to detect cursor tampering.
@node Ada Containers Formal_Hashed_Maps a-cfhama ads,Ada Containers Formal_Hashed_Sets a-cfhase ads,Ada Containers Formal_Doubly_Linked_Lists a-cfdlli ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id8}@anchor{2e1}@anchor{gnat_rm/the_gnat_library ada-containers-formal-hashed-maps-a-cfhama-ads}@anchor{2e2}
+@anchor{gnat_rm/the_gnat_library ada-containers-formal-hashed-maps-a-cfhama-ads}@anchor{2e1}@anchor{gnat_rm/the_gnat_library id8}@anchor{2e2}
@section @code{Ada.Containers.Formal_Hashed_Maps} (@code{a-cfhama.ads})
does not have the complex overhead required to detect cursor tampering.
@node Ada Containers Formal_Hashed_Sets a-cfhase ads,Ada Containers Formal_Ordered_Maps a-cforma ads,Ada Containers Formal_Hashed_Maps a-cfhama ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id9}@anchor{2e3}@anchor{gnat_rm/the_gnat_library ada-containers-formal-hashed-sets-a-cfhase-ads}@anchor{2e4}
+@anchor{gnat_rm/the_gnat_library ada-containers-formal-hashed-sets-a-cfhase-ads}@anchor{2e3}@anchor{gnat_rm/the_gnat_library id9}@anchor{2e4}
@section @code{Ada.Containers.Formal_Hashed_Sets} (@code{a-cfhase.ads})
does not have the complex overhead required to detect cursor tampering.
@node Ada Containers Formal_Ordered_Maps a-cforma ads,Ada Containers Formal_Ordered_Sets a-cforse ads,Ada Containers Formal_Hashed_Sets a-cfhase ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id10}@anchor{2e5}@anchor{gnat_rm/the_gnat_library ada-containers-formal-ordered-maps-a-cforma-ads}@anchor{2e6}
+@anchor{gnat_rm/the_gnat_library ada-containers-formal-ordered-maps-a-cforma-ads}@anchor{2e5}@anchor{gnat_rm/the_gnat_library id10}@anchor{2e6}
@section @code{Ada.Containers.Formal_Ordered_Maps} (@code{a-cforma.ads})
does not have the complex overhead required to detect cursor tampering.
@node Ada Containers Formal_Vectors a-cofove ads,Ada Containers Formal_Indefinite_Vectors a-cfinve ads,Ada Containers Formal_Ordered_Sets a-cforse ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id12}@anchor{2e9}@anchor{gnat_rm/the_gnat_library ada-containers-formal-vectors-a-cofove-ads}@anchor{2ea}
+@anchor{gnat_rm/the_gnat_library ada-containers-formal-vectors-a-cofove-ads}@anchor{2e9}@anchor{gnat_rm/the_gnat_library id12}@anchor{2ea}
@section @code{Ada.Containers.Formal_Vectors} (@code{a-cofove.ads})
does not have the complex overhead required to detect cursor tampering.
@node Ada Containers Formal_Indefinite_Vectors a-cfinve ads,Ada Containers Functional_Vectors a-cofuve ads,Ada Containers Formal_Vectors a-cofove ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id13}@anchor{2eb}@anchor{gnat_rm/the_gnat_library ada-containers-formal-indefinite-vectors-a-cfinve-ads}@anchor{2ec}
+@anchor{gnat_rm/the_gnat_library ada-containers-formal-indefinite-vectors-a-cfinve-ads}@anchor{2eb}@anchor{gnat_rm/the_gnat_library id13}@anchor{2ec}
@section @code{Ada.Containers.Formal_Indefinite_Vectors} (@code{a-cfinve.ads})
does not have the complex overhead required to detect cursor tampering.
@node Ada Containers Functional_Vectors a-cofuve ads,Ada Containers Functional_Sets a-cofuse ads,Ada Containers Formal_Indefinite_Vectors a-cfinve ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id14}@anchor{2ed}@anchor{gnat_rm/the_gnat_library ada-containers-functional-vectors-a-cofuve-ads}@anchor{2ee}
+@anchor{gnat_rm/the_gnat_library ada-containers-functional-vectors-a-cofuve-ads}@anchor{2ed}@anchor{gnat_rm/the_gnat_library id14}@anchor{2ee}
@section @code{Ada.Containers.Functional_Vectors} (@code{a-cofuve.ads})
specification of this unit is compatible with SPARK 2014.
@node Ada Containers Functional_Maps a-cofuma ads,Ada Containers Bounded_Holders a-coboho ads,Ada Containers Functional_Sets a-cofuse ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id16}@anchor{2f1}@anchor{gnat_rm/the_gnat_library ada-containers-functional-maps-a-cofuma-ads}@anchor{2f2}
+@anchor{gnat_rm/the_gnat_library ada-containers-functional-maps-a-cofuma-ads}@anchor{2f1}@anchor{gnat_rm/the_gnat_library id16}@anchor{2f2}
@section @code{Ada.Containers.Functional_Maps} (@code{a-cofuma.ads})
where this concept makes sense.
@node Ada Command_Line Remove a-colire ads,Ada Command_Line Response_File a-clrefi ads,Ada Command_Line Environment a-colien ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id19}@anchor{2f7}@anchor{gnat_rm/the_gnat_library ada-command-line-remove-a-colire-ads}@anchor{2f8}
+@anchor{gnat_rm/the_gnat_library ada-command-line-remove-a-colire-ads}@anchor{2f7}@anchor{gnat_rm/the_gnat_library id19}@anchor{2f8}
@section @code{Ada.Command_Line.Remove} (@code{a-colire.ads})
see the removed argument.
@node Ada Command_Line Response_File a-clrefi ads,Ada Direct_IO C_Streams a-diocst ads,Ada Command_Line Remove a-colire ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id20}@anchor{2f9}@anchor{gnat_rm/the_gnat_library ada-command-line-response-file-a-clrefi-ads}@anchor{2fa}
+@anchor{gnat_rm/the_gnat_library ada-command-line-response-file-a-clrefi-ads}@anchor{2f9}@anchor{gnat_rm/the_gnat_library id20}@anchor{2fa}
@section @code{Ada.Command_Line.Response_File} (@code{a-clrefi.ads})
@geindex handling long command lines
This child of @code{Ada.Command_Line} provides a mechanism facilities for
-getting command line arguments from a text file, called a "response file".
+getting command line arguments from a text file, called a “response file”.
Using a response file allow passing a set of arguments to an executable longer
than the maximum allowed by the system on the command line.
@node Ada Direct_IO C_Streams a-diocst ads,Ada Exceptions Is_Null_Occurrence a-einuoc ads,Ada Command_Line Response_File a-clrefi ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id21}@anchor{2fb}@anchor{gnat_rm/the_gnat_library ada-direct-io-c-streams-a-diocst-ads}@anchor{2fc}
+@anchor{gnat_rm/the_gnat_library ada-direct-io-c-streams-a-diocst-ads}@anchor{2fb}@anchor{gnat_rm/the_gnat_library id21}@anchor{2fc}
@section @code{Ada.Direct_IO.C_Streams} (@code{a-diocst.ads})
can be constructed from a stream opened on the C side.
@node Ada Exceptions Is_Null_Occurrence a-einuoc ads,Ada Exceptions Last_Chance_Handler a-elchha ads,Ada Direct_IO C_Streams a-diocst ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id22}@anchor{2fd}@anchor{gnat_rm/the_gnat_library ada-exceptions-is-null-occurrence-a-einuoc-ads}@anchor{2fe}
+@anchor{gnat_rm/the_gnat_library ada-exceptions-is-null-occurrence-a-einuoc-ads}@anchor{2fd}@anchor{gnat_rm/the_gnat_library id22}@anchor{2fe}
@section @code{Ada.Exceptions.Is_Null_Occurrence} (@code{a-einuoc.ads})
an exception.
@node Ada Exceptions Last_Chance_Handler a-elchha ads,Ada Exceptions Traceback a-exctra ads,Ada Exceptions Is_Null_Occurrence a-einuoc ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id23}@anchor{2ff}@anchor{gnat_rm/the_gnat_library ada-exceptions-last-chance-handler-a-elchha-ads}@anchor{300}
+@anchor{gnat_rm/the_gnat_library ada-exceptions-last-chance-handler-a-elchha-ads}@anchor{2ff}@anchor{gnat_rm/the_gnat_library id23}@anchor{300}
@section @code{Ada.Exceptions.Last_Chance_Handler} (@code{a-elchha.ads})
can be constructed from a stream opened on the C side.
@node Ada Streams Stream_IO C_Streams a-ssicst ads,Ada Strings Unbounded Text_IO a-suteio ads,Ada Sequential_IO C_Streams a-siocst ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id26}@anchor{305}@anchor{gnat_rm/the_gnat_library ada-streams-stream-io-c-streams-a-ssicst-ads}@anchor{306}
+@anchor{gnat_rm/the_gnat_library ada-streams-stream-io-c-streams-a-ssicst-ads}@anchor{305}@anchor{gnat_rm/the_gnat_library id26}@anchor{306}
@section @code{Ada.Streams.Stream_IO.C_Streams} (@code{a-ssicst.ads})
with ordinary strings.
@node Ada Strings Wide_Unbounded Wide_Text_IO a-swuwti ads,Ada Strings Wide_Wide_Unbounded Wide_Wide_Text_IO a-szuzti ads,Ada Strings Unbounded Text_IO a-suteio ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id28}@anchor{309}@anchor{gnat_rm/the_gnat_library ada-strings-wide-unbounded-wide-text-io-a-swuwti-ads}@anchor{30a}
+@anchor{gnat_rm/the_gnat_library ada-strings-wide-unbounded-wide-text-io-a-swuwti-ads}@anchor{309}@anchor{gnat_rm/the_gnat_library id28}@anchor{30a}
@section @code{Ada.Strings.Wide_Unbounded.Wide_Text_IO} (@code{a-swuwti.ads})
with ordinary wide strings.
@node Ada Strings Wide_Wide_Unbounded Wide_Wide_Text_IO a-szuzti ads,Ada Task_Initialization a-tasini ads,Ada Strings Wide_Unbounded Wide_Text_IO a-swuwti ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id29}@anchor{30b}@anchor{gnat_rm/the_gnat_library ada-strings-wide-wide-unbounded-wide-wide-text-io-a-szuzti-ads}@anchor{30c}
+@anchor{gnat_rm/the_gnat_library ada-strings-wide-wide-unbounded-wide-wide-text-io-a-szuzti-ads}@anchor{30b}@anchor{gnat_rm/the_gnat_library id29}@anchor{30c}
@section @code{Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Text_IO} (@code{a-szuzti.ads})
interactive).
@node Ada Wide_Characters Unicode a-wichun ads,Ada Wide_Text_IO C_Streams a-wtcstr ads,Ada Text_IO Reset_Standard_Files a-tirsfi ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id33}@anchor{313}@anchor{gnat_rm/the_gnat_library ada-wide-characters-unicode-a-wichun-ads}@anchor{314}
+@anchor{gnat_rm/the_gnat_library ada-wide-characters-unicode-a-wichun-ads}@anchor{313}@anchor{gnat_rm/the_gnat_library id33}@anchor{314}
@section @code{Ada.Wide_Characters.Unicode} (@code{a-wichun.ads})
Wide_Character values according to Unicode categories.
@node Ada Wide_Text_IO C_Streams a-wtcstr ads,Ada Wide_Text_IO Reset_Standard_Files a-wrstfi ads,Ada Wide_Characters Unicode a-wichun ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id34}@anchor{315}@anchor{gnat_rm/the_gnat_library ada-wide-text-io-c-streams-a-wtcstr-ads}@anchor{316}
+@anchor{gnat_rm/the_gnat_library ada-wide-text-io-c-streams-a-wtcstr-ads}@anchor{315}@anchor{gnat_rm/the_gnat_library id34}@anchor{316}
@section @code{Ada.Wide_Text_IO.C_Streams} (@code{a-wtcstr.ads})
interactive).
@node Ada Wide_Wide_Characters Unicode a-zchuni ads,Ada Wide_Wide_Text_IO C_Streams a-ztcstr ads,Ada Wide_Text_IO Reset_Standard_Files a-wrstfi ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id36}@anchor{319}@anchor{gnat_rm/the_gnat_library ada-wide-wide-characters-unicode-a-zchuni-ads}@anchor{31a}
+@anchor{gnat_rm/the_gnat_library ada-wide-wide-characters-unicode-a-zchuni-ads}@anchor{319}@anchor{gnat_rm/the_gnat_library id36}@anchor{31a}
@section @code{Ada.Wide_Wide_Characters.Unicode} (@code{a-zchuni.ads})
Wide_Wide_Character values according to Unicode categories.
@node Ada Wide_Wide_Text_IO C_Streams a-ztcstr ads,Ada Wide_Wide_Text_IO Reset_Standard_Files a-zrstfi ads,Ada Wide_Wide_Characters Unicode a-zchuni ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id37}@anchor{31b}@anchor{gnat_rm/the_gnat_library ada-wide-wide-text-io-c-streams-a-ztcstr-ads}@anchor{31c}
+@anchor{gnat_rm/the_gnat_library ada-wide-wide-text-io-c-streams-a-ztcstr-ads}@anchor{31b}@anchor{gnat_rm/the_gnat_library id37}@anchor{31c}
@section @code{Ada.Wide_Wide_Text_IO.C_Streams} (@code{a-ztcstr.ads})
This package provides the Vector/View conversion routines.
@node GNAT Altivec Vector_Operations g-alveop ads,GNAT Altivec Vector_Types g-alvety ads,GNAT Altivec Conversions g-altcon ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id41}@anchor{323}@anchor{gnat_rm/the_gnat_library gnat-altivec-vector-operations-g-alveop-ads}@anchor{324}
+@anchor{gnat_rm/the_gnat_library gnat-altivec-vector-operations-g-alveop-ads}@anchor{323}@anchor{gnat_rm/the_gnat_library id41}@anchor{324}
@section @code{GNAT.Altivec.Vector_Operations} (@code{g-alveop.ads})
@geindex AltiVec
-This package provides public 'View' data types from/to which private
+This package provides public ‘View’ data types from/to which private
vector representations can be converted via
GNAT.Altivec.Conversions. This allows convenient access to individual
vector elements and provides a simple way to initialize vector
to the resulting slices.
@node GNAT AWK g-awk ads,GNAT Bind_Environment g-binenv ads,GNAT Array_Split g-arrspl ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id45}@anchor{32b}@anchor{gnat_rm/the_gnat_library gnat-awk-g-awk-ads}@anchor{32c}
+@anchor{gnat_rm/the_gnat_library gnat-awk-g-awk-ads}@anchor{32b}@anchor{gnat_rm/the_gnat_library id45}@anchor{32c}
@section @code{GNAT.AWK} (@code{g-awk.ads})
where each record is a line and a field is a data element in this line.
@node GNAT Bind_Environment g-binenv ads,GNAT Branch_Prediction g-brapre ads,GNAT AWK g-awk ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id46}@anchor{32d}@anchor{gnat_rm/the_gnat_library gnat-bind-environment-g-binenv-ads}@anchor{32e}
+@anchor{gnat_rm/the_gnat_library gnat-bind-environment-g-binenv-ads}@anchor{32d}@anchor{gnat_rm/the_gnat_library id46}@anchor{32e}
@section @code{GNAT.Bind_Environment} (@code{g-binenv.ads})
line switch.
@node GNAT Branch_Prediction g-brapre ads,GNAT Bounded_Buffers g-boubuf ads,GNAT Bind_Environment g-binenv ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id47}@anchor{32f}@anchor{gnat_rm/the_gnat_library gnat-branch-prediction-g-brapre-ads}@anchor{330}
+@anchor{gnat_rm/the_gnat_library gnat-branch-prediction-g-brapre-ads}@anchor{32f}@anchor{gnat_rm/the_gnat_library id47}@anchor{330}
@section @code{GNAT.Branch_Prediction} (@code{g-brapre.ads})
access-to-procedure values.
@node GNAT Bubble_Sort_A g-busora ads,GNAT Bubble_Sort_G g-busorg ads,GNAT Bubble_Sort g-bubsor ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id51}@anchor{337}@anchor{gnat_rm/the_gnat_library gnat-bubble-sort-a-g-busora-ads}@anchor{338}
+@anchor{gnat_rm/the_gnat_library gnat-bubble-sort-a-g-busora-ads}@anchor{337}@anchor{gnat_rm/the_gnat_library id51}@anchor{338}
@section @code{GNAT.Bubble_Sort_A} (@code{g-busora.ads})
@geindex Wide characte representations
Provides a routine which given a string, reads the start of the string to
-see whether it is one of the standard byte order marks (BOM's) which signal
+see whether it is one of the standard byte order marks (BOM’s) which signal
the encoding of the string. The routine includes detection of special XML
sequences for various UCS input formats.
Machine-specific implementations are available in some cases.
@node GNAT Calendar g-calend ads,GNAT Calendar Time_IO g-catiio ads,GNAT Byte_Swapping g-bytswa ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id55}@anchor{33f}@anchor{gnat_rm/the_gnat_library gnat-calendar-g-calend-ads}@anchor{340}
+@anchor{gnat_rm/the_gnat_library gnat-calendar-g-calend-ads}@anchor{33f}@anchor{gnat_rm/the_gnat_library id55}@anchor{340}
@section @code{GNAT.Calendar} (@code{g-calend.ads})
C @code{timeval} format.
@node GNAT Calendar Time_IO g-catiio ads,GNAT CRC32 g-crc32 ads,GNAT Calendar g-calend ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id56}@anchor{341}@anchor{gnat_rm/the_gnat_library gnat-calendar-time-io-g-catiio-ads}@anchor{342}
+@anchor{gnat_rm/the_gnat_library gnat-calendar-time-io-g-catiio-ads}@anchor{341}@anchor{gnat_rm/the_gnat_library id56}@anchor{342}
@section @code{GNAT.Calendar.Time_IO} (@code{g-catiio.ads})
@geindex GNAT.Calendar.Time_IO (g-catiio.ads)
@node GNAT CRC32 g-crc32 ads,GNAT Case_Util g-casuti ads,GNAT Calendar Time_IO g-catiio ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id57}@anchor{343}@anchor{gnat_rm/the_gnat_library gnat-crc32-g-crc32-ads}@anchor{344}
+@anchor{gnat_rm/the_gnat_library gnat-crc32-g-crc32-ads}@anchor{343}@anchor{gnat_rm/the_gnat_library id57}@anchor{344}
@section @code{GNAT.CRC32} (@code{g-crc32.ads})
Aug. 1988. Sarwate, D.V.
@node GNAT Case_Util g-casuti ads,GNAT CGI g-cgi ads,GNAT CRC32 g-crc32 ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id58}@anchor{345}@anchor{gnat_rm/the_gnat_library gnat-case-util-g-casuti-ads}@anchor{346}
+@anchor{gnat_rm/the_gnat_library gnat-case-util-g-casuti-ads}@anchor{345}@anchor{gnat_rm/the_gnat_library id58}@anchor{346}
@section @code{GNAT.Case_Util} (@code{g-casuti.ads})
in @code{Ada.Characters.Handling}.
@node GNAT CGI g-cgi ads,GNAT CGI Cookie g-cgicoo ads,GNAT Case_Util g-casuti ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id59}@anchor{347}@anchor{gnat_rm/the_gnat_library gnat-cgi-g-cgi-ads}@anchor{348}
+@anchor{gnat_rm/the_gnat_library gnat-cgi-g-cgi-ads}@anchor{347}@anchor{gnat_rm/the_gnat_library id59}@anchor{348}
@section @code{GNAT.CGI} (@code{g-cgi.ads})
programs written in Ada.
@node GNAT Command_Line g-comlin ads,GNAT Compiler_Version g-comver ads,GNAT CGI Debug g-cgideb ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id62}@anchor{34d}@anchor{gnat_rm/the_gnat_library gnat-command-line-g-comlin-ads}@anchor{34e}
+@anchor{gnat_rm/the_gnat_library gnat-command-line-g-comlin-ads}@anchor{34d}@anchor{gnat_rm/the_gnat_library id62}@anchor{34e}
@section @code{GNAT.Command_Line} (@code{g-comlin.ads})
of a partition).
@node GNAT Ctrl_C g-ctrl_c ads,GNAT Current_Exception g-curexc ads,GNAT Compiler_Version g-comver ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id64}@anchor{351}@anchor{gnat_rm/the_gnat_library gnat-ctrl-c-g-ctrl-c-ads}@anchor{352}
+@anchor{gnat_rm/the_gnat_library gnat-ctrl-c-g-ctrl-c-ads}@anchor{351}@anchor{gnat_rm/the_gnat_library id64}@anchor{352}
@section @code{GNAT.Ctrl_C} (@code{g-ctrl_c.ads})
Provides a simple interface to handle Ctrl-C keyboard events.
@node GNAT Current_Exception g-curexc ads,GNAT Debug_Pools g-debpoo ads,GNAT Ctrl_C g-ctrl_c ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id65}@anchor{353}@anchor{gnat_rm/the_gnat_library gnat-current-exception-g-curexc-ads}@anchor{354}
+@anchor{gnat_rm/the_gnat_library gnat-current-exception-g-curexc-ads}@anchor{353}@anchor{gnat_rm/the_gnat_library id65}@anchor{354}
@section @code{GNAT.Current_Exception} (@code{g-curexc.ads})
Provide a debugging storage pools that helps tracking memory corruption
problems.
-See @code{The GNAT Debug_Pool Facility} section in the @cite{GNAT User's Guide}.
+See @code{The GNAT Debug_Pool Facility} section in the @cite{GNAT User’s Guide}.
@node GNAT Debug_Utilities g-debuti ads,GNAT Decode_String g-decstr ads,GNAT Debug_Pools g-debpoo ads,The GNAT Library
@anchor{gnat_rm/the_gnat_library gnat-debug-utilities-g-debuti-ads}@anchor{357}@anchor{gnat_rm/the_gnat_library id67}@anchor{358}
A preinstantiation of GNAT.Decode_Strings for UTF-8 encoding.
@node GNAT Directory_Operations g-dirope ads,GNAT Directory_Operations Iteration g-diopit ads,GNAT Decode_UTF8_String g-deutst ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id70}@anchor{35d}@anchor{gnat_rm/the_gnat_library gnat-directory-operations-g-dirope-ads}@anchor{35e}
+@anchor{gnat_rm/the_gnat_library gnat-directory-operations-g-dirope-ads}@anchor{35d}@anchor{gnat_rm/the_gnat_library id70}@anchor{35e}
@section @code{GNAT.Directory_Operations} (@code{g-dirope.ads})
directory.
@node GNAT Directory_Operations Iteration g-diopit ads,GNAT Dynamic_HTables g-dynhta ads,GNAT Directory_Operations g-dirope ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id71}@anchor{35f}@anchor{gnat_rm/the_gnat_library gnat-directory-operations-iteration-g-diopit-ads}@anchor{360}
+@anchor{gnat_rm/the_gnat_library gnat-directory-operations-iteration-g-diopit-ads}@anchor{35f}@anchor{gnat_rm/the_gnat_library id71}@anchor{360}
@section @code{GNAT.Directory_Operations.Iteration} (@code{g-diopit.ads})
for iterating through directories.
@node GNAT Dynamic_HTables g-dynhta ads,GNAT Dynamic_Tables g-dyntab ads,GNAT Directory_Operations Iteration g-diopit ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id72}@anchor{361}@anchor{gnat_rm/the_gnat_library gnat-dynamic-htables-g-dynhta-ads}@anchor{362}
+@anchor{gnat_rm/the_gnat_library gnat-dynamic-htables-g-dynhta-ads}@anchor{361}@anchor{gnat_rm/the_gnat_library id72}@anchor{362}
@section @code{GNAT.Dynamic_HTables} (@code{g-dynhta.ads})
@code{GNAT.Table} creates a single instance of the table type.
@node GNAT Encode_String g-encstr ads,GNAT Encode_UTF8_String g-enutst ads,GNAT Dynamic_Tables g-dyntab ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id74}@anchor{365}@anchor{gnat_rm/the_gnat_library gnat-encode-string-g-encstr-ads}@anchor{366}
+@anchor{gnat_rm/the_gnat_library gnat-encode-string-g-encstr-ads}@anchor{365}@anchor{gnat_rm/the_gnat_library id74}@anchor{366}
@section @code{GNAT.Encode_String} (@code{g-encstr.ads})
occurrences.
@node GNAT Exceptions g-except ads,GNAT Expect g-expect ads,GNAT Exception_Traces g-exctra ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id78}@anchor{36d}@anchor{gnat_rm/the_gnat_library gnat-exceptions-g-except-ads}@anchor{36e}
+@anchor{gnat_rm/the_gnat_library gnat-exceptions-g-except-ads}@anchor{36d}@anchor{gnat_rm/the_gnat_library id78}@anchor{36e}
@section @code{GNAT.Exceptions} (@code{g-except.ads})
@code{Constraint_Error} with a message from a pure subprogram.
@node GNAT Expect g-expect ads,GNAT Expect TTY g-exptty ads,GNAT Exceptions g-except ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id79}@anchor{36f}@anchor{gnat_rm/the_gnat_library gnat-expect-g-expect-ads}@anchor{370}
+@anchor{gnat_rm/the_gnat_library gnat-expect-g-expect-ads}@anchor{36f}@anchor{gnat_rm/the_gnat_library id79}@anchor{370}
@section @code{GNAT.Expect} (@code{g-expect.ads})
implemented for VxWorks or LynxOS.
@node GNAT Expect TTY g-exptty ads,GNAT Float_Control g-flocon ads,GNAT Expect g-expect ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id80}@anchor{371}@anchor{gnat_rm/the_gnat_library gnat-expect-tty-g-exptty-ads}@anchor{372}
+@anchor{gnat_rm/the_gnat_library gnat-expect-tty-g-exptty-ads}@anchor{371}@anchor{gnat_rm/the_gnat_library id80}@anchor{372}
@section @code{GNAT.Expect.TTY} (@code{g-exptty.ads})
in particular is not implemented for VxWorks or LynxOS.
@node GNAT Float_Control g-flocon ads,GNAT Formatted_String g-forstr ads,GNAT Expect TTY g-exptty ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id81}@anchor{373}@anchor{gnat_rm/the_gnat_library gnat-float-control-g-flocon-ads}@anchor{374}
+@anchor{gnat_rm/the_gnat_library gnat-float-control-g-flocon-ads}@anchor{373}@anchor{gnat_rm/the_gnat_library id81}@anchor{374}
@section @code{GNAT.Float_Control} (@code{g-flocon.ads})
in this package can be used to reestablish the required mode.
@node GNAT Formatted_String g-forstr ads,GNAT Heap_Sort g-heasor ads,GNAT Float_Control g-flocon ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id82}@anchor{375}@anchor{gnat_rm/the_gnat_library gnat-formatted-string-g-forstr-ads}@anchor{376}
+@anchor{gnat_rm/the_gnat_library gnat-formatted-string-g-forstr-ads}@anchor{375}@anchor{gnat_rm/the_gnat_library id82}@anchor{376}
@section @code{GNAT.Formatted_String} (@code{g-forstr.ads})
formatted string.
@node GNAT Heap_Sort g-heasor ads,GNAT Heap_Sort_A g-hesora ads,GNAT Formatted_String g-forstr ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id83}@anchor{377}@anchor{gnat_rm/the_gnat_library gnat-heap-sort-g-heasor-ads}@anchor{378}
+@anchor{gnat_rm/the_gnat_library gnat-heap-sort-g-heasor-ads}@anchor{377}@anchor{gnat_rm/the_gnat_library id83}@anchor{378}
@section @code{GNAT.Heap_Sort} (@code{g-heasor.ads})
interface, but may be slightly more efficient.
@node GNAT Heap_Sort_G g-hesorg ads,GNAT HTable g-htable ads,GNAT Heap_Sort_A g-hesora ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id85}@anchor{37b}@anchor{gnat_rm/the_gnat_library gnat-heap-sort-g-g-hesorg-ads}@anchor{37c}
+@anchor{gnat_rm/the_gnat_library gnat-heap-sort-g-g-hesorg-ads}@anchor{37b}@anchor{gnat_rm/the_gnat_library id85}@anchor{37c}
@section @code{GNAT.Heap_Sort_G} (@code{g-hesorg.ads})
multiple instantiations.
@node GNAT HTable g-htable ads,GNAT IO g-io ads,GNAT Heap_Sort_G g-hesorg ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id86}@anchor{37d}@anchor{gnat_rm/the_gnat_library gnat-htable-g-htable-ads}@anchor{37e}
+@anchor{gnat_rm/the_gnat_library gnat-htable-g-htable-ads}@anchor{37d}@anchor{gnat_rm/the_gnat_library id86}@anchor{37e}
@section @code{GNAT.HTable} (@code{g-htable.ads})
allowing arbitrary dynamic hash tables.
@node GNAT IO g-io ads,GNAT IO_Aux g-io_aux ads,GNAT HTable g-htable ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id87}@anchor{37f}@anchor{gnat_rm/the_gnat_library gnat-io-g-io-ads}@anchor{380}
+@anchor{gnat_rm/the_gnat_library gnat-io-g-io-ads}@anchor{37f}@anchor{gnat_rm/the_gnat_library id87}@anchor{380}
@section @code{GNAT.IO} (@code{g-io.ads})
Standard_Output or Standard_Error.
@node GNAT IO_Aux g-io_aux ads,GNAT Lock_Files g-locfil ads,GNAT IO g-io ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id88}@anchor{381}@anchor{gnat_rm/the_gnat_library gnat-io-aux-g-io-aux-ads}@anchor{382}
+@anchor{gnat_rm/the_gnat_library gnat-io-aux-g-io-aux-ads}@anchor{381}@anchor{gnat_rm/the_gnat_library id88}@anchor{382}
@section @code{GNAT.IO_Aux} (@code{g-io_aux.ads})
for whether a file exists, and functions for reading a line of text.
@node GNAT Lock_Files g-locfil ads,GNAT MBBS_Discrete_Random g-mbdira ads,GNAT IO_Aux g-io_aux ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id89}@anchor{383}@anchor{gnat_rm/the_gnat_library gnat-lock-files-g-locfil-ads}@anchor{384}
+@anchor{gnat_rm/the_gnat_library gnat-lock-files-g-locfil-ads}@anchor{383}@anchor{gnat_rm/the_gnat_library id89}@anchor{384}
@section @code{GNAT.Lock_Files} (@code{g-locfil.ads})
providing program level synchronization.
@node GNAT MBBS_Discrete_Random g-mbdira ads,GNAT MBBS_Float_Random g-mbflra ads,GNAT Lock_Files g-locfil ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id90}@anchor{385}@anchor{gnat_rm/the_gnat_library gnat-mbbs-discrete-random-g-mbdira-ads}@anchor{386}
+@anchor{gnat_rm/the_gnat_library gnat-mbbs-discrete-random-g-mbdira-ads}@anchor{385}@anchor{gnat_rm/the_gnat_library id90}@anchor{386}
@section @code{GNAT.MBBS_Discrete_Random} (@code{g-mbdira.ads})
a modified version of the Blum-Blum-Shub generator.
@node GNAT MBBS_Float_Random g-mbflra ads,GNAT MD5 g-md5 ads,GNAT MBBS_Discrete_Random g-mbdira ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id91}@anchor{387}@anchor{gnat_rm/the_gnat_library gnat-mbbs-float-random-g-mbflra-ads}@anchor{388}
+@anchor{gnat_rm/the_gnat_library gnat-mbbs-float-random-g-mbflra-ads}@anchor{387}@anchor{gnat_rm/the_gnat_library id91}@anchor{388}
@section @code{GNAT.MBBS_Float_Random} (@code{g-mbflra.ads})
a modified version of the Blum-Blum-Shub generator.
@node GNAT MD5 g-md5 ads,GNAT Memory_Dump g-memdum ads,GNAT MBBS_Float_Random g-mbflra ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id92}@anchor{389}@anchor{gnat_rm/the_gnat_library gnat-md5-g-md5-ads}@anchor{38a}
+@anchor{gnat_rm/the_gnat_library gnat-md5-g-md5-ads}@anchor{389}@anchor{gnat_rm/the_gnat_library id92}@anchor{38a}
@section @code{GNAT.MD5} (@code{g-md5.ads})
FIPS PUB 198.
@node GNAT Memory_Dump g-memdum ads,GNAT Most_Recent_Exception g-moreex ads,GNAT MD5 g-md5 ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id93}@anchor{38b}@anchor{gnat_rm/the_gnat_library gnat-memory-dump-g-memdum-ads}@anchor{38c}
+@anchor{gnat_rm/the_gnat_library gnat-memory-dump-g-memdum-ads}@anchor{38b}@anchor{gnat_rm/the_gnat_library id93}@anchor{38c}
@section @code{GNAT.Memory_Dump} (@code{g-memdum.ads})
standard Ada library and are more convenient to use.
@node GNAT Regexp g-regexp ads,GNAT Registry g-regist ads,GNAT Random_Numbers g-rannum ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id98}@anchor{395}@anchor{gnat_rm/the_gnat_library gnat-regexp-g-regexp-ads}@anchor{25a}
+@anchor{gnat_rm/the_gnat_library gnat-regexp-g-regexp-ads}@anchor{25a}@anchor{gnat_rm/the_gnat_library id98}@anchor{395}
@section @code{GNAT.Regexp} (@code{g-regexp.ads})
A simple implementation of regular expressions, using a subset of regular
expression syntax copied from familiar Unix style utilities. This is the
simplest of the three pattern matching packages provided, and is particularly
-suitable for 'file globbing' applications.
+suitable for ‘file globbing’ applications.
@node GNAT Registry g-regist ads,GNAT Regpat g-regpat ads,GNAT Regexp g-regexp ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id99}@anchor{396}@anchor{gnat_rm/the_gnat_library gnat-registry-g-regist-ads}@anchor{397}
+@anchor{gnat_rm/the_gnat_library gnat-registry-g-regist-ads}@anchor{396}@anchor{gnat_rm/the_gnat_library id99}@anchor{397}
@section @code{GNAT.Registry} (@code{g-regist.ads})
package provided with the Win32Ada binding
@node GNAT Regpat g-regpat ads,GNAT Rewrite_Data g-rewdat ads,GNAT Registry g-regist ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id100}@anchor{398}@anchor{gnat_rm/the_gnat_library gnat-regpat-g-regpat-ads}@anchor{399}
+@anchor{gnat_rm/the_gnat_library gnat-regpat-g-regpat-ads}@anchor{398}@anchor{gnat_rm/the_gnat_library id100}@anchor{399}
@section @code{GNAT.Regpat} (@code{g-regpat.ads})
Henry Spencer (and binary compatible with this C library).
@node GNAT Rewrite_Data g-rewdat ads,GNAT Secondary_Stack_Info g-sestin ads,GNAT Regpat g-regpat ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id101}@anchor{39a}@anchor{gnat_rm/the_gnat_library gnat-rewrite-data-g-rewdat-ads}@anchor{39b}
+@anchor{gnat_rm/the_gnat_library gnat-rewrite-data-g-rewdat-ads}@anchor{39a}@anchor{gnat_rm/the_gnat_library id101}@anchor{39b}
@section @code{GNAT.Rewrite_Data} (@code{g-rewdat.ads})
@geindex Secondary Stack Info
-Provide the capability to query the high water mark of the current task's
+Provide the capability to query the high water mark of the current task’s
secondary stack.
@node GNAT Semaphores g-semaph ads,GNAT Serial_Communications g-sercom ads,GNAT Secondary_Stack_Info g-sestin ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id103}@anchor{39e}@anchor{gnat_rm/the_gnat_library gnat-semaphores-g-semaph-ads}@anchor{39f}
+@anchor{gnat_rm/the_gnat_library gnat-semaphores-g-semaph-ads}@anchor{39e}@anchor{gnat_rm/the_gnat_library id103}@anchor{39f}
@section @code{GNAT.Semaphores} (@code{g-semaph.ads})
in RFC 2104 and FIPS PUB 198.
@node GNAT SHA384 g-sha384 ads,GNAT SHA512 g-sha512 ads,GNAT SHA256 g-sha256 ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id108}@anchor{3a8}@anchor{gnat_rm/the_gnat_library gnat-sha384-g-sha384-ads}@anchor{3a9}
+@anchor{gnat_rm/the_gnat_library gnat-sha384-g-sha384-ads}@anchor{3a8}@anchor{gnat_rm/the_gnat_library id108}@anchor{3a9}
@section @code{GNAT.SHA384} (@code{g-sha384.ads})
in RFC 2104 and FIPS PUB 198.
@node GNAT SHA512 g-sha512 ads,GNAT Signals g-signal ads,GNAT SHA384 g-sha384 ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id109}@anchor{3aa}@anchor{gnat_rm/the_gnat_library gnat-sha512-g-sha512-ads}@anchor{3ab}
+@anchor{gnat_rm/the_gnat_library gnat-sha512-g-sha512-ads}@anchor{3aa}@anchor{gnat_rm/the_gnat_library id109}@anchor{3ab}
@section @code{GNAT.SHA512} (@code{g-sha512.ads})
efficient algorithm developed by Robert Dewar for the SPITBOL system.
@node GNAT Spitbol g-spitbo ads,GNAT Spitbol Table_Boolean g-sptabo ads,GNAT Spitbol Patterns g-spipat ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id116}@anchor{3b8}@anchor{gnat_rm/the_gnat_library gnat-spitbol-g-spitbo-ads}@anchor{3b9}
+@anchor{gnat_rm/the_gnat_library gnat-spitbol-g-spitbo-ads}@anchor{3b8}@anchor{gnat_rm/the_gnat_library id116}@anchor{3b9}
@section @code{GNAT.Spitbol} (@code{g-spitbo.ads})
from string to integer values.
@node GNAT Spitbol Table_VString g-sptavs ads,GNAT SSE g-sse ads,GNAT Spitbol Table_Integer g-sptain ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id119}@anchor{3be}@anchor{gnat_rm/the_gnat_library gnat-spitbol-table-vstring-g-sptavs-ads}@anchor{3bf}
+@anchor{gnat_rm/the_gnat_library gnat-spitbol-table-vstring-g-sptavs-ads}@anchor{3be}@anchor{gnat_rm/the_gnat_library id119}@anchor{3bf}
@section @code{GNAT.Spitbol.Table_VString} (@code{g-sptavs.ads})
maps from strings to strings.
@node GNAT SSE g-sse ads,GNAT SSE Vector_Types g-ssvety ads,GNAT Spitbol Table_VString g-sptavs ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id120}@anchor{3c0}@anchor{gnat_rm/the_gnat_library gnat-sse-g-sse-ads}@anchor{3c1}
+@anchor{gnat_rm/the_gnat_library gnat-sse-g-sse-ads}@anchor{3c0}@anchor{gnat_rm/the_gnat_library id120}@anchor{3c1}
@section @code{GNAT.SSE} (@code{g-sse.ads})
type and the hash result type are parameters.
@node GNAT Strings g-string ads,GNAT String_Split g-strspl ads,GNAT String_Hash g-strhas ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id123}@anchor{3c6}@anchor{gnat_rm/the_gnat_library gnat-strings-g-string-ads}@anchor{3c7}
+@anchor{gnat_rm/the_gnat_library gnat-strings-g-string-ads}@anchor{3c6}@anchor{gnat_rm/the_gnat_library id123}@anchor{3c7}
@section @code{GNAT.Strings} (@code{g-string.ads})
@code{GNAT.Array_Split}.
@node GNAT Table g-table ads,GNAT Task_Lock g-tasloc ads,GNAT String_Split g-strspl ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id125}@anchor{3ca}@anchor{gnat_rm/the_gnat_library gnat-table-g-table-ads}@anchor{3cb}
+@anchor{gnat_rm/the_gnat_library gnat-table-g-table-ads}@anchor{3ca}@anchor{gnat_rm/the_gnat_library id125}@anchor{3cb}
@section @code{GNAT.Table} (@code{g-table.ads})
used to define dynamic instances of the table.
@node GNAT Task_Lock g-tasloc ads,GNAT Time_Stamp g-timsta ads,GNAT Table g-table ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id126}@anchor{3cc}@anchor{gnat_rm/the_gnat_library gnat-task-lock-g-tasloc-ads}@anchor{3cd}
+@anchor{gnat_rm/the_gnat_library gnat-task-lock-g-tasloc-ads}@anchor{3cc}@anchor{gnat_rm/the_gnat_library id126}@anchor{3cd}
@section @code{GNAT.Task_Lock} (@code{g-tasloc.ads})
between tasks is very rarely expected.
@node GNAT Time_Stamp g-timsta ads,GNAT Threads g-thread ads,GNAT Task_Lock g-tasloc ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id127}@anchor{3ce}@anchor{gnat_rm/the_gnat_library gnat-time-stamp-g-timsta-ads}@anchor{3cf}
+@anchor{gnat_rm/the_gnat_library gnat-time-stamp-g-timsta-ads}@anchor{3ce}@anchor{gnat_rm/the_gnat_library id127}@anchor{3cf}
@section @code{GNAT.Time_Stamp} (@code{g-timsta.ads})
environment which then accesses Ada code.
@node GNAT Traceback g-traceb ads,GNAT Traceback Symbolic g-trasym ads,GNAT Threads g-thread ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id129}@anchor{3d2}@anchor{gnat_rm/the_gnat_library gnat-traceback-g-traceb-ads}@anchor{3d3}
+@anchor{gnat_rm/the_gnat_library gnat-traceback-g-traceb-ads}@anchor{3d2}@anchor{gnat_rm/the_gnat_library id129}@anchor{3d3}
@section @code{GNAT.Traceback} (@code{g-traceb.ads})
in various debugging situations.
@node GNAT Traceback Symbolic g-trasym ads,GNAT UTF_32 g-table ads,GNAT Traceback g-traceb ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id130}@anchor{3d4}@anchor{gnat_rm/the_gnat_library gnat-traceback-symbolic-g-trasym-ads}@anchor{3d5}
+@anchor{gnat_rm/the_gnat_library gnat-traceback-symbolic-g-trasym-ads}@anchor{3d4}@anchor{gnat_rm/the_gnat_library id130}@anchor{3d5}
@section @code{GNAT.Traceback.Symbolic} (@code{g-trasym.ads})
@geindex Trace back facilities
@node GNAT UTF_32 g-table ads,GNAT Wide_Spelling_Checker g-u3spch ads,GNAT Traceback Symbolic g-trasym ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id131}@anchor{3d6}@anchor{gnat_rm/the_gnat_library gnat-utf-32-g-table-ads}@anchor{3d7}
+@anchor{gnat_rm/the_gnat_library gnat-utf-32-g-table-ads}@anchor{3d6}@anchor{gnat_rm/the_gnat_library id131}@anchor{3d7}
@section @code{GNAT.UTF_32} (@code{g-table.ads})
near misspelling of another wide string.
@node GNAT Wide_String_Split g-wistsp ads,GNAT Wide_Wide_Spelling_Checker g-zspche ads,GNAT Wide_Spelling_Checker g-wispch ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id134}@anchor{3dc}@anchor{gnat_rm/the_gnat_library gnat-wide-string-split-g-wistsp-ads}@anchor{3dd}
+@anchor{gnat_rm/the_gnat_library gnat-wide-string-split-g-wistsp-ads}@anchor{3dc}@anchor{gnat_rm/the_gnat_library id134}@anchor{3dd}
@section @code{GNAT.Wide_String_Split} (@code{g-wistsp.ads})
@code{GNAT.Array_Split}.
@node Interfaces C Extensions i-cexten ads,Interfaces C Streams i-cstrea ads,GNAT Wide_Wide_String_Split g-zistsp ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library interfaces-c-extensions-i-cexten-ads}@anchor{3e2}@anchor{gnat_rm/the_gnat_library id137}@anchor{3e3}
+@anchor{gnat_rm/the_gnat_library id137}@anchor{3e2}@anchor{gnat_rm/the_gnat_library interfaces-c-extensions-i-cexten-ads}@anchor{3e3}
@section @code{Interfaces.C.Extensions} (@code{i-cexten.ads})
on C streams.
@node Interfaces Packed_Decimal i-pacdec ads,Interfaces VxWorks i-vxwork ads,Interfaces C Streams i-cstrea ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library interfaces-packed-decimal-i-pacdec-ads}@anchor{3e6}@anchor{gnat_rm/the_gnat_library id139}@anchor{3e7}
+@anchor{gnat_rm/the_gnat_library id139}@anchor{3e6}@anchor{gnat_rm/the_gnat_library interfaces-packed-decimal-i-pacdec-ads}@anchor{3e7}
@section @code{Interfaces.Packed_Decimal} (@code{i-pacdec.ads})
mainframes.
@node Interfaces VxWorks i-vxwork ads,Interfaces VxWorks Int_Connection i-vxinco ads,Interfaces Packed_Decimal i-pacdec ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library interfaces-vxworks-i-vxwork-ads}@anchor{3e8}@anchor{gnat_rm/the_gnat_library id140}@anchor{3e9}
+@anchor{gnat_rm/the_gnat_library id140}@anchor{3e8}@anchor{gnat_rm/the_gnat_library interfaces-vxworks-i-vxwork-ads}@anchor{3e9}
@section @code{Interfaces.VxWorks} (@code{i-vxwork.ads})
VxWorks hardware interrupt facilities.
@node Interfaces VxWorks Int_Connection i-vxinco ads,Interfaces VxWorks IO i-vxwoio ads,Interfaces VxWorks i-vxwork ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library interfaces-vxworks-int-connection-i-vxinco-ads}@anchor{3ea}@anchor{gnat_rm/the_gnat_library id141}@anchor{3eb}
+@anchor{gnat_rm/the_gnat_library id141}@anchor{3ea}@anchor{gnat_rm/the_gnat_library interfaces-vxworks-int-connection-i-vxinco-ads}@anchor{3eb}
@section @code{Interfaces.VxWorks.Int_Connection} (@code{i-vxinco.ads})
handlers.
@node Interfaces VxWorks IO i-vxwoio ads,System Address_Image s-addima ads,Interfaces VxWorks Int_Connection i-vxinco ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library interfaces-vxworks-io-i-vxwoio-ads}@anchor{3ec}@anchor{gnat_rm/the_gnat_library id142}@anchor{3ed}
+@anchor{gnat_rm/the_gnat_library id142}@anchor{3ec}@anchor{gnat_rm/the_gnat_library interfaces-vxworks-io-i-vxwoio-ads}@anchor{3ed}
@section @code{Interfaces.VxWorks.IO} (@code{i-vxwoio.ads})
to enable the use of Get_Immediate under VxWorks.
@node System Address_Image s-addima ads,System Assertions s-assert ads,Interfaces VxWorks IO i-vxwoio ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library system-address-image-s-addima-ads}@anchor{3ee}@anchor{gnat_rm/the_gnat_library id143}@anchor{3ef}
+@anchor{gnat_rm/the_gnat_library id143}@anchor{3ee}@anchor{gnat_rm/the_gnat_library system-address-image-s-addima-ads}@anchor{3ef}
@section @code{System.Address_Image} (@code{s-addima.ads})
x86, and x86_64 platforms.
@node System Memory s-memory ads,System Multiprocessors s-multip ads,System Atomic_Counters s-atocou ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library system-memory-s-memory-ads}@anchor{3f4}@anchor{gnat_rm/the_gnat_library id146}@anchor{3f5}
+@anchor{gnat_rm/the_gnat_library id146}@anchor{3f4}@anchor{gnat_rm/the_gnat_library system-memory-s-memory-ads}@anchor{3f5}
@section @code{System.Memory} (@code{s-memory.ads})
technically an implementation-defined addition).
@node System Multiprocessors Dispatching_Domains s-mudido ads,System Partition_Interface s-parint ads,System Multiprocessors s-multip ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library system-multiprocessors-dispatching-domains-s-mudido-ads}@anchor{3f8}@anchor{gnat_rm/the_gnat_library id148}@anchor{3f9}
+@anchor{gnat_rm/the_gnat_library id148}@anchor{3f8}@anchor{gnat_rm/the_gnat_library system-multiprocessors-dispatching-domains-s-mudido-ads}@anchor{3f9}
@section @code{System.Multiprocessors.Dispatching_Domains} (@code{s-mudido.ads})
do any automatic reclamation.
@node System Pool_Local s-pooloc ads,System Restrictions s-restri ads,System Pool_Global s-pooglo ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library system-pool-local-s-pooloc-ads}@anchor{3fe}@anchor{gnat_rm/the_gnat_library id151}@anchor{3ff}
+@anchor{gnat_rm/the_gnat_library id151}@anchor{3fe}@anchor{gnat_rm/the_gnat_library system-pool-local-s-pooloc-ads}@anchor{3ff}
@section @code{System.Pool_Local} (@code{s-pooloc.ads})
are violated by one or more packages in the partition.
@node System Rident s-rident ads,System Strings Stream_Ops s-ststop ads,System Restrictions s-restri ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library system-rident-s-rident-ads}@anchor{402}@anchor{gnat_rm/the_gnat_library id153}@anchor{403}
+@anchor{gnat_rm/the_gnat_library id153}@anchor{402}@anchor{gnat_rm/the_gnat_library system-rident-s-rident-ads}@anchor{403}
@section @code{System.Rident} (@code{s-rident.ads})
package can be used directly by application programs.
@node System Unsigned_Types s-unstyp ads,System Wch_Cnv s-wchcnv ads,System Strings Stream_Ops s-ststop ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library system-unsigned-types-s-unstyp-ads}@anchor{406}@anchor{gnat_rm/the_gnat_library id155}@anchor{407}
+@anchor{gnat_rm/the_gnat_library id155}@anchor{406}@anchor{gnat_rm/the_gnat_library system-unsigned-types-s-unstyp-ads}@anchor{407}
@section @code{System.Unsigned_Types} (@code{s-unstyp.ads})
used by the compiler in connection with packed array types.
@node System Wch_Cnv s-wchcnv ads,System Wch_Con s-wchcon ads,System Unsigned_Types s-unstyp ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library system-wch-cnv-s-wchcnv-ads}@anchor{408}@anchor{gnat_rm/the_gnat_library id156}@anchor{409}
+@anchor{gnat_rm/the_gnat_library id156}@anchor{408}@anchor{gnat_rm/the_gnat_library system-wch-cnv-s-wchcnv-ads}@anchor{409}
@section @code{System.Wch_Cnv} (@code{s-wchcnv.ads})
the package @code{System.Wch_Cnv}.
@node Interfacing to Other Languages,Specialized Needs Annexes,The GNAT Library,Top
-@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-other-languages}@anchor{11}@anchor{gnat_rm/interfacing_to_other_languages doc}@anchor{40c}@anchor{gnat_rm/interfacing_to_other_languages id1}@anchor{40d}
+@anchor{gnat_rm/interfacing_to_other_languages doc}@anchor{40c}@anchor{gnat_rm/interfacing_to_other_languages id1}@anchor{40d}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-other-languages}@anchor{11}
@chapter Interfacing to Other Languages
@end menu
@node Interfacing to C,Interfacing to C++,,Interfacing to Other Languages
-@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-c}@anchor{40e}@anchor{gnat_rm/interfacing_to_other_languages id2}@anchor{40f}
+@anchor{gnat_rm/interfacing_to_other_languages id2}@anchor{40e}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-c}@anchor{40f}
@section Interfacing to C
@end itemize
@node Interfacing to C++,Interfacing to COBOL,Interfacing to C,Interfacing to Other Languages
-@anchor{gnat_rm/interfacing_to_other_languages id4}@anchor{410}@anchor{gnat_rm/interfacing_to_other_languages id3}@anchor{47}
+@anchor{gnat_rm/interfacing_to_other_languages id3}@anchor{47}@anchor{gnat_rm/interfacing_to_other_languages id4}@anchor{410}
@section Interfacing to C++
order as required for convenient interface to Fortran.
@node Interfacing to non-GNAT Ada code,,Interfacing to Fortran,Interfacing to Other Languages
-@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-non-gnat-ada-code}@anchor{415}@anchor{gnat_rm/interfacing_to_other_languages id7}@anchor{416}
+@anchor{gnat_rm/interfacing_to_other_languages id7}@anchor{415}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-non-gnat-ada-code}@anchor{416}
@section Interfacing to non-GNAT Ada code
types with fixed bounds.
@node Specialized Needs Annexes,Implementation of Specific Ada Features,Interfacing to Other Languages,Top
-@anchor{gnat_rm/specialized_needs_annexes specialized-needs-annexes}@anchor{12}@anchor{gnat_rm/specialized_needs_annexes doc}@anchor{417}@anchor{gnat_rm/specialized_needs_annexes id1}@anchor{418}
+@anchor{gnat_rm/specialized_needs_annexes doc}@anchor{417}@anchor{gnat_rm/specialized_needs_annexes id1}@anchor{418}@anchor{gnat_rm/specialized_needs_annexes specialized-needs-annexes}@anchor{12}
@chapter Specialized Needs Annexes
@end table
@node Implementation of Specific Ada Features,Implementation of Ada 2012 Features,Specialized Needs Annexes,Top
-@anchor{gnat_rm/implementation_of_specific_ada_features implementation-of-specific-ada-features}@anchor{13}@anchor{gnat_rm/implementation_of_specific_ada_features doc}@anchor{419}@anchor{gnat_rm/implementation_of_specific_ada_features id1}@anchor{41a}
+@anchor{gnat_rm/implementation_of_specific_ada_features doc}@anchor{419}@anchor{gnat_rm/implementation_of_specific_ada_features id1}@anchor{41a}@anchor{gnat_rm/implementation_of_specific_ada_features implementation-of-specific-ada-features}@anchor{13}
@chapter Implementation of Specific Ada Features
@end menu
@node Machine Code Insertions,GNAT Implementation of Tasking,,Implementation of Specific Ada Features
-@anchor{gnat_rm/implementation_of_specific_ada_features machine-code-insertions}@anchor{166}@anchor{gnat_rm/implementation_of_specific_ada_features id2}@anchor{41b}
+@anchor{gnat_rm/implementation_of_specific_ada_features id2}@anchor{41b}@anchor{gnat_rm/implementation_of_specific_ada_features machine-code-insertions}@anchor{166}
@section Machine Code Insertions
the RTL, and are dependent on the configuration file used to build the
GCC back end. If there are no output operands, then this argument may
either be omitted, or explicitly given as @code{No_Output_Operands}.
-No support is provided for GNU C's symbolic names for output parameters.
+No support is provided for GNU C’s symbolic names for output parameters.
The second argument of @code{my_float'Asm_Output} functions as
though it were an @code{out} parameter, which is a little curious, but
value to be used as the input argument. The possible values for the
constraint are the same as those used in the RTL, and are dependent on
the configuration file used to built the GCC back end.
-No support is provided for GNU C's symbolic names for input parameters.
+No support is provided for GNU C’s symbolic names for input parameters.
If there are no input operands, this argument may either be omitted, or
explicitly given as @code{No_Input_Operands}. The fourth argument, not
that is missing either input or output operands or to avoid unwanted
optimizations. A warning is generated if this advice is not followed.
-No support is provided for GNU C's @code{asm goto} feature.
+No support is provided for GNU C’s @code{asm goto} feature.
The @code{Asm} subprograms may be used in two ways. First the procedure
forms can be used anywhere a procedure call would be valid, and
-correspond to what the RM calls 'intrinsic' routines. Such calls can
+correspond to what the RM calls ‘intrinsic’ routines. Such calls can
be used to intersperse machine instructions with other Ada statements.
Second, the function forms, which return a dummy value of the limited
private type @code{Asm_Insn}, can be used in code statements, and indeed
qualification is required.
@node GNAT Implementation of Tasking,GNAT Implementation of Shared Passive Packages,Machine Code Insertions,Implementation of Specific Ada Features
-@anchor{gnat_rm/implementation_of_specific_ada_features id3}@anchor{41c}@anchor{gnat_rm/implementation_of_specific_ada_features gnat-implementation-of-tasking}@anchor{41d}
+@anchor{gnat_rm/implementation_of_specific_ada_features gnat-implementation-of-tasking}@anchor{41c}@anchor{gnat_rm/implementation_of_specific_ada_features id3}@anchor{41d}
@section GNAT Implementation of Tasking
@end menu
@node Mapping Ada Tasks onto the Underlying Kernel Threads,Ensuring Compliance with the Real-Time Annex,,GNAT Implementation of Tasking
-@anchor{gnat_rm/implementation_of_specific_ada_features mapping-ada-tasks-onto-the-underlying-kernel-threads}@anchor{41e}@anchor{gnat_rm/implementation_of_specific_ada_features id4}@anchor{41f}
+@anchor{gnat_rm/implementation_of_specific_ada_features id4}@anchor{41e}@anchor{gnat_rm/implementation_of_specific_ada_features mapping-ada-tasks-onto-the-underlying-kernel-threads}@anchor{41f}
@subsection Mapping Ada Tasks onto the Underlying Kernel Threads
-GNAT's run-time support comprises two layers:
+GNAT’s run-time support comprises two layers:
@itemize *
GNULL (GNAT Low-level Library)
@end itemize
-In GNAT, Ada's tasking services rely on a platform and OS independent
+In GNAT, Ada’s tasking services rely on a platform and OS independent
layer known as GNARL. This code is responsible for implementing the
-correct semantics of Ada's task creation, rendezvous, protected
+correct semantics of Ada’s task creation, rendezvous, protected
operations etc.
-GNARL decomposes Ada's tasking semantics into simpler lower level
+GNARL decomposes Ada’s tasking semantics into simpler lower level
operations such as create a thread, set the priority of a thread,
yield, create a lock, lock/unlock, etc. The spec for these low-level
operations constitutes GNULLI, the GNULL Interface. This interface is
@geindex Forking a new process
@node Ensuring Compliance with the Real-Time Annex,Support for Locking Policies,Mapping Ada Tasks onto the Underlying Kernel Threads,GNAT Implementation of Tasking
-@anchor{gnat_rm/implementation_of_specific_ada_features id5}@anchor{420}@anchor{gnat_rm/implementation_of_specific_ada_features ensuring-compliance-with-the-real-time-annex}@anchor{421}
+@anchor{gnat_rm/implementation_of_specific_ada_features ensuring-compliance-with-the-real-time-annex}@anchor{420}@anchor{gnat_rm/implementation_of_specific_ada_features id5}@anchor{421}
@subsection Ensuring Compliance with the Real-Time Annex
@code{Concurrent_Readers_Locking} is supported on Linux.
Notes about @code{Ceiling_Locking} on Linux:
-If the process is running as 'root', ceiling locking is used.
+If the process is running as ‘root’, ceiling locking is used.
If the capabilities facility is installed
-("sudo apt-get --assume-yes install libcap-dev" on Ubuntu,
+(“sudo apt-get –assume-yes install libcap-dev” on Ubuntu,
for example),
and the program is linked against that library
-("-largs -lcap"),
+(“-largs -lcap”),
and the executable file has the cap_sys_nice capability
-("sudo /sbin/setcap cap_sys_nice=ep executable_file_name"),
+(“sudo /sbin/setcap cap_sys_nice=ep executable_file_name”),
then ceiling locking is used.
Otherwise, the @code{Ceiling_Locking} policy is ignored.
@node GNAT Implementation of Shared Passive Packages,Code Generation for Array Aggregates,GNAT Implementation of Tasking,Implementation of Specific Ada Features
-@anchor{gnat_rm/implementation_of_specific_ada_features id6}@anchor{423}@anchor{gnat_rm/implementation_of_specific_ada_features gnat-implementation-of-shared-passive-packages}@anchor{424}
+@anchor{gnat_rm/implementation_of_specific_ada_features gnat-implementation-of-shared-passive-packages}@anchor{423}@anchor{gnat_rm/implementation_of_specific_ada_features id6}@anchor{424}
@section GNAT Implementation of Shared Passive Packages
@end menu
@node Static constant aggregates with static bounds,Constant aggregates with unconstrained nominal types,,Code Generation for Array Aggregates
-@anchor{gnat_rm/implementation_of_specific_ada_features static-constant-aggregates-with-static-bounds}@anchor{427}@anchor{gnat_rm/implementation_of_specific_ada_features id8}@anchor{428}
+@anchor{gnat_rm/implementation_of_specific_ada_features id8}@anchor{427}@anchor{gnat_rm/implementation_of_specific_ada_features static-constant-aggregates-with-static-bounds}@anchor{428}
@subsection Static constant aggregates with static bounds
@end example
@node Aggregates with static bounds,Aggregates with nonstatic bounds,Constant aggregates with unconstrained nominal types,Code Generation for Array Aggregates
-@anchor{gnat_rm/implementation_of_specific_ada_features id10}@anchor{42b}@anchor{gnat_rm/implementation_of_specific_ada_features aggregates-with-static-bounds}@anchor{42c}
+@anchor{gnat_rm/implementation_of_specific_ada_features aggregates-with-static-bounds}@anchor{42b}@anchor{gnat_rm/implementation_of_specific_ada_features id10}@anchor{42c}
@subsection Aggregates with static bounds
@end example
@node Aggregates with nonstatic bounds,Aggregates in assignment statements,Aggregates with static bounds,Code Generation for Array Aggregates
-@anchor{gnat_rm/implementation_of_specific_ada_features id11}@anchor{42d}@anchor{gnat_rm/implementation_of_specific_ada_features aggregates-with-nonstatic-bounds}@anchor{42e}
+@anchor{gnat_rm/implementation_of_specific_ada_features aggregates-with-nonstatic-bounds}@anchor{42d}@anchor{gnat_rm/implementation_of_specific_ada_features id11}@anchor{42e}
@subsection Aggregates with nonstatic bounds
compatible subtypes.
@node Aggregates in assignment statements,,Aggregates with nonstatic bounds,Code Generation for Array Aggregates
-@anchor{gnat_rm/implementation_of_specific_ada_features id12}@anchor{42f}@anchor{gnat_rm/implementation_of_specific_ada_features aggregates-in-assignment-statements}@anchor{430}
+@anchor{gnat_rm/implementation_of_specific_ada_features aggregates-in-assignment-statements}@anchor{42f}@anchor{gnat_rm/implementation_of_specific_ada_features id12}@anchor{430}
@subsection Aggregates in assignment statements
This maximum size approach
has been a source of surprise to some users, who expect the default
values of the discriminants to determine the size reserved for an
-unconstrained object: "If the default is 15, why should the object occupy
-a larger size?"
+unconstrained object: “If the default is 15, why should the object occupy
+a larger size?”
The answer, of course, is that the discriminant may be later modified,
and its full range of values must be taken into account. This is why the
declaration:
an attempt to create @code{Too_Large} will raise @code{Storage_Error},
because the required size includes @code{Positive'Last}
bytes. As the first example indicates, the proper approach is to declare an
-index type of 'reasonable' range so that unconstrained objects are not too
+index type of ‘reasonable’ range so that unconstrained objects are not too
large.
One final wrinkle: if the object is declared to be @code{aliased}, or if it is
remain invariant.
@node Strict Conformance to the Ada Reference Manual,,The Size of Discriminated Records with Default Discriminants,Implementation of Specific Ada Features
-@anchor{gnat_rm/implementation_of_specific_ada_features strict-conformance-to-the-ada-reference-manual}@anchor{433}@anchor{gnat_rm/implementation_of_specific_ada_features id14}@anchor{434}
+@anchor{gnat_rm/implementation_of_specific_ada_features id14}@anchor{433}@anchor{gnat_rm/implementation_of_specific_ada_features strict-conformance-to-the-ada-reference-manual}@anchor{434}
@section Strict Conformance to the Ada Reference Manual
infinite and NaN values are properly generated.
@node Implementation of Ada 2012 Features,Obsolescent Features,Implementation of Specific Ada Features,Top
-@anchor{gnat_rm/implementation_of_ada_2012_features doc}@anchor{435}@anchor{gnat_rm/implementation_of_ada_2012_features implementation-of-ada-2012-features}@anchor{14}@anchor{gnat_rm/implementation_of_ada_2012_features id1}@anchor{436}
+@anchor{gnat_rm/implementation_of_ada_2012_features doc}@anchor{435}@anchor{gnat_rm/implementation_of_ada_2012_features id1}@anchor{436}@anchor{gnat_rm/implementation_of_ada_2012_features implementation-of-ada-2012-features}@anchor{14}
@chapter Implementation of Ada 2012 Features
implemented the feature, or implemented it as soon as it appeared as a
binding interpretation.
-Each feature corresponds to an Ada Issue ('AI') approved by the Ada
+Each feature corresponds to an Ada Issue (‘AI’) approved by the Ada
standardization group (ISO/IEC JTC1/SC22/WG9) for inclusion in Ada 2012.
The features are ordered based on the relevant sections of the Ada
-Reference Manual ("RM"). When a given AI relates to multiple points
+Reference Manual (“RM”). When a given AI relates to multiple points
in the RM, the earliest is used.
A complete description of the AIs may be found in
@itemize *
@item
-@emph{AI-0080 'View of' not needed if clear from context (0000-00-00)}
+@emph{AI-0080 ‘View of’ not needed if clear from context (0000-00-00)}
This is an editorial change only, described as non-testable in the AI.
@emph{AI-0183 Aspect specifications (2010-08-16)}
Aspect specifications have been fully implemented except for pre and post-
-conditions, and type invariants, which have their own separate AI's. All
+conditions, and type invariants, which have their own separate AI’s. All
forms of declarations listed in the AI are supported. The following is a
list of the aspects supported (with GNAT implementation aspects marked)
@end itemize
@tab
--- GNAT
+– GNAT
@item
@tab
--- GNAT
+– GNAT
@item
@tab
--- GNAT
+– GNAT
@item
@tab
--- GNAT
+– GNAT
@item
@tab
--- GNAT
+– GNAT
@item
@tab
--- GNAT
+– GNAT
@item
@tab
--- GNAT
+– GNAT
@item
@tab
--- GNAT
+– GNAT
@item
@tab
--- GNAT
+– GNAT
@item
@tab
--- GNAT
+– GNAT
@item
@tab
--- GNAT
+– GNAT
@item
@tab
--- GNAT
+– GNAT
@item
@tab
--- GNAT
+– GNAT
@item
@tab
--- GNAT
+– GNAT
@item
@tab
--- GNAT
+– GNAT
@item
@tab
--- GNAT
+– GNAT
@item
@tab
--- GNAT
+– GNAT
@item
@tab
--- GNAT
+– GNAT
@item
@tab
--- GNAT
+– GNAT
@item
@tab
--- GNAT
+– GNAT
@end multitable
@item
@emph{AI-0128 Inequality is a primitive operation (0000-00-00)}
-If an equality operator ("=") is declared for a type, then the implicitly
-declared inequality operator ("/=") is a primitive operation of the type.
+If an equality operator (“=”) is declared for a type, then the implicitly
+declared inequality operator (“/=”) is a primitive operation of the type.
This is the only reasonable interpretation, and is the one always implemented
by GNAT, but the RM was not entirely clear in making this point.
@emph{AI-0093 Additional rules use immutably limited (0000-00-00)}
This is an editorial change only, to make more widespread use of the Ada 2012
-'immutably limited'.
+‘immutably limited’.
RM References: 3.03 (23.4/3)
@end itemize
Ada 2012 relaxes the restriction that forbids discriminants of tagged types
to have default expressions by allowing them when the type is limited. It
is often useful to define a default value for a discriminant even though
-it can't be changed by assignment.
+it can’t be changed by assignment.
RM References: 3.07 (9.1/2) 3.07.02 (3)
@end itemize
@emph{AI-0076 function with controlling result (0000-00-00)}
This is an editorial change only. The RM defines calls with controlling
-results, but uses the term 'function with controlling result' without an
+results, but uses the term ‘function with controlling result’ without an
explicit definition.
RM References: 3.09.02 (2/2)
@item
@emph{AI-0099 Tag determines whether finalization needed (0000-00-00)}
-This AI clarifies that 'needs finalization' is part of dynamic semantics,
+This AI clarifies that ‘needs finalization’ is part of dynamic semantics,
and therefore depends on the run-time characteristics of an object (i.e. its
-tag) and not on its nominal type. As the AI indicates: "we do not expect
-this to affect any implementation'@w{'}.
+tag) and not on its nominal type. As the AI indicates: “we do not expect
+this to affect any implementation’’.
RM References: 7.06.01 (6) 7.06.01 (7) 7.06.01 (8) 7.06.01 (9/2)
@end itemize
@itemize *
@item
-@emph{AI-0072 Task signalling using 'Terminated (0000-00-00)}
+@emph{AI-0072 Task signalling using ‘Terminated (0000-00-00)}
This AI clarifies that task signalling for reading @code{'Terminated} only
occurs if the result is True. GNAT semantics has always been consistent with
@emph{AI-0219 Pure permissions and limited parameters (2010-05-25)}
This AI refines the rules for the cases with limited parameters which do not
-allow the implementations to omit 'redundant'. GNAT now properly conforms
+allow the implementations to omit ‘redundant’. GNAT now properly conforms
to the requirements of this binding interpretation.
RM References: 10.02.01 (18/2)
@itemize *
@item
-@emph{AI-0109 Redundant check in S'Class'Input (0000-00-00)}
+@emph{AI-0109 Redundant check in S’Class’Input (0000-00-00)}
This AI is an editorial change only. It removes the need for a tag check
that can never fail.
@item
@emph{AI-0017 Freezing and incomplete types (0000-00-00)}
-So-called 'Taft-amendment types' (i.e., types that are completed in package
+So-called ‘Taft-amendment types’ (i.e., types that are completed in package
bodies) are not frozen by the occurrence of bodies in the
enclosing declarative part. GNAT always implemented this properly.
@end itemize
@node Obsolescent Features,Compatibility and Porting Guide,Implementation of Ada 2012 Features,Top
-@anchor{gnat_rm/obsolescent_features id1}@anchor{437}@anchor{gnat_rm/obsolescent_features doc}@anchor{438}@anchor{gnat_rm/obsolescent_features obsolescent-features}@anchor{15}
+@anchor{gnat_rm/obsolescent_features doc}@anchor{437}@anchor{gnat_rm/obsolescent_features id1}@anchor{438}@anchor{gnat_rm/obsolescent_features obsolescent-features}@anchor{15}
@chapter Obsolescent Features
The pragma @code{No_Run_Time} is used to achieve an affect similar
-to the use of the "Zero Foot Print" configurable run time, but without
+to the use of the “Zero Foot Print” configurable run time, but without
requiring a specially configured run time. The result of using this
pragma, which must be used for all units in a partition, is to restrict
the use of any language features requiring run-time support code. The
is part of the new Ada 2005 standard.
@node pragma Restricted_Run_Time,pragma Task_Info,pragma Ravenscar,Obsolescent Features
-@anchor{gnat_rm/obsolescent_features pragma-restricted-run-time}@anchor{43d}@anchor{gnat_rm/obsolescent_features id4}@anchor{43e}
+@anchor{gnat_rm/obsolescent_features id4}@anchor{43d}@anchor{gnat_rm/obsolescent_features pragma-restricted-run-time}@anchor{43e}
@section pragma Restricted_Run_Time
this kind of implementation dependent addition.
@node pragma Task_Info,package System Task_Info s-tasinf ads,pragma Restricted_Run_Time,Obsolescent Features
-@anchor{gnat_rm/obsolescent_features pragma-task-info}@anchor{43f}@anchor{gnat_rm/obsolescent_features id5}@anchor{440}
+@anchor{gnat_rm/obsolescent_features id5}@anchor{43f}@anchor{gnat_rm/obsolescent_features pragma-task-info}@anchor{440}
@section pragma Task_Info
This package provides target dependent functionality that is used
to support the @code{Task_Info} pragma. The predefined Ada package
@code{System.Multiprocessors} and the @code{CPU} aspect now provide a
-standard replacement for GNAT's @code{Task_Info} functionality.
+standard replacement for GNAT’s @code{Task_Info} functionality.
@node Compatibility and Porting Guide,GNU Free Documentation License,Obsolescent Features,Top
-@anchor{gnat_rm/compatibility_and_porting_guide compatibility-and-porting-guide}@anchor{16}@anchor{gnat_rm/compatibility_and_porting_guide doc}@anchor{443}@anchor{gnat_rm/compatibility_and_porting_guide id1}@anchor{444}
+@anchor{gnat_rm/compatibility_and_porting_guide doc}@anchor{443}@anchor{gnat_rm/compatibility_and_porting_guide compatibility-and-porting-guide}@anchor{16}@anchor{gnat_rm/compatibility_and_porting_guide id1}@anchor{444}
@chapter Compatibility and Porting Guide
then the implementation is allowed to choose -128.0 .. +127.0 if it
likes, but is not required to do so.
-This leads to possible portability problems, so let's have a closer
+This leads to possible portability problems, so let’s have a closer
look at this, and figure out how to avoid these problems.
First, why does this freedom exist, and why would an implementation
that means 16 bits on all machines). But if the implementation chooses
the +127.0 bound then it can fit values of the type in 8 bits.
-Why not make the user write +127.0 if that's what is wanted?
+Why not make the user write +127.0 if that’s what is wanted?
The rationale is that if you are thinking of fixed point
-as a kind of 'poor man's floating-point', then you don't want
+as a kind of ‘poor man’s floating-point’, then you don’t want
to be thinking about the scaled integers that are used in its
-representation. Let's take another example:
+representation. Let’s take another example:
@example
type F2 is delta 2.0**(-15) range -1.0 .. +1.0;
@end example
and the Ada language design team felt that this was too annoying
-to require. We don't need to debate this decision at this point,
+to require. We don’t need to debate this decision at this point,
since it is well established (the rule about narrowing the ranges
dates to Ada 83).
for Char in 'A' .. 'Z' loop ... end loop;
@end example
-The problem is that 'A' and 'Z' could be from either
+The problem is that ‘A’ and ‘Z’ could be from either
@code{Character} or @code{Wide_Character}. The simplest correction
is to make the type explicit; e.g.:
as the actual for a generic formal private type, but then the instantiation
would be illegal if there were any instances of declarations of variables
of this type in the generic body. In Ada 95, to avoid this clear violation
-of the methodological principle known as the 'contract model',
+of the methodological principle known as the ‘contract model’,
the generic declaration explicitly indicates whether
or not such instantiations are permitted. If a generic formal parameter
has explicit unknown discriminants, indicated by using @code{(<>)} after the
@end itemize
@node More deterministic semantics,Changed semantics,Legal Ada 83 programs that are illegal in Ada 95,Compatibility with Ada 83
-@anchor{gnat_rm/compatibility_and_porting_guide more-deterministic-semantics}@anchor{44b}@anchor{gnat_rm/compatibility_and_porting_guide id5}@anchor{44c}
+@anchor{gnat_rm/compatibility_and_porting_guide id5}@anchor{44b}@anchor{gnat_rm/compatibility_and_porting_guide more-deterministic-semantics}@anchor{44c}
@subsection More deterministic semantics
@end itemize
@node Changed semantics,Other language compatibility issues,More deterministic semantics,Compatibility with Ada 83
-@anchor{gnat_rm/compatibility_and_porting_guide id6}@anchor{44d}@anchor{gnat_rm/compatibility_and_porting_guide changed-semantics}@anchor{44e}
+@anchor{gnat_rm/compatibility_and_porting_guide changed-semantics}@anchor{44d}@anchor{gnat_rm/compatibility_and_porting_guide id6}@anchor{44e}
@subsection Changed semantics
@end itemize
@node Other language compatibility issues,,Changed semantics,Compatibility with Ada 83
-@anchor{gnat_rm/compatibility_and_porting_guide other-language-compatibility-issues}@anchor{44f}@anchor{gnat_rm/compatibility_and_porting_guide id7}@anchor{450}
+@anchor{gnat_rm/compatibility_and_porting_guide id7}@anchor{44f}@anchor{gnat_rm/compatibility_and_porting_guide other-language-compatibility-issues}@anchor{450}
@subsection Other language compatibility issues
in practice, it is usually advisable to make the necessary modifications
to the program to remove the need for using this switch.
See the @code{Compiling Different Versions of Ada} section in
-the @cite{GNAT User's Guide}.
+the @cite{GNAT User’s Guide}.
@item
Support for removed Ada 83 pragmas and attributes
@item
@emph{Fixed-point multiplication and division.}
-Certain expressions involving '*' or '/' for a fixed-point type, which
+Certain expressions involving ‘*’ or ‘/’ for a fixed-point type, which
were legal in Ada 95 and invoked the predefined versions of these operations,
are now ambiguous.
The ambiguity may be resolved either by applying a type conversion to the
@end itemize
@node Implementation-dependent characteristics,Compatibility with Other Ada Systems,Compatibility between Ada 95 and Ada 2005,Compatibility and Porting Guide
-@anchor{gnat_rm/compatibility_and_porting_guide implementation-dependent-characteristics}@anchor{453}@anchor{gnat_rm/compatibility_and_porting_guide id9}@anchor{454}
+@anchor{gnat_rm/compatibility_and_porting_guide id9}@anchor{453}@anchor{gnat_rm/compatibility_and_porting_guide implementation-dependent-characteristics}@anchor{454}
@section Implementation-dependent characteristics
@end menu
@node Implementation-defined pragmas,Implementation-defined attributes,,Implementation-dependent characteristics
-@anchor{gnat_rm/compatibility_and_porting_guide implementation-defined-pragmas}@anchor{455}@anchor{gnat_rm/compatibility_and_porting_guide id10}@anchor{456}
+@anchor{gnat_rm/compatibility_and_porting_guide id10}@anchor{455}@anchor{gnat_rm/compatibility_and_porting_guide implementation-defined-pragmas}@anchor{456}
@subsection Implementation-defined pragmas
these are a potential source of non-portability. All GNAT-defined pragmas
are described in @ref{7,,Implementation Defined Pragmas},
and these include several that are specifically
-intended to correspond to other vendors' Ada 83 pragmas.
+intended to correspond to other vendors’ Ada 83 pragmas.
For migrating from VADS, the pragma @code{Use_VADS_Size} may be useful.
For compatibility with HP Ada 83, GNAT supplies the pragmas
@code{Extend_System}, @code{Ident}, @code{Inline_Generic},
implementation. All GNAT-defined attributes are described in
@ref{8,,Implementation Defined Attributes},
and these include several that are specifically intended
-to correspond to other vendors' Ada 83 attributes. For migrating from VADS,
+to correspond to other vendors’ Ada 83 attributes. For migrating from VADS,
the attribute @code{VADS_Size} may be useful. For compatibility with HP
Ada 83, GNAT supplies the attributes @code{Bit}, @code{Machine_Size} and
@code{Type_Class}.
@node Libraries,Elaboration order,Implementation-defined attributes,Implementation-dependent characteristics
-@anchor{gnat_rm/compatibility_and_porting_guide libraries}@anchor{459}@anchor{gnat_rm/compatibility_and_porting_guide id12}@anchor{45a}
+@anchor{gnat_rm/compatibility_and_porting_guide id12}@anchor{459}@anchor{gnat_rm/compatibility_and_porting_guide libraries}@anchor{45a}
@subsection Libraries
The implementation can choose any elaboration order consistent with the unit
dependency relationship. This freedom means that some orders can result in
-Program_Error being raised due to an 'Access Before Elaboration': an attempt
+Program_Error being raised due to an ‘Access Before Elaboration’: an attempt
to invoke a subprogram before its body has been elaborated, or to instantiate
a generic before the generic body has been elaborated. By default GNAT
attempts to choose a safe order (one that will not encounter access before
needed. However, this can lead to the creation of elaboration circularities
and a resulting rejection of the program by gnatbind. This issue is
thoroughly described in the @emph{Elaboration Order Handling in GNAT} appendix
-in the @cite{GNAT User's Guide}.
+in the @cite{GNAT User’s Guide}.
In brief, there are several
ways to deal with this situation:
@end itemize
@node Target-specific aspects,,Elaboration order,Implementation-dependent characteristics
-@anchor{gnat_rm/compatibility_and_porting_guide target-specific-aspects}@anchor{45d}@anchor{gnat_rm/compatibility_and_porting_guide id14}@anchor{45e}
+@anchor{gnat_rm/compatibility_and_porting_guide id14}@anchor{45d}@anchor{gnat_rm/compatibility_and_porting_guide target-specific-aspects}@anchor{45e}
@subsection Target-specific aspects
Ada 2005 and Ada 2012) are sometimes
incompatible with typical Ada 83 compiler practices regarding implicit
packing, the meaning of the Size attribute, and the size of access values.
-GNAT's approach to these issues is described in @ref{45f,,Representation Clauses}.
+GNAT’s approach to these issues is described in @ref{45f,,Representation Clauses}.
@node Compatibility with Other Ada Systems,Representation Clauses,Implementation-dependent characteristics,Compatibility and Porting Guide
-@anchor{gnat_rm/compatibility_and_porting_guide id15}@anchor{460}@anchor{gnat_rm/compatibility_and_porting_guide compatibility-with-other-ada-systems}@anchor{461}
+@anchor{gnat_rm/compatibility_and_porting_guide compatibility-with-other-ada-systems}@anchor{460}@anchor{gnat_rm/compatibility_and_porting_guide id15}@anchor{461}
@section Compatibility with Other Ada Systems
@end itemize
@node Representation Clauses,Compatibility with HP Ada 83,Compatibility with Other Ada Systems,Compatibility and Porting Guide
-@anchor{gnat_rm/compatibility_and_porting_guide representation-clauses}@anchor{45f}@anchor{gnat_rm/compatibility_and_porting_guide id16}@anchor{462}
+@anchor{gnat_rm/compatibility_and_porting_guide id16}@anchor{462}@anchor{gnat_rm/compatibility_and_porting_guide representation-clauses}@anchor{45f}
@section Representation Clauses
packing of an array or record. This could cause expensive implicit
conversions for change of representation in the presence of derived
types, and the Ada design intends to avoid this possibility.
-Subsequent AI's were issued to make it clear that such implicit
+Subsequent AI’s were issued to make it clear that such implicit
change of representation in response to a Size clause is inadvisable,
and this recommendation is represented explicitly in the Ada 95 (and Ada 2005)
Reference Manuals as implementation advice that is followed by GNAT.
32 (since no sign bit is required). Some Ada 83 compilers gave 31, and
some 32 in this situation. This problem will usually show up as a compile
time error, but not always. It is a good idea to check all uses of the
-'Size attribute when porting Ada 83 code. The GNAT specific attribute
+‘Size attribute when porting Ada 83 code. The GNAT specific attribute
Object_Size can provide a useful way of duplicating the behavior of
some Ada 83 compiler systems.
and that therefore it will be the same size as a System.Address value. This
assumption is true for GNAT in most cases with one exception. For the case of
a pointer to an unconstrained array type (where the bounds may vary from one
-value of the access type to another), the default is to use a 'fat pointer',
+value of the access type to another), the default is to use a ‘fat pointer’,
which is represented as two separate pointers, one to the bounds, and one to
the array. This representation has a number of advantages, including improved
efficiency. However, it may cause some difficulties in porting existing Ada 83
code which makes the assumption that, for example, pointers fit in 32 bits on
a machine with 32-bit addressing.
-To get around this problem, GNAT also permits the use of 'thin pointers' for
+To get around this problem, GNAT also permits the use of ‘thin pointers’ for
access types in this case (where the designated type is an unconstrained array
type). These thin pointers are indeed the same size as a System.Address value.
To specify a thin pointer, use a size clause for the type, for example:
@end itemize
@node GNU Free Documentation License,Index,Compatibility and Porting Guide,Top
-@anchor{share/gnu_free_documentation_license gnu-fdl}@anchor{1}@anchor{share/gnu_free_documentation_license doc}@anchor{465}@anchor{share/gnu_free_documentation_license gnu-free-documentation-license}@anchor{466}
+@anchor{share/gnu_free_documentation_license doc}@anchor{465}@anchor{share/gnu_free_documentation_license gnu-fdl}@anchor{1}@anchor{share/gnu_free_documentation_license gnu-free-documentation-license}@anchor{466}
@chapter GNU Free Documentation License
@strong{Preamble}
The purpose of this License is to make a manual, textbook, or other
-functional and useful document "free" in the sense of freedom: to
+functional and useful document “free” in the sense of freedom: to
assure everyone the effective freedom to copy and redistribute it,
with or without modifying it, either commercially or noncommercially.
Secondarily, this License preserves for the author and publisher a way
to get credit for their work, while not being considered responsible
for modifications made by others.
-This License is a kind of "copyleft", which means that derivative
+This License is a kind of “copyleft”, which means that derivative
works of the document must themselves be free in the same sense. It
complements the GNU General Public License, which is a copyleft
license designed for free software.
world-wide, royalty-free license, unlimited in duration, to use that
work under the conditions stated herein. The @strong{Document}, below,
refers to any such manual or work. Any member of the public is a
-licensee, and is addressed as "@strong{you}". You accept the license if you
+licensee, and is addressed as “@strong{you}”. You accept the license if you
copy, modify or distribute the work in a way requiring permission
under copyright law.
-A "@strong{Modified Version}" of the Document means any work containing the
+A “@strong{Modified Version}” of the Document means any work containing the
Document or a portion of it, either copied verbatim, or with
modifications and/or translated into another language.
-A "@strong{Secondary Section}" is a named appendix or a front-matter section of
+A “@strong{Secondary Section}” is a named appendix or a front-matter section of
the Document that deals exclusively with the relationship of the
-publishers or authors of the Document to the Document's overall subject
+publishers or authors of the Document to the Document’s overall subject
(or to related matters) and contains nothing that could fall directly
within that overall subject. (Thus, if the Document is in part a
textbook of mathematics, a Secondary Section may not explain any
commercial, philosophical, ethical or political position regarding
them.
-The "@strong{Invariant Sections}" are certain Secondary Sections whose titles
+The “@strong{Invariant Sections}” are certain Secondary Sections whose titles
are designated, as being those of Invariant Sections, in the notice
that says that the Document is released under this License. If a
section does not fit the above definition of Secondary then it is not
Invariant Sections. If the Document does not identify any Invariant
Sections then there are none.
-The "@strong{Cover Texts}" are certain short passages of text that are listed,
+The “@strong{Cover Texts}” are certain short passages of text that are listed,
as Front-Cover Texts or Back-Cover Texts, in the notice that says that
the Document is released under this License. A Front-Cover Text may
be at most 5 words, and a Back-Cover Text may be at most 25 words.
-A "@strong{Transparent}" copy of the Document means a machine-readable copy,
+A “@strong{Transparent}” copy of the Document means a machine-readable copy,
represented in a format whose specification is available to the
general public, that is suitable for revising the document
straightforwardly with generic text editors or (for images composed of
format whose markup, or absence of markup, has been arranged to thwart
or discourage subsequent modification by readers is not Transparent.
An image format is not Transparent if used for any substantial amount
-of text. A copy that is not "Transparent" is called @strong{Opaque}.
+of text. A copy that is not “Transparent” is called @strong{Opaque}.
Examples of suitable formats for Transparent copies include plain
ASCII without markup, Texinfo input format, LaTeX input format, SGML
machine-generated HTML, PostScript or PDF produced by some word
processors for output purposes only.
-The "@strong{Title Page}" means, for a printed book, the title page itself,
+The “@strong{Title Page}” means, for a printed book, the title page itself,
plus such following pages as are needed to hold, legibly, the material
this License requires to appear in the title page. For works in
-formats which do not have any title page as such, "Title Page" means
-the text near the most prominent appearance of the work's title,
+formats which do not have any title page as such, “Title Page” means
+the text near the most prominent appearance of the work’s title,
preceding the beginning of the body of the text.
-The "@strong{publisher}" means any person or entity that distributes
+The “@strong{publisher}” means any person or entity that distributes
copies of the Document to the public.
-A section "@strong{Entitled XYZ}" means a named subunit of the Document whose
+A section “@strong{Entitled XYZ}” means a named subunit of the Document whose
title either is precisely XYZ or contains XYZ in parentheses following
text that translates XYZ in another language. (Here XYZ stands for a
-specific section name mentioned below, such as "@strong{Acknowledgements}",
-"@strong{Dedications}", "@strong{Endorsements}", or "@strong{History}".)
-To "@strong{Preserve the Title}"
+specific section name mentioned below, such as “@strong{Acknowledgements}”,
+“@strong{Dedications}”, “@strong{Endorsements}”, or “@strong{History}”.)
+To “@strong{Preserve the Title}”
of such a section when you modify the Document means that it remains a
-section "Entitled XYZ" according to this definition.
+section “Entitled XYZ” according to this definition.
The Document may include Warranty Disclaimers next to the notice which
states that this License applies to the Document. These Warranty
If you publish printed copies (or copies in media that commonly have
printed covers) of the Document, numbering more than 100, and the
-Document's license notice requires Cover Texts, you must enclose the
+Document’s license notice requires Cover Texts, you must enclose the
copies in covers that carry, clearly and legibly, all these Cover
Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on
the back cover. Both covers must also clearly and legibly identify
@item
Preserve in that license notice the full lists of Invariant Sections
-and required Cover Texts given in the Document's license notice.
+and required Cover Texts given in the Document’s license notice.
@item
Include an unaltered copy of this License.
@item
-Preserve the section Entitled "History", Preserve its Title, and add
+Preserve the section Entitled “History”, Preserve its Title, and add
to it an item stating at least the title, year, new authors, and
publisher of the Modified Version as given on the Title Page. If
-there is no section Entitled "History" in the Document, create one
+there is no section Entitled “History” in the Document, create one
stating the title, year, authors, and publisher of the Document as
given on its Title Page, then add an item describing the Modified
Version as stated in the previous sentence.
Preserve the network location, if any, given in the Document for
public access to a Transparent copy of the Document, and likewise
the network locations given in the Document for previous versions
-it was based on. These may be placed in the "History" section.
+it was based on. These may be placed in the “History” section.
You may omit a network location for a work that was published at
least four years before the Document itself, or if the original
publisher of the version it refers to gives permission.
@item
-For any section Entitled "Acknowledgements" or "Dedications",
+For any section Entitled “Acknowledgements” or “Dedications”,
Preserve the Title of the section, and preserve in the section all
the substance and tone of each of the contributor acknowledgements
and/or dedications given therein.
or the equivalent are not considered part of the section titles.
@item
-Delete any section Entitled "Endorsements". Such a section
+Delete any section Entitled “Endorsements”. Such a section
may not be included in the Modified Version.
@item
-Do not retitle any existing section to be Entitled "Endorsements"
+Do not retitle any existing section to be Entitled “Endorsements”
or to conflict in title with any Invariant Section.
@item
appendices that qualify as Secondary Sections and contain no material
copied from the Document, you may at your option designate some or all
of these sections as invariant. To do this, add their titles to the
-list of Invariant Sections in the Modified Version's license notice.
+list of Invariant Sections in the Modified Version’s license notice.
These titles must be distinct from any other section titles.
-You may add a section Entitled "Endorsements", provided it contains
+You may add a section Entitled “Endorsements”, provided it contains
nothing but endorsements of your Modified Version by various
-parties---for example, statements of peer review or that the text has
+parties—for example, statements of peer review or that the text has
been approved by an organization as the authoritative definition of a
standard.
Make the same adjustment to the section titles in the list of
Invariant Sections in the license notice of the combined work.
-In the combination, you must combine any sections Entitled "History"
+In the combination, you must combine any sections Entitled “History”
in the various original documents, forming one section Entitled
-"History"; likewise combine any sections Entitled "Acknowledgements",
-and any sections Entitled "Dedications". You must delete all sections
-Entitled "Endorsements".
+“History”; likewise combine any sections Entitled “Acknowledgements”,
+and any sections Entitled “Dedications”. You must delete all sections
+Entitled “Endorsements”.
@strong{6. COLLECTIONS OF DOCUMENTS}
A compilation of the Document or its derivatives with other separate
and independent documents or works, in or on a volume of a storage or
-distribution medium, is called an "aggregate" if the copyright
+distribution medium, is called an “aggregate” if the copyright
resulting from the compilation is not used to limit the legal rights
-of the compilation's users beyond what the individual works permit.
+of the compilation’s users beyond what the individual works permit.
When the Document is included in an aggregate, this License does not
apply to the other works in the aggregate which are not themselves
derivative works of the Document.
If the Cover Text requirement of section 3 is applicable to these
copies of the Document, then if the Document is less than one half of
-the entire aggregate, the Document's Cover Texts may be placed on
+the entire aggregate, the Document’s Cover Texts may be placed on
covers that bracket the Document within the aggregate, or the
electronic equivalent of covers if the Document is in electronic form.
Otherwise they must appear on printed covers that bracket the whole
the translation and the original version of this License or a notice
or disclaimer, the original version will prevail.
-If a section in the Document is Entitled "Acknowledgements",
-"Dedications", or "History", the requirement (section 4) to Preserve
+If a section in the Document is Entitled “Acknowledgements”,
+“Dedications”, or “History”, the requirement (section 4) to Preserve
its Title (section 1) will typically require changing the actual
title.
Each version of the License is given a distinguishing version number.
If the Document specifies that a particular numbered version of this
-License "or any later version" applies to it, you have the option of
+License “or any later version” applies to it, you have the option of
following the terms and conditions either of that specified version or
of any later version that has been published (not as a draft) by the
Free Software Foundation. If the Document does not specify a version
number of this License, you may choose any version ever published (not
as a draft) by the Free Software Foundation. If the Document
specifies that a proxy can decide which future versions of this
-License can be used, that proxy's public statement of acceptance of a
+License can be used, that proxy’s public statement of acceptance of a
version permanently authorizes you to choose that version for the
Document.
@strong{11. RELICENSING}
-"Massive Multiauthor Collaboration Site" (or "MMC Site") means any
+“Massive Multiauthor Collaboration Site” (or “MMC Site”) means any
World Wide Web server that publishes copyrightable works and also
provides prominent facilities for anybody to edit those works. A
public wiki that anybody can edit is an example of such a server. A
-"Massive Multiauthor Collaboration" (or "MMC") contained in the
+“Massive Multiauthor Collaboration” (or “MMC”) contained in the
site means any set of copyrightable works thus published on the MMC
site.
-"CC-BY-SA" means the Creative Commons Attribution-Share Alike 3.0
+“CC-BY-SA” means the Creative Commons Attribution-Share Alike 3.0
license published by Creative Commons Corporation, a not-for-profit
corporation with a principal place of business in San Francisco,
California, as well as future copyleft versions of that license
published by that same organization.
-"Incorporate" means to publish or republish a Document, in whole or
+“Incorporate” means to publish or republish a Document, in whole or
in part, as part of another Document.
-An MMC is "eligible for relicensing" if it is licensed under this
+An MMC is “eligible for relicensing” if it is licensed under this
License, and if all works that were first published under this License
somewhere other than this MMC, and subsequently incorporated in whole
or in part into the MMC, (1) had no cover texts or invariant sections,
under the terms of the GNU Free Documentation License, Version 1.3
or any later version published by the Free Software Foundation;
with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
-A copy of the license is included in the section entitled "GNU
-Free Documentation License".
+A copy of the license is included in the section entitled “GNU
+Free Documentation License”.
@end quotation
If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts,
-replace the "with ... Texts." line with this:
+replace the “with … Texts.” line with this:
@quotation
@setfilename gnat_ugn.info
@documentencoding UTF-8
@ifinfo
-@*Generated by Sphinx 1.4.6.@*
+@*Generated by Sphinx 4.0.2.@*
@end ifinfo
@settitle GNAT User's Guide for Native Platforms
@defindex ge
@copying
@quotation
-GNAT User's Guide for Native Platforms , Apr 12, 2021
+GNAT User's Guide for Native Platforms , Jun 23, 2021
AdaCore
@c %** end of user preamble
@ifnottex
-@node Top, About This Guide
+@node Top
@top GNAT User's Guide for Native Platforms
@insertcopying
@end ifnottex
under the terms of the GNU Free Documentation License, Version 1.3 or
any later version published by the Free Software Foundation; with no
Invariant Sections, with the Front-Cover Texts being
-"GNAT User's Guide for Native Platforms",
+“GNAT User’s Guide for Native Platforms”,
and with no Back-Cover Texts. A copy of the license is
included in the section entitled @ref{1,,GNU Free Documentation License}.
@end menu
@node About This Guide,Getting Started with GNAT,Top,Top
-@anchor{gnat_ugn/about_this_guide about-this-guide}@anchor{2}@anchor{gnat_ugn/about_this_guide doc}@anchor{3}@anchor{gnat_ugn/about_this_guide gnat-user-s-guide-for-native-platforms}@anchor{4}@anchor{gnat_ugn/about_this_guide id1}@anchor{5}
+@anchor{gnat_ugn/about_this_guide doc}@anchor{2}@anchor{gnat_ugn/about_this_guide about-this-guide}@anchor{3}@anchor{gnat_ugn/about_this_guide gnat-user-s-guide-for-native-platforms}@anchor{4}@anchor{gnat_ugn/about_this_guide id1}@anchor{5}
@chapter About This Guide
By default, GNAT assumes Ada 2012, but you can override with a
compiler switch (@ref{6,,Compiling Different Versions of Ada})
to explicitly specify the language version.
-Throughout this manual, references to 'Ada' without a year suffix
+Throughout this manual, references to ‘Ada’ without a year suffix
apply to all Ada versions of the language, starting with Ada 95.
@menu
comprising the @code{$} character followed by a space.
@item
-Full file names are shown with the '/' character
+Full file names are shown with the ‘/’ character
as the directory separator; e.g., @code{parent-dir/subdir/myfile.adb}.
If you are using GNAT on a Windows platform, please note that
-the '\' character should be used instead.
+the ‘' character should be used instead.
@end itemize
@node Getting Started with GNAT,The GNAT Compilation Model,About This Guide,Top
-@anchor{gnat_ugn/getting_started_with_gnat getting-started-with-gnat}@anchor{8}@anchor{gnat_ugn/getting_started_with_gnat doc}@anchor{14}@anchor{gnat_ugn/getting_started_with_gnat id1}@anchor{15}
+@anchor{gnat_ugn/getting_started_with_gnat doc}@anchor{14}@anchor{gnat_ugn/getting_started_with_gnat getting-started-with-gnat}@anchor{8}@anchor{gnat_ugn/getting_started_with_gnat id1}@anchor{15}
@chapter Getting Started with GNAT
-This chapter describes how to use GNAT's command line interface to build
+This chapter describes how to use GNAT’s command line interface to build
executable Ada programs.
On most platforms a visually oriented Integrated Development Environment
is also available: GNAT Studio.
-GNAT Studio offers a graphical "look and feel", support for development in
+GNAT Studio offers a graphical “look and feel”, support for development in
other programming languages, comprehensive browsing features, and
many other capabilities.
For information on GNAT Studio please refer to the
project file attribute.
@node Running GNAT,Running a Simple Ada Program,System Requirements,Getting Started with GNAT
-@anchor{gnat_ugn/getting_started_with_gnat running-gnat}@anchor{18}@anchor{gnat_ugn/getting_started_with_gnat id3}@anchor{19}
+@anchor{gnat_ugn/getting_started_with_gnat id3}@anchor{18}@anchor{gnat_ugn/getting_started_with_gnat running-gnat}@anchor{19}
@section Running GNAT
performs the necessary compilation, binding and linking steps.
@node Running a Simple Ada Program,Running a Program with Multiple Units,Running GNAT,Getting Started with GNAT
-@anchor{gnat_ugn/getting_started_with_gnat running-a-simple-ada-program}@anchor{1a}@anchor{gnat_ugn/getting_started_with_gnat id4}@anchor{1b}
+@anchor{gnat_ugn/getting_started_with_gnat id4}@anchor{1a}@anchor{gnat_ugn/getting_started_with_gnat running-a-simple-ada-program}@anchor{1b}
@section Running a Simple Ada Program
This compile command generates a file
@code{hello.o}, which is the object
file corresponding to your Ada program. It also generates
-an 'Ada Library Information' file @code{hello.ali},
+an ‘Ada Library Information’ file @code{hello.ali},
which contains additional information used to check
that an Ada program is consistent.
all the necessary build steps in the correct order.
In particular, these builders automatically recompile any sources that have
been modified since they were last compiled, or sources that depend
-on such modified sources, so that 'version skew' is avoided.
+on such modified sources, so that ‘version skew’ is avoided.
@geindex Version skew (avoided by `@w{`}gnatmake`@w{`})
@c -- Example: A |withing| unit has a |with| clause, it |withs| a |withed| unit
@node The GNAT Compilation Model,Building Executable Programs with GNAT,Getting Started with GNAT,Top
-@anchor{gnat_ugn/the_gnat_compilation_model doc}@anchor{20}@anchor{gnat_ugn/the_gnat_compilation_model the-gnat-compilation-model}@anchor{9}@anchor{gnat_ugn/the_gnat_compilation_model id1}@anchor{21}
+@anchor{gnat_ugn/the_gnat_compilation_model doc}@anchor{20}@anchor{gnat_ugn/the_gnat_compilation_model id1}@anchor{21}@anchor{gnat_ugn/the_gnat_compilation_model the-gnat-compilation-model}@anchor{9}
@chapter The GNAT Compilation Model
@end menu
@node Source Representation,Foreign Language Representation,,The GNAT Compilation Model
-@anchor{gnat_ugn/the_gnat_compilation_model source-representation}@anchor{22}@anchor{gnat_ugn/the_gnat_compilation_model id2}@anchor{2f}
+@anchor{gnat_ugn/the_gnat_compilation_model id2}@anchor{2f}@anchor{gnat_ugn/the_gnat_compilation_model source-representation}@anchor{22}
@section Source Representation
The basic character set is Latin-1. This character set is defined by ISO
standard 8859, part 1. The lower half (character codes @code{16#00#}
-... @code{16#7F#)} is identical to standard ASCII coding, but the upper
+… @code{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.
letters can be used in identifiers.
@node Other 8-Bit Codes,Wide_Character Encodings,Latin-1,Foreign Language Representation
-@anchor{gnat_ugn/the_gnat_compilation_model other-8-bit-codes}@anchor{34}@anchor{gnat_ugn/the_gnat_compilation_model id5}@anchor{35}
+@anchor{gnat_ugn/the_gnat_compilation_model id5}@anchor{34}@anchor{gnat_ugn/the_gnat_compilation_model other-8-bit-codes}@anchor{35}
@subsection Other 8-Bit Codes
@geindex Upper-Half Coding
The wide character with encoding @code{16#abcd#} where the upper bit is on
-(in other words, 'a' is in the range 8-F) is represented as two bytes,
+(in other words, ‘a’ is in the range 8-F) is represented as two bytes,
@code{16#ab#} and @code{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
where @code{a}, @code{b}, @code{c}, @code{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
+example, [‘A345’] is used to represent the wide character with code
@code{16#A345#}. It is also possible (though not required) to use the
Brackets coding for upper half characters. For example, the code
@code{16#A3#} can be represented as @code{['A3']}.
where @code{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
+example, [“1F4567”] is used to represent the wide wide character with code
@code{16#001F_4567#}.
This scheme is compatible with use of the full Wide_Wide_Character set,
@end table
@node File Naming Topics and Utilities,Configuration Pragmas,Foreign Language Representation,The GNAT Compilation Model
-@anchor{gnat_ugn/the_gnat_compilation_model id8}@anchor{3a}@anchor{gnat_ugn/the_gnat_compilation_model file-naming-topics-and-utilities}@anchor{24}
+@anchor{gnat_ugn/the_gnat_compilation_model file-naming-topics-and-utilities}@anchor{24}@anchor{gnat_ugn/the_gnat_compilation_model id8}@anchor{3a}
@section File Naming Topics and Utilities
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
+(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. @ref{3d,,Using gnatkr}.
be omitted.
@node Alternative File Naming Schemes,Handling Arbitrary File Naming Conventions with gnatname,Using Other File Names,File Naming Topics and Utilities
-@anchor{gnat_ugn/the_gnat_compilation_model id11}@anchor{40}@anchor{gnat_ugn/the_gnat_compilation_model alternative-file-naming-schemes}@anchor{41}
+@anchor{gnat_ugn/the_gnat_compilation_model alternative-file-naming-schemes}@anchor{40}@anchor{gnat_ugn/the_gnat_compilation_model id11}@anchor{41}
@subsection Alternative File Naming Schemes
@end example
Our final example implements a scheme typically used with one of the
-Ada 83 compilers, where the separator character for subunits was '__'
+Ada 83 compilers, where the separator character for subunits was ‘__’
(two underscores), specs were identified by adding @code{_.ADA}, bodies
by adding @code{.ADA}, and subunits by
adding @code{.SEP}. All file names were
or a project file.
When the non-standard file naming conventions are well-defined,
a small number of pragmas @code{Source_File_Name} specifying a naming pattern
-(@ref{41,,Alternative File Naming Schemes}) may be sufficient. However,
+(@ref{40,,Alternative File Naming Schemes}) may be sufficient. However,
if the file naming conventions are irregular or arbitrary, a number
of pragma @code{Source_File_Name} for individual compilation units
must be defined.
set of files.
@node Running gnatname,Switches for gnatname,Arbitrary File Naming Conventions,Handling Arbitrary File Naming Conventions with gnatname
-@anchor{gnat_ugn/the_gnat_compilation_model running-gnatname}@anchor{46}@anchor{gnat_ugn/the_gnat_compilation_model id14}@anchor{47}
+@anchor{gnat_ugn/the_gnat_compilation_model id14}@anchor{46}@anchor{gnat_ugn/the_gnat_compilation_model running-gnatname}@anchor{47}
@subsubsection Running @code{gnatname}
For a more complete description of the syntax of Naming Patterns,
see the second kind of regular expressions described in @code{g-regexp.ads}
-(the 'Glob' regular expressions).
+(the ‘Glob’ regular expressions).
When invoked without the switch @code{-P}, @code{gnatname} will create a
configuration pragmas file @code{gnat.adc} in the current working directory,
no switch @code{-c} may be specified.
On all platforms, except on VMS, when @code{gnatname} is invoked for an
existing project file <proj>.gpr, a backup copy of the project file is created
-in the project directory with file name <proj>.gpr.saved_x. 'x' is the first
+in the project directory with file name <proj>.gpr.saved_x. ‘x’ is the first
non negative number that makes this backup copy a new file.
@geindex -v (gnatname)
@end menu
@node About gnatkr,Using gnatkr,,File Name Krunching with gnatkr
-@anchor{gnat_ugn/the_gnat_compilation_model id18}@anchor{4e}@anchor{gnat_ugn/the_gnat_compilation_model about-gnatkr}@anchor{4f}
+@anchor{gnat_ugn/the_gnat_compilation_model about-gnatkr}@anchor{4e}@anchor{gnat_ugn/the_gnat_compilation_model id18}@anchor{4f}
@subsubsection About @code{gnatkr}
@end itemize
The @code{-gnatk@emph{nn}}
-switch of the compiler activates a 'krunching'
+switch of the compiler activates a ‘krunching’
circuit that limits file names to nn characters (where nn is a decimal
integer).
krunched name of a file.
@node Examples of gnatkr Usage,,Krunching Method,File Name Krunching with gnatkr
-@anchor{gnat_ugn/the_gnat_compilation_model id21}@anchor{53}@anchor{gnat_ugn/the_gnat_compilation_model examples-of-gnatkr-usage}@anchor{54}
+@anchor{gnat_ugn/the_gnat_compilation_model examples-of-gnatkr-usage}@anchor{53}@anchor{gnat_ugn/the_gnat_compilation_model id21}@anchor{54}
@subsubsection Examples of @code{gnatkr} Usage
@end menu
@node Handling Files with Multiple Units,Operating gnatchop in Compilation Mode,,Renaming Files with gnatchop
-@anchor{gnat_ugn/the_gnat_compilation_model id23}@anchor{56}@anchor{gnat_ugn/the_gnat_compilation_model handling-files-with-multiple-units}@anchor{57}
+@anchor{gnat_ugn/the_gnat_compilation_model handling-files-with-multiple-units}@anchor{56}@anchor{gnat_ugn/the_gnat_compilation_model id23}@anchor{57}
@subsubsection Handling Files with Multiple Units
See @ref{42,,Handling Arbitrary File Naming Conventions with gnatname}
for more details on how to use @cite{gnatname}.
-Alternatively, if you want to permanently restructure a set of 'foreign'
+Alternatively, if you want to permanently restructure a set of ‘foreign’
files so that they match the GNAT rules, and do the remaining development
using the GNAT structure, you can simply use @code{gnatchop} once, generate the
new set of files and work with them from that point on.
automatically in UTF-8 mode without needing to specify an explicit encoding.
@node Operating gnatchop in Compilation Mode,Command Line for gnatchop,Handling Files with Multiple Units,Renaming Files with gnatchop
-@anchor{gnat_ugn/the_gnat_compilation_model operating-gnatchop-in-compilation-mode}@anchor{58}@anchor{gnat_ugn/the_gnat_compilation_model id24}@anchor{59}
+@anchor{gnat_ugn/the_gnat_compilation_model id24}@anchor{58}@anchor{gnat_ugn/the_gnat_compilation_model operating-gnatchop-in-compilation-mode}@anchor{59}
@subsubsection Operating gnatchop in Compilation Mode
submit a file containing only configuration pragmas, or one that ends in
configuration pragmas, to @code{gnatchop}.
-However, using a special option to activate 'compilation mode',
+However, using a special option to activate ‘compilation mode’,
@code{gnatchop}
can perform another function, which is to provide exactly the semantics
required by the RM for handling of configuration pragmas in a compilation.
in which GNAT processes the ACVC tests.
@node Command Line for gnatchop,Switches for gnatchop,Operating gnatchop in Compilation Mode,Renaming Files with gnatchop
-@anchor{gnat_ugn/the_gnat_compilation_model id25}@anchor{5a}@anchor{gnat_ugn/the_gnat_compilation_model command-line-for-gnatchop}@anchor{5b}
+@anchor{gnat_ugn/the_gnat_compilation_model command-line-for-gnatchop}@anchor{5a}@anchor{gnat_ugn/the_gnat_compilation_model id25}@anchor{5b}
@subsubsection Command Line for @code{gnatchop}
@end example
@node Switches for gnatchop,Examples of gnatchop Usage,Command Line for gnatchop,Renaming Files with gnatchop
-@anchor{gnat_ugn/the_gnat_compilation_model switches-for-gnatchop}@anchor{5c}@anchor{gnat_ugn/the_gnat_compilation_model id26}@anchor{5d}
+@anchor{gnat_ugn/the_gnat_compilation_model id26}@anchor{5c}@anchor{gnat_ugn/the_gnat_compilation_model switches-for-gnatchop}@anchor{5d}
@subsubsection Switches for @code{gnatchop}
@end table
@node Examples of gnatchop Usage,,Switches for gnatchop,Renaming Files with gnatchop
-@anchor{gnat_ugn/the_gnat_compilation_model id27}@anchor{5e}@anchor{gnat_ugn/the_gnat_compilation_model examples-of-gnatchop-usage}@anchor{5f}
+@anchor{gnat_ugn/the_gnat_compilation_model examples-of-gnatchop-usage}@anchor{5e}@anchor{gnat_ugn/the_gnat_compilation_model id27}@anchor{5f}
@subsubsection Examples of @code{gnatchop} Usage
unit will be skipped.
@node Configuration Pragmas,Generating Object Files,File Naming Topics and Utilities,The GNAT Compilation Model
-@anchor{gnat_ugn/the_gnat_compilation_model id28}@anchor{60}@anchor{gnat_ugn/the_gnat_compilation_model configuration-pragmas}@anchor{25}
+@anchor{gnat_ugn/the_gnat_compilation_model configuration-pragmas}@anchor{25}@anchor{gnat_ugn/the_gnat_compilation_model id28}@anchor{60}
@section Configuration Pragmas
@end menu
@node Handling of Configuration Pragmas,The Configuration Pragmas Files,,Configuration Pragmas
-@anchor{gnat_ugn/the_gnat_compilation_model id29}@anchor{61}@anchor{gnat_ugn/the_gnat_compilation_model handling-of-configuration-pragmas}@anchor{3f}
+@anchor{gnat_ugn/the_gnat_compilation_model handling-of-configuration-pragmas}@anchor{3f}@anchor{gnat_ugn/the_gnat_compilation_model id29}@anchor{61}
@subsection Handling of Configuration Pragmas
GNAT also provides the @code{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 @ref{58,,Operating gnatchop in Compilation Mode} for details.
+See @ref{59,,Operating gnatchop in Compilation Mode} for details.
However, for most purposes, it will be more convenient to edit the
@code{gnat.adc} file that contains configuration pragmas directly,
as described in the following section.
appeared in the body of spec.
@node The Configuration Pragmas Files,,Handling of Configuration Pragmas,Configuration Pragmas
-@anchor{gnat_ugn/the_gnat_compilation_model the-configuration-pragmas-files}@anchor{62}@anchor{gnat_ugn/the_gnat_compilation_model id30}@anchor{63}
+@anchor{gnat_ugn/the_gnat_compilation_model id30}@anchor{62}@anchor{gnat_ugn/the_gnat_compilation_model the-configuration-pragmas-files}@anchor{63}
@subsection The Configuration Pragmas Files
temporary files. A file is considered temporary if its name ends in
@code{.tmp} or @code{.TMP}. Certain tools follow this naming
convention because they pass information to @code{gcc} via
-temporary files that are immediately deleted; it doesn't make sense to
+temporary files that are immediately deleted; it doesn’t make sense to
depend on a file that no longer exists. Such tools include
@code{gprbuild}, @code{gnatmake}, and @code{gnatcheck}.
A given object file clearly depends on the source file which is compiled
-to produce it. Here we are using "depends" in the sense of a typical
+to produce it. Here we are using “depends” in the sense of a typical
@code{make} utility; in other words, an object file depends on a source
file if changes to the source file require the object file to be
recompiled.
@code{lib-writ.adb} in the GNAT compiler sources.
@node Binding an Ada Program,GNAT and Libraries,The Ada Library Information Files,The GNAT Compilation Model
-@anchor{gnat_ugn/the_gnat_compilation_model id34}@anchor{67}@anchor{gnat_ugn/the_gnat_compilation_model binding-an-ada-program}@anchor{29}
+@anchor{gnat_ugn/the_gnat_compilation_model binding-an-ada-program}@anchor{29}@anchor{gnat_ugn/the_gnat_compilation_model id34}@anchor{67}
@section Binding an Ada Program
This section describes how to build and use libraries with GNAT, and also shows
how to recompile the GNAT run-time library. You should be familiar with the
Project Manager facility (see the @emph{GNAT_Project_Manager} chapter of the
-@emph{GPRbuild User's Guide}) before reading this chapter.
+@emph{GPRbuild User’s Guide}) before reading this chapter.
@menu
* Introduction to Libraries in GNAT::
@end menu
@node Introduction to Libraries in GNAT,General Ada Libraries,,GNAT and Libraries
-@anchor{gnat_ugn/the_gnat_compilation_model introduction-to-libraries-in-gnat}@anchor{69}@anchor{gnat_ugn/the_gnat_compilation_model id36}@anchor{6a}
+@anchor{gnat_ugn/the_gnat_compilation_model id36}@anchor{69}@anchor{gnat_ugn/the_gnat_compilation_model introduction-to-libraries-in-gnat}@anchor{6a}
@subsection Introduction to Libraries in GNAT
units are called @emph{interface units} (@ref{6b,,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
+need to be elaborated in an order partially defined by Ada’s semantics. GNAT
computes the elaboration order from the @code{ALI} files and this is why they
constitute a mandatory part of GNAT libraries.
@emph{Stand-alone libraries} are the exception to this rule because a specific
The easiest way to build a library is to use the Project Manager,
which supports a special type of project called a @emph{Library Project}
(see the @emph{Library Projects} section in the @emph{GNAT Project Manager}
-chapter of the @emph{GPRbuild User's Guide}).
+chapter of the @emph{GPRbuild User’s Guide}).
A project is considered a library project, when two project-level attributes
are defined in it: @code{Library_Name} and @code{Library_Dir}. In order to
be accessed by the directive @code{-l@emph{xxx}} at link time.
@node Installing a library,Using a library,Building a library,General Ada Libraries
-@anchor{gnat_ugn/the_gnat_compilation_model installing-a-library}@anchor{71}@anchor{gnat_ugn/the_gnat_compilation_model id39}@anchor{72}
+@anchor{gnat_ugn/the_gnat_compilation_model id39}@anchor{71}@anchor{gnat_ugn/the_gnat_compilation_model installing-a-library}@anchor{72}
@subsubsection Installing a library
If you use project files, library installation is part of the library build
process (see the @emph{Installing a Library with Project Files} section of the
-@emph{GNAT Project Manager} chapter of the @emph{GPRbuild User's Guide}).
+@emph{GNAT Project Manager} chapter of the @emph{GPRbuild User’s Guide}).
When project files are not an option, it is also possible, but not recommended,
to install the library so that the sources needed to use the library are on the
Ada source path and the ALI files & libraries be on the Ada Object path (see
@ref{73,,Search Paths and the Run-Time Library (RTL)}. Alternatively, the system
administrator can place general-purpose libraries in the default compiler
-paths, by specifying the libraries' location in the configuration files
+paths, by specifying the libraries’ location in the configuration files
@code{ada_source_path} and @code{ada_object_path}. These configuration files
must be located in the GNAT installation tree at the same place as the gcc spec
file. The location of the gcc spec file can be determined as follows:
any part of it.
@node Using a library,,Installing a library,General Ada Libraries
-@anchor{gnat_ugn/the_gnat_compilation_model using-a-library}@anchor{74}@anchor{gnat_ugn/the_gnat_compilation_model id40}@anchor{75}
+@anchor{gnat_ugn/the_gnat_compilation_model id40}@anchor{74}@anchor{gnat_ugn/the_gnat_compilation_model using-a-library}@anchor{75}
@subsubsection Using a library
end My_Proj;
@end example
-Even if you have a third-party, non-Ada library, you can still use GNAT's
+Even if you have a third-party, non-Ada library, you can still use GNAT’s
Project Manager facility to provide a wrapper for it. For example, the
following project, when @emph{with}ed by your main project, will link with the
third-party library @code{liba.a}:
install area.
@node Stand-alone Ada Libraries,Rebuilding the GNAT Run-Time Library,General Ada Libraries,GNAT and Libraries
-@anchor{gnat_ugn/the_gnat_compilation_model stand-alone-ada-libraries}@anchor{6b}@anchor{gnat_ugn/the_gnat_compilation_model id41}@anchor{77}
+@anchor{gnat_ugn/the_gnat_compilation_model id41}@anchor{77}@anchor{gnat_ugn/the_gnat_compilation_model stand-alone-ada-libraries}@anchor{6b}
@subsection Stand-alone Ada Libraries
@end menu
@node Introduction to Stand-alone Libraries,Building a Stand-alone Library,,Stand-alone Ada Libraries
-@anchor{gnat_ugn/the_gnat_compilation_model introduction-to-stand-alone-libraries}@anchor{78}@anchor{gnat_ugn/the_gnat_compilation_model id42}@anchor{79}
+@anchor{gnat_ugn/the_gnat_compilation_model id42}@anchor{78}@anchor{gnat_ugn/the_gnat_compilation_model introduction-to-stand-alone-libraries}@anchor{79}
@subsubsection Introduction to Stand-alone Libraries
-A Stand-alone Library (abbreviated 'SAL') is a library that contains the
+A Stand-alone Library (abbreviated ‘SAL’) is a library that contains the
necessary code to
elaborate the Ada units that are included in the library. In contrast with
an ordinary library, which consists of all sources, objects and @code{ALI}
library, a SAL may specify a restricted subset of compilation units
to serve as a library interface. In this case, the fully
self-sufficient set of files will normally consist of an objects
-archive, the sources of interface units' specs, and the @code{ALI}
+archive, the sources of interface units’ specs, and the @code{ALI}
files of interface units.
If an interface spec contains a generic unit or an inlined subprogram,
-the body's
+the body’s
source must also be provided; if the units that must be provided in the source
form depend on other units, the source and @code{ALI} files of those must
also be provided.
then the clients do not need to be relinked.
SALs also allow the library providers to minimize the amount of library source
-text exposed to the clients. Such 'information hiding' might be useful or
+text exposed to the clients. Such ‘information hiding’ might be useful or
necessary for various reasons.
Stand-alone libraries are also well suited to be used in an executable whose
main routine is not written in Ada.
@node Building a Stand-alone Library,Creating a Stand-alone Library to be used in a non-Ada context,Introduction to Stand-alone Libraries,Stand-alone Ada Libraries
-@anchor{gnat_ugn/the_gnat_compilation_model id43}@anchor{7a}@anchor{gnat_ugn/the_gnat_compilation_model building-a-stand-alone-library}@anchor{7b}
+@anchor{gnat_ugn/the_gnat_compilation_model building-a-stand-alone-library}@anchor{7a}@anchor{gnat_ugn/the_gnat_compilation_model id43}@anchor{7b}
@subsubsection Building a Stand-alone Library
-GNAT's Project facility provides a simple way of building and installing
+GNAT’s Project facility provides a simple way of building and installing
stand-alone libraries; see the @emph{Stand-alone Library Projects} section
-in the @emph{GNAT Project Manager} chapter of the @emph{GPRbuild User's Guide}.
+in the @emph{GNAT Project Manager} chapter of the @emph{GPRbuild User’s Guide}.
To be a Stand-alone Library Project, in addition to the two attributes
that make a project a Library Project (@code{Library_Name} and
@code{Library_Dir}; see the @emph{Library Projects} section in the
-@emph{GNAT Project Manager} chapter of the @emph{GPRbuild User's Guide}),
+@emph{GNAT Project Manager} chapter of the @emph{GPRbuild User’s Guide}),
the attribute @code{Library_Interface} must be defined. For example:
@example
Copy the @code{ALI} files of the interface to the library directory,
add in this copy an indication that it is an interface to a SAL
(i.e., add a word @code{SL} on the line in the @code{ALI} file that starts
-with letter 'P') and make the modified copy of the @code{ALI} file
+with letter ‘P’) and make the modified copy of the @code{ALI} file
read-only.
@end itemize
Using SALs is not different from using other libraries
-(see @ref{74,,Using a library}).
+(see @ref{75,,Using a library}).
@node Creating a Stand-alone Library to be used in a non-Ada context,Restrictions in Stand-alone Libraries,Building a Stand-alone Library,Stand-alone Ada Libraries
@anchor{gnat_ugn/the_gnat_compilation_model creating-a-stand-alone-library-to-be-used-in-a-non-ada-context}@anchor{7c}@anchor{gnat_ugn/the_gnat_compilation_model id44}@anchor{7d}
end My_Package;
@end example
-On the foreign language side, you must provide a 'foreign' view of the
+On the foreign language side, you must provide a ‘foreign’ view of the
library interface; remember that it should contain elaboration routines in
addition to interface subprograms.
@geindex Conditional compilation
@node Conditional Compilation,Mixed Language Programming,GNAT and Libraries,The GNAT Compilation Model
-@anchor{gnat_ugn/the_gnat_compilation_model id47}@anchor{82}@anchor{gnat_ugn/the_gnat_compilation_model conditional-compilation}@anchor{2b}
+@anchor{gnat_ugn/the_gnat_compilation_model conditional-compilation}@anchor{2b}@anchor{gnat_ugn/the_gnat_compilation_model id47}@anchor{82}
@section Conditional Compilation
@end menu
@node Modeling Conditional Compilation in Ada,Preprocessing with gnatprep,,Conditional Compilation
-@anchor{gnat_ugn/the_gnat_compilation_model modeling-conditional-compilation-in-ada}@anchor{83}@anchor{gnat_ugn/the_gnat_compilation_model id48}@anchor{84}
+@anchor{gnat_ugn/the_gnat_compilation_model id48}@anchor{83}@anchor{gnat_ugn/the_gnat_compilation_model modeling-conditional-compilation-in-ada}@anchor{84}
@subsection Modeling Conditional Compilation in Ada
the status of these pragmas.
Note that a pragma is not a statement, so in contexts where a statement
-sequence is required, you can't just write a pragma on its own. You have
+sequence is required, you can’t just write a pragma on its own. You have
to add a @code{null} statement.
@example
need to define this one yourself).
@node Use of Alternative Implementations,Preprocessing,Conditionalizing Declarations,Modeling Conditional Compilation in Ada
-@anchor{gnat_ugn/the_gnat_compilation_model use-of-alternative-implementations}@anchor{8b}@anchor{gnat_ugn/the_gnat_compilation_model id52}@anchor{8c}
+@anchor{gnat_ugn/the_gnat_compilation_model id52}@anchor{8b}@anchor{gnat_ugn/the_gnat_compilation_model use-of-alternative-implementations}@anchor{8c}
@subsubsection Use of Alternative Implementations
where @code{Ada_2005} is a Boolean constant.
-But this won't work when @code{Ada_2005} is set to @code{False},
+But this won’t work when @code{Ada_2005} is set to @code{False},
since the @code{then} clause will be illegal for an Ada 95 compiler.
(Recall that although such unreachable code would eventually be deleted
by the compiler, it still needs to be legal. If it uses features
and the build script renames the appropriate file to @code{file_queries-insert.adb} and then carries out the compilation.
-This can also be done with project files' naming schemes. For example:
+This can also be done with project files’ naming schemes. For example:
@example
for body ("File_Queries.Insert") use "file_queries-insert-2005.ada";
and operating system, and automatically selects the right version,
renaming it if necessary to @code{s-asthan.adb} before the run-time build.
-Another style for arranging alternative implementations is through Ada's
+Another style for arranging alternative implementations is through Ada’s
access-to-subprogram facility.
In case some functionality is to be conditionally included,
you can declare an access-to-procedure variable @code{Ref} that is initialized
-to designate a 'do nothing' procedure, and then invoke @code{Ref.all}
+to designate a ‘do nothing’ procedure, and then invoke @code{Ref.all}
when appropriate.
In some library package, set @code{Ref} to @code{Proc'Access} for some
procedure @code{Proc} that performs the relevant processing.
calls.
@node Preprocessing,,Use of Alternative Implementations,Modeling Conditional Compilation in Ada
-@anchor{gnat_ugn/the_gnat_compilation_model preprocessing}@anchor{8d}@anchor{gnat_ugn/the_gnat_compilation_model id53}@anchor{8e}
+@anchor{gnat_ugn/the_gnat_compilation_model id53}@anchor{8d}@anchor{gnat_ugn/the_gnat_compilation_model preprocessing}@anchor{8e}
@subsubsection Preprocessing
@geindex Preprocessing (gnatprep)
-This section discusses how to use GNAT's @code{gnatprep} utility for simple
+This section discusses how to use GNAT’s @code{gnatprep} utility for simple
preprocessing.
Although designed for use with GNAT, @code{gnatprep} does not depend on any
special GNAT features.
all characters need to be in the ASCII set (no accented letters).
@node Using gnatprep,Switches for gnatprep,Preprocessing Symbols,Preprocessing with gnatprep
-@anchor{gnat_ugn/the_gnat_compilation_model using-gnatprep}@anchor{94}@anchor{gnat_ugn/the_gnat_compilation_model id56}@anchor{95}
+@anchor{gnat_ugn/the_gnat_compilation_model id56}@anchor{94}@anchor{gnat_ugn/the_gnat_compilation_model using-gnatprep}@anchor{95}
@subsubsection Using @code{gnatprep}
@end itemize
@node Switches for gnatprep,Form of Definitions File,Using gnatprep,Preprocessing with gnatprep
-@anchor{gnat_ugn/the_gnat_compilation_model switches-for-gnatprep}@anchor{96}@anchor{gnat_ugn/the_gnat_compilation_model id57}@anchor{97}
+@anchor{gnat_ugn/the_gnat_compilation_model id57}@anchor{96}@anchor{gnat_ugn/the_gnat_compilation_model switches-for-gnatprep}@anchor{97}
@subsubsection Switches for @code{gnatprep}
and comments may be added to the definitions lines.
@node Form of Input Text for gnatprep,,Form of Definitions File,Preprocessing with gnatprep
-@anchor{gnat_ugn/the_gnat_compilation_model id59}@anchor{9a}@anchor{gnat_ugn/the_gnat_compilation_model form-of-input-text-for-gnatprep}@anchor{9b}
+@anchor{gnat_ugn/the_gnat_compilation_model form-of-input-text-for-gnatprep}@anchor{9a}@anchor{gnat_ugn/the_gnat_compilation_model id59}@anchor{9b}
@subsubsection Form of Input Text for @code{gnatprep}
<expression> ::= ( <expression> )
@end example
-Note the following restriction: it is not allowed to have "and" or "or"
-following "not" in the same expression without parentheses. For example, this
+Note the following restriction: it is not allowed to have “and” or “or”
+following “not” in the same expression without parentheses. For example, this
is not allowed:
@example
2#11#. The symbol value must also be a non negative integer. Integer values
in the range 0 .. 2**31-1 are supported.
-The test (<expression> ::= <symbol>'Defined) is true only if
+The test (<expression> ::= <symbol>’Defined) is true only if
the symbol has been defined in the definition file or by a @code{-D}
switch on the command line. Otherwise, the test is false.
The use of the @code{not} operator inverts the sense of this logical test.
The @code{not} operator cannot be combined with the @code{or} or @code{and}
-operators, without parentheses. For example, "if not X or Y then" is not
-allowed, but "if (not X) or Y then" and "if not (X or Y) then" are.
+operators, without parentheses. For example, “if not X or Y then” is not
+allowed, but “if (not X) or Y then” and “if not (X or Y) then” are.
The @code{then} keyword is optional as shown
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
+files, reference the project file’s directory via the
@code{project_name'Project_Dir} project attribute; e.g:
@quotation
Empty lines and comments (using Ada syntax) are also permitted, with no
semantic effect.
-Here's an example of a preprocessor data file:
+Here’s an example of a preprocessor data file:
@quotation
@end quotation
Thus each preprocessor control line starts with either a literal string or
-the character '*':
+the character ‘*’:
@itemize *
file that will be input to the preprocessor.
@item
-The character '*' is a wild-card indicator; the additional parameters on the line
+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).
@end itemize
It is an error to have two lines with the same file name or two
-lines starting with the character '*'.
+lines starting with the character ‘*’.
-After the file name or '*', an optional literal string specifies the name of
+After the file name or ‘*’, an optional literal string specifies the name of
the definition file to be used for preprocessing
(@ref{98,,Form of Definitions File}). The definition files are found by the
compiler in one of the source directories. In some cases, when compiling
Causes both preprocessor lines and the lines deleted
by preprocessing to be retained as comments marked
-with the special string '@cite{--!}'.
+with the special string ‘@cite{–!}’.
@item @code{-D@emph{symbol}=@emph{new_value}}
@end table
@node Mixed Language Programming,GNAT and Other Compilation Models,Conditional Compilation,The GNAT Compilation Model
-@anchor{gnat_ugn/the_gnat_compilation_model mixed-language-programming}@anchor{2c}@anchor{gnat_ugn/the_gnat_compilation_model id61}@anchor{9d}
+@anchor{gnat_ugn/the_gnat_compilation_model id61}@anchor{9d}@anchor{gnat_ugn/the_gnat_compilation_model mixed-language-programming}@anchor{2c}
@section Mixed Language Programming
@end menu
@node Interfacing to C,Calling Conventions,,Mixed Language Programming
-@anchor{gnat_ugn/the_gnat_compilation_model interfacing-to-c}@anchor{9e}@anchor{gnat_ugn/the_gnat_compilation_model id62}@anchor{9f}
+@anchor{gnat_ugn/the_gnat_compilation_model id62}@anchor{9e}@anchor{gnat_ugn/the_gnat_compilation_model interfacing-to-c}@anchor{9f}
@subsection 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 @code{extern} statements in C, for instance, and the
+language – using @code{extern} statements in C, for instance, and the
@code{Import}, @code{Export}, and @code{Convention} pragmas in Ada.
A full treatment of these topics is provided in Appendix B, section 1
of the Ada Reference Manual.
@end example
The build procedure for this application is similar to the last
-example's:
+example’s:
@itemize *
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:
+A note on interfacing to a C ‘varargs’ function:
@quotation
of this type can only be 8, 16, 32, or 64.
@item
-Binary arithmetic operators: '+', '-', '*', '/'.
+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
@end example
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
+import conventions (e.g. C), it is the user’s responsibility to ensure
that the Ada subprogram profile matches the underlying builtin
expectations.
@end itemize
meaning as Fortran.
@node Building Mixed Ada and C++ Programs,Generating Ada Bindings for C and C++ headers,Calling Conventions,Mixed Language Programming
-@anchor{gnat_ugn/the_gnat_compilation_model id64}@anchor{a3}@anchor{gnat_ugn/the_gnat_compilation_model building-mixed-ada-and-c-programs}@anchor{a4}
+@anchor{gnat_ugn/the_gnat_compilation_model building-mixed-ada-and-c-programs}@anchor{a3}@anchor{gnat_ugn/the_gnat_compilation_model id64}@anchor{a4}
@subsection Building Mixed Ada and C++ Programs
GNAT supports interfacing with the G++ compiler (or any C++ compiler
generating code that is compatible with the G++ Application Binary
-Interface ---see @indicateurl{http://www.codesourcery.com/archives/cxx-abi}).
+Interface —see @indicateurl{http://www.codesourcery.com/archives/cxx-abi}).
Interfacing can be done at 3 levels: simple data, subprograms, and
classes. In the first two cases, GNAT offers a specific @code{Convention C_Plus_Plus}
at the same time and may make one of the two compilers operate
improperly if set during invocation of the wrong compiler. It is also
very important that the linker uses the proper @code{libgcc.a} GCC
-library -- that is, the one from the C++ compiler installation. The
+library – that is, the one from the C++ compiler installation. The
implicit link command as suggested in the @code{gnatmake} command
from the former example can be replaced by an explicit link command with
the full-verbosity option in order to verify which library is used:
where CC is the name of the non-GNU C++ compiler.
-If the "zero cost" exception mechanism is used, and the platform
+If the “zero cost” exception mechanism is used, and the platform
supports automatic registration of exception tables (e.g., Solaris),
paths to more objects are required:
$ gnatlink ada_unit file1.o file2.o --LINK=./my_script
@end example
-If the "zero cost exception" mechanism is used, and the platform
-doesn't support automatic registration of exception tables (e.g., HP-UX
+If the “zero cost exception” mechanism is used, and the platform
+doesn’t support automatic registration of exception tables (e.g., HP-UX
or AIX), the simple approach described above will not work and
a pre-linking phase using GNAT will be necessary.
@end itemize
together automatically in most cases.
@node A Simple Example,Interfacing with C++ constructors,Linking a Mixed C++ & Ada Program,Building Mixed Ada and C++ Programs
-@anchor{gnat_ugn/the_gnat_compilation_model id67}@anchor{aa}@anchor{gnat_ugn/the_gnat_compilation_model a-simple-example}@anchor{ab}
+@anchor{gnat_ugn/the_gnat_compilation_model a-simple-example}@anchor{aa}@anchor{gnat_ugn/the_gnat_compilation_model id67}@anchor{ab}
@subsubsection A Simple Example
the constructor can be placed inside the construct.
@node Interfacing with C++ at the Class Level,,Interfacing with C++ constructors,Building Mixed Ada and C++ Programs
-@anchor{gnat_ugn/the_gnat_compilation_model interfacing-with-c-at-the-class-level}@anchor{ae}@anchor{gnat_ugn/the_gnat_compilation_model id69}@anchor{af}
+@anchor{gnat_ugn/the_gnat_compilation_model id69}@anchor{af}@anchor{gnat_ugn/the_gnat_compilation_model interfacing-with-c-at-the-class-level}@anchor{ae}
@subsubsection Interfacing with C++ at the Class Level
@end example
@node Generating Ada Bindings for C and C++ headers,Generating C Headers for Ada Specifications,Building Mixed Ada and C++ Programs,Mixed Language Programming
-@anchor{gnat_ugn/the_gnat_compilation_model id70}@anchor{b0}@anchor{gnat_ugn/the_gnat_compilation_model generating-ada-bindings-for-c-and-c-headers}@anchor{a7}
+@anchor{gnat_ugn/the_gnat_compilation_model generating-ada-bindings-for-c-and-c-headers}@anchor{a7}@anchor{gnat_ugn/the_gnat_compilation_model id70}@anchor{b0}
@subsection Generating Ada Bindings for C and C++ headers
will generate, under GNU/Linux, the following files: @code{time_h.ads},
@code{bits_time_h.ads}, @code{stddef_h.ads}, @code{bits_types_h.ads} which
correspond to the files @code{/usr/include/time.h},
-@code{/usr/include/bits/time.h}, etc..., and will then compile these Ada specs
+@code{/usr/include/bits/time.h}, etc…, and will then compile these Ada specs
in Ada 2005 mode.
The @code{-C} switch tells @code{gcc} to extract comments from headers,
@end example
@node Generating Bindings for C++ Headers,Switches,Running the Binding Generator,Generating Ada Bindings for C and C++ headers
-@anchor{gnat_ugn/the_gnat_compilation_model id72}@anchor{b3}@anchor{gnat_ugn/the_gnat_compilation_model generating-bindings-for-c-headers}@anchor{b4}
+@anchor{gnat_ugn/the_gnat_compilation_model generating-bindings-for-c-headers}@anchor{b3}@anchor{gnat_ugn/the_gnat_compilation_model id72}@anchor{b4}
@subsubsection Generating Bindings for C++ Headers
call subprograms, reference objects, and constants.
@node GNAT and Other Compilation Models,Using GNAT Files with External Tools,Mixed Language Programming,The GNAT Compilation Model
-@anchor{gnat_ugn/the_gnat_compilation_model id74}@anchor{ba}@anchor{gnat_ugn/the_gnat_compilation_model gnat-and-other-compilation-models}@anchor{2d}
+@anchor{gnat_ugn/the_gnat_compilation_model gnat-and-other-compilation-models}@anchor{2d}@anchor{gnat_ugn/the_gnat_compilation_model id74}@anchor{ba}
@section GNAT and Other 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
+don’t need to compile specs; they are compiled when they are used. The
Ada @emph{with} is similar in effect to the @code{#include} of a C
header.
@geindex GNAT library
-In GNAT, there is no 'library' in the normal sense. Instead, the set of
+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.
compiled.
@node Using GNAT Files with External Tools,,GNAT and Other Compilation Models,The GNAT Compilation Model
-@anchor{gnat_ugn/the_gnat_compilation_model using-gnat-files-with-external-tools}@anchor{2e}@anchor{gnat_ugn/the_gnat_compilation_model id77}@anchor{bf}
+@anchor{gnat_ugn/the_gnat_compilation_model id77}@anchor{bf}@anchor{gnat_ugn/the_gnat_compilation_model using-gnat-files-with-external-tools}@anchor{2e}
@section Using GNAT Files with External Tools
@end menu
@node Using Other Utility Programs with GNAT,The External Symbol Naming Scheme of GNAT,,Using GNAT Files with External Tools
-@anchor{gnat_ugn/the_gnat_compilation_model using-other-utility-programs-with-gnat}@anchor{c0}@anchor{gnat_ugn/the_gnat_compilation_model id78}@anchor{c1}
+@anchor{gnat_ugn/the_gnat_compilation_model id78}@anchor{c0}@anchor{gnat_ugn/the_gnat_compilation_model using-other-utility-programs-with-gnat}@anchor{c1}
@subsection Using Other Utility Programs with GNAT
as Purify.
@node The External Symbol Naming Scheme of GNAT,,Using Other Utility Programs with GNAT,Using GNAT Files with External Tools
-@anchor{gnat_ugn/the_gnat_compilation_model the-external-symbol-naming-scheme-of-gnat}@anchor{c2}@anchor{gnat_ugn/the_gnat_compilation_model id79}@anchor{c3}
+@anchor{gnat_ugn/the_gnat_compilation_model id79}@anchor{c2}@anchor{gnat_ugn/the_gnat_compilation_model the-external-symbol-naming-scheme-of-gnat}@anchor{c3}
@subsection The External Symbol Naming Scheme of GNAT
@c -- Example: A |withing| unit has a |with| clause, it |withs| a |withed| unit
@node Building Executable Programs with GNAT,GNAT Utility Programs,The GNAT Compilation Model,Top
-@anchor{gnat_ugn/building_executable_programs_with_gnat building-executable-programs-with-gnat}@anchor{a}@anchor{gnat_ugn/building_executable_programs_with_gnat doc}@anchor{c4}@anchor{gnat_ugn/building_executable_programs_with_gnat id1}@anchor{c5}
+@anchor{gnat_ugn/building_executable_programs_with_gnat doc}@anchor{c4}@anchor{gnat_ugn/building_executable_programs_with_gnat building-executable-programs-with-gnat}@anchor{a}@anchor{gnat_ugn/building_executable_programs_with_gnat id1}@anchor{c5}
@chapter Building Executable Programs with GNAT
@end menu
@node Building with gnatmake,Compiling with gcc,,Building Executable Programs with GNAT
-@anchor{gnat_ugn/building_executable_programs_with_gnat the-gnat-make-program-gnatmake}@anchor{c6}@anchor{gnat_ugn/building_executable_programs_with_gnat building-with-gnatmake}@anchor{ca}
+@anchor{gnat_ugn/building_executable_programs_with_gnat building-with-gnatmake}@anchor{ca}@anchor{gnat_ugn/building_executable_programs_with_gnat the-gnat-make-program-gnatmake}@anchor{c6}
@section Building with @code{gnatmake}
Note that for advanced forms of project structure, we recommend creating
a project file as explained in the @emph{GNAT_Project_Manager} chapter in the
-@emph{GPRbuild User's Guide}, and using the
+@emph{GPRbuild User’s Guide}, and using the
@code{gprbuild} tool which supports building with project files and works similarly
to @code{gnatmake}.
@end menu
@node Running gnatmake,Switches for gnatmake,,Building with gnatmake
-@anchor{gnat_ugn/building_executable_programs_with_gnat running-gnatmake}@anchor{cb}@anchor{gnat_ugn/building_executable_programs_with_gnat id2}@anchor{cc}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id2}@anchor{cb}@anchor{gnat_ugn/building_executable_programs_with_gnat running-gnatmake}@anchor{cc}
@subsection Running @code{gnatmake}
@code{-M} switch is sent to @code{stdout}.
@node Switches for gnatmake,Mode Switches for gnatmake,Running gnatmake,Building with gnatmake
-@anchor{gnat_ugn/building_executable_programs_with_gnat switches-for-gnatmake}@anchor{cd}@anchor{gnat_ugn/building_executable_programs_with_gnat id3}@anchor{ce}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id3}@anchor{cd}@anchor{gnat_ugn/building_executable_programs_with_gnat switches-for-gnatmake}@anchor{ce}
@subsection Switches for @code{gnatmake}
@item @code{--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".
+has the same name as the executable with extension “.map”.
@item @code{--create-map-file=@emph{mapfile}}
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. @code{gnatmake} "trusts" the source info file. This means that
+fail. @code{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.
@end table
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
+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
@code{-P} is used, a mapping file is always used, so
@geindex naming scheme
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
+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
@item @code{-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 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 @code{-a} switch is also specified.
@end table
@item @code{-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
+ease the programmer’s task in case of compilation errors, the list of
sources for which the compile fails is given when @code{gnatmake}
terminates.
@item @code{-n}
-Don't compile, bind, or link. Checks if all objects are up to date.
+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
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 different ‘first letter’ switches are ignored, but
orders between same switches are taken into account. For example,
@code{-O -O2} is different than @code{-O2 -O}, but @code{-g -O}
is equivalent to @code{-O -g}.
@end itemize
@node How gnatmake Works,Examples of gnatmake Usage,Notes on the Command Line,Building with gnatmake
-@anchor{gnat_ugn/building_executable_programs_with_gnat id6}@anchor{d4}@anchor{gnat_ugn/building_executable_programs_with_gnat how-gnatmake-works}@anchor{d5}
+@anchor{gnat_ugn/building_executable_programs_with_gnat how-gnatmake-works}@anchor{d4}@anchor{gnat_ugn/building_executable_programs_with_gnat id6}@anchor{d5}
@subsection How @code{gnatmake} Works
Generally @code{gnatmake} automatically performs all necessary
-recompilations and you don't need to worry about how it works. However,
+recompilations and you don’t need to worry about how it works. However,
it may be useful to have some basic understanding of the @code{gnatmake}
approach and in particular to understand how it uses the results of
previous compilations without incorrectly depending on them.
This process ensures that @code{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
+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
The content of the @code{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.
-@ref{71,,Installing a library}
+@ref{72,,Installing a library}
@end itemize
Specifying the switch @code{-I-}
@end itemize
@node Examples,,Order of Compilation Issues,Compiling with gcc
-@anchor{gnat_ugn/building_executable_programs_with_gnat id12}@anchor{df}@anchor{gnat_ugn/building_executable_programs_with_gnat examples}@anchor{e0}
+@anchor{gnat_ugn/building_executable_programs_with_gnat examples}@anchor{df}@anchor{gnat_ugn/building_executable_programs_with_gnat id12}@anchor{e0}
@subsection Examples
@end menu
@node Alphabetical List of All Switches,Output and Error Message Control,,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat id13}@anchor{e2}@anchor{gnat_ugn/building_executable_programs_with_gnat alphabetical-list-of-all-switches}@anchor{e3}
+@anchor{gnat_ugn/building_executable_programs_with_gnat alphabetical-list-of-all-switches}@anchor{e2}@anchor{gnat_ugn/building_executable_programs_with_gnat id13}@anchor{e3}
@subsection Alphabetical List of All Switches
Load compiler executables (for example, @code{gnat1}, the Ada compiler)
from @code{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
+See the “Options for Directory Search” section in the
@cite{Using the GNU Compiler Collection (GCC)} manual for further details.
You would normally use the @code{-b} or @code{-V} switch instead.
@end table
@item @code{-gnatB}
-Assume no invalid (bad) values except for 'Valid attribute use
+Assume no invalid (bad) values except for ‘Valid attribute use
(@ref{e7,,Validity Checking}).
@end table
Specify a configuration pragma file
(the equal sign is optional)
-(@ref{62,,The Configuration Pragmas Files}).
+(@ref{63,,The Configuration Pragmas Files}).
@end table
@geindex -gnateC (gcc)
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
+Note that this option should be used only for compiling – the
code is likely to malfunction at run time.
@end table
Entry calls
@item
-Indirect calls using 'Access
+Indirect calls using ‘Access
@item
Requeue statements
@item @code{-gnatq}
-Don't quit. Try semantics, even if parse errors.
+Don’t quit. Try semantics, even if parse errors.
@end table
@geindex -gnatQ (gcc)
@item @code{-gnatQ}
-Don't quit. Generate @code{ALI} and tree files even if illegalities.
+Don’t quit. Generate @code{ALI} and tree files even if illegalities.
Note that code generation is still suppressed in the presence of any
errors, so even with @code{-gnatQ} no object file is generated.
@end table
@item @code{-gnatU}
-Tag all error messages with the unique string 'error:'
+Tag all error messages with the unique string ‘error:’
@end table
@geindex -gnatv (gcc)
@item @code{--RTS=@emph{rts-path}}
Specifies the default location of the run-time library. Same meaning as the
-equivalent @code{gnatmake} flag (@ref{cd,,Switches for gnatmake}).
+equivalent @code{gnatmake} flag (@ref{ce,,Switches for gnatmake}).
@end table
@geindex -S (gcc)
The switch @code{-gnat-p} may not be combined with any other switch.
@item
-Once a 'y' appears in the string (that is a use of the @code{-gnaty}
+Once a ‘y’ appears in the string (that is a use of the @code{-gnaty}
switch), then all further characters in the switch are interpreted
as style modifiers (see description of @code{-gnaty}).
@item
-Once a 'd' appears in the string (that is a use of the @code{-gnatd}
+Once a ‘d’ appears in the string (that is a use of the @code{-gnatd}
switch), then all further characters in the switch are interpreted
as debug flags (see description of @code{-gnatd}).
@item
-Once a 'w' appears in the string (that is a use of the @code{-gnatw}
+Once a ‘w’ appears in the string (that is a use of the @code{-gnatw}
switch), then all further characters in the switch are interpreted
as warning mode modifiers (see description of @code{-gnatw}).
@item
-Once a 'V' appears in the string (that is a use of the @code{-gnatV}
+Once a ‘V’ appears in the string (that is a use of the @code{-gnatV}
switch), then all further characters in the switch are interpreted
as validity checking options (@ref{e7,,Validity Checking}).
@item
-Option 'em', 'ec', 'ep', 'l=' and 'R' must be the last options in
+Option ‘em’, ‘ec’, ‘ep’, ‘l=’ and ‘R’ must be the last options in
a combined list of options.
@end itemize
@geindex stderr
-The standard default format for error messages is called 'brief format'.
+The standard default format for error messages is called ‘brief format’.
Brief format messages are written to @code{stderr} (the standard error
file) and have the following form:
@item @code{-gnatU}
This switch forces all error messages to be preceded by the unique
-string 'error:'. This means that error messages take a few more
+string ‘error:’. This means that error messages take a few more
characters in space, but allows easy searching for and identification
of error messages.
@end table
@item @code{-gnatq}
-The @code{q} stands for quit (really 'don't quit').
+The @code{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.
@end table
@node Warning Message Control,Debugging and Assertion Control,Output and Error Message Control,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat warning-message-control}@anchor{eb}@anchor{gnat_ugn/building_executable_programs_with_gnat id15}@anchor{f0}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id15}@anchor{f0}@anchor{gnat_ugn/building_executable_programs_with_gnat warning-message-control}@anchor{eb}
@subsection Warning Message Control
false positive warnings.
This warning option also activates a special test for comparisons using
-the operators '>=' and' <='.
+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 '='.
+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 @code{Natural} variable <= 0.
This warning option also generates warnings if
@emph{[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: ".
+the string “error: ” rather than “warning: “.
@item
@emph{[enabled by default]}
or @code{System}
hierarchies that is not
documented in either the Ada Reference Manual or the GNAT
-Programmer's Reference Manual. Such units are intended only
+Programmer’s Reference Manual. Such units are intended only
for internal implementation purposes and should not be @emph{with}ed
by user programs. The default is that such warnings are generated
@end table
@emph{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.
+preconditions, and postconditions from Type_Invariant’Class, Invariant’Class,
+Pre’Class, and Post’Class aspects. Also list inherited subtype predicates.
@end table
@geindex -gnatw.L (gcc)
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
+serves to emphasize that the “misordering” is deliberate). The
default is that such warnings are not given.
@end table
of the storage unit,
@item
-then the remaining components whose length doesn't depend on discriminants
+then the remaining components whose length doesn’t depend on discriminants
(that is to say, with variable but uniform length for all objects),
@item
are declared but not referenced, and for units that are @emph{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
+no entities in the package are referenced. This means that if a with’ed
package is referenced but the only references are in @code{use}
clauses or @code{renames}
declarations, a warning is still generated. A warning is also generated
@emph{Activate info messages for non-default bit order.}
-This switch activates messages (labeled "info", they are not warnings,
+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
@emph{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
+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.
@end table
@emph{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
+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:
@end example
The pragmas @code{Assert} and @code{Debug} normally have no effect and
-are ignored. This switch, where @code{a} stands for 'assert', causes
+are ignored. This switch, where @code{a} stands for ‘assert’, causes
pragmas @code{Assert} and @code{Debug} to be activated. This switch also
causes preconditions, postconditions, subtype predicates, and
type invariants to be activated.
@end table
@node Validity Checking,Style Checking,Debugging and Assertion Control,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat validity-checking}@anchor{e7}@anchor{gnat_ugn/building_executable_programs_with_gnat id17}@anchor{f3}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id17}@anchor{f3}@anchor{gnat_ugn/building_executable_programs_with_gnat validity-checking}@anchor{e7}
@subsection Validity Checking
in writing the GNAT sources themselves. This switch allows user programs
to activate all or some of these checks. If the source program fails a
specified style check, an appropriate message is given, preceded by
-the character sequence '(style)'. This message does not prevent
+the character sequence ‘(style)’. This message does not prevent
successful compilation (unless the @code{-gnatwe} switch is used).
Note that this is by no means intended to be a general facility for
@emph{Check separate specs.}
-Separate declarations ('specs') are required for subprograms (a
+Separate declarations (‘specs’) are required for subprograms (a
body is not allowed to serve as its own declaration). The only
exception is that parameterless library level procedures are
not required to have a separate declaration. This exception covers
If any of these style rules is violated, a message is generated giving
details on the violation. The initial characters of such messages are
-always '@cite{(style)}'. Note that these messages are treated as warning
+always ‘@cite{(style)}’. Note that these messages are treated as warning
messages, so they normally do not prevent the generation of an object
file. The @code{-gnatwe} switch can be used to treat warning messages,
including style messages, as fatal errors.
The switch @code{-gnatyN} clears any previously set style checks.
@node Run-Time Checks,Using gcc for Syntax Checking,Style Checking,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat run-time-checks}@anchor{ea}@anchor{gnat_ugn/building_executable_programs_with_gnat id19}@anchor{f5}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id19}@anchor{f5}@anchor{gnat_ugn/building_executable_programs_with_gnat run-time-checks}@anchor{ea}
@subsection Run-Time Checks
checking code is zero or near-zero, the compiler will generate it even
if checks are suppressed. In particular, if the compiler can prove
that a certain check will necessarily fail, it will generate code to
-do an unconditional 'raise', even if checks are suppressed. The
+do an unconditional ‘raise’, even if checks are suppressed. The
compiler warns in this case. Another case in which checks may not be
eliminated is when they are embedded in certain run-time routines such
as math library routines.
This switch controls the mode used for computing intermediate
arithmetic integer operations, and also enables overflow checking.
For a full description of overflow mode and checking control, see
-the 'Overflow Check Handling in GNAT' appendix in this
-User's Guide.
+the ‘Overflow Check Handling in GNAT’ appendix in this
+User’s Guide.
Overflow checks are always enabled by this switch. The argument
controls the mode, using the codes
@item @code{-gnats}
-The @code{s} stands for 'syntax'.
+The @code{s} stands for ‘syntax’.
Run GNAT in syntax checking only mode. For
example, the command
@item @code{-gnatc}
-The @code{c} stands for 'check'.
+The @code{c} stands for ‘check’.
Causes the compiler to operate in semantic check mode,
with full checking for all illegalities specified in the
Ada Reference Manual, but without generation of any object code
@end table
@node Character Set Control,File Naming Control,Compiling Different Versions of Ada,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat id23}@anchor{fb}@anchor{gnat_ugn/building_executable_programs_with_gnat character-set-control}@anchor{31}
+@anchor{gnat_ugn/building_executable_programs_with_gnat character-set-control}@anchor{31}@anchor{gnat_ugn/building_executable_programs_with_gnat id23}@anchor{fb}
@subsection Character Set Control
Note that brackets coding is always accepted, even if one of the other
options is specified, so for example @code{-gnatW8} specifies that both
brackets and UTF-8 encodings will be recognized. The units that are
-with'ed directly or indirectly will be scanned using the specified
+with’ed directly or indirectly will be scanned using the specified
representation scheme, and so if one of the non-brackets scheme is
used, it must be used consistently throughout the program. However,
since brackets encoding is always recognized, it may be conveniently
@item @code{-gnatk@emph{n}}
-Activates file name 'krunching'. @code{n}, a decimal integer in the range
+Activates file name ‘krunching’. @code{n}, a decimal integer in the range
1-999, indicates the maximum allowable length of a file name (not
including the @code{.ads} or @code{.adb} extension). The default is not
to enable file name krunching.
@end table
@node Subprogram Inlining Control,Auxiliary Output Control,File Naming Control,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat subprogram-inlining-control}@anchor{fe}@anchor{gnat_ugn/building_executable_programs_with_gnat id25}@anchor{ff}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id25}@anchor{fe}@anchor{gnat_ugn/building_executable_programs_with_gnat subprogram-inlining-control}@anchor{ff}
@subsection Subprogram Inlining Control
@item @code{-gnatn[12]}
-The @code{n} here is intended to suggest the first syllable of the word 'inline'.
+The @code{n} here is intended to suggest the first syllable of the word ‘inline’.
GNAT recognizes and processes @code{Inline} pragmas. However, for inlining to
actually occur, optimization must be enabled and, by default, inlining of
subprograms across units is not performed. If you want to additionally
For @code{-gnatR3}, symbolic expressions for values that are computed
at run time for records are included. These symbolic expressions have
a mostly obvious format with #n being used to represent the value of the
-n'th discriminant. See source files @code{repinfo.ads/adb} in the
+n’th discriminant. See source files @code{repinfo.ads/adb} in the
GNAT sources for full details on the format of @code{-gnatR3} output.
For @code{-gnatR4}, information for relevant compiler-generated types
Historically, old debug formats like stabs were not powerful enough to
express some Ada types (for instance, variant records or fixed-point types).
To work around this, GNAT introduced proprietary encodings that embed the
-missing information ("GNAT encodings").
+missing information (“GNAT encodings”).
Recent versions of the DWARF debug information format are now able to
-correctly describe most of these Ada constructs ("standard DWARF"). As
+correctly describe most of these Ada constructs (“standard DWARF”). As
third-party tools started to use this format, GNAT has been enhanced to
generate it. However, most tools (including GDB) are still relying on GNAT
encodings.
@end table
@node Exception Handling Control,Units to Sources Mapping Files,Debugging Control,Compiler Switches
-@anchor{gnat_ugn/building_executable_programs_with_gnat id28}@anchor{105}@anchor{gnat_ugn/building_executable_programs_with_gnat exception-handling-control}@anchor{106}
+@anchor{gnat_ugn/building_executable_programs_with_gnat exception-handling-control}@anchor{105}@anchor{gnat_ugn/building_executable_programs_with_gnat id28}@anchor{106}
@subsection Exception Handling Control
exception propagation, but introduces significant overhead for
the use of exception handlers, even if no exception is raised.
-The other approach is called 'zero cost' exception handling.
+The other approach is called ‘zero cost’ exception handling.
With this method, the compiler builds static tables to describe
the exception ranges. No dynamic code is required when entering
a frame containing an exception handler. When an exception is
exception handlers if no exception is raised. Note that in this
mode and in the context of mixed Ada and C/C++ programming,
to propagate an exception through a C/C++ code, the C/C++ code
-must be compiled with the @code{-funwind-tables} GCC's
+must be compiled with the @code{-funwind-tables} GCC’s
option.
The following switches may be used to control which of the
The same option @code{--RTS} must be used both for @code{gcc}
and @code{gnatbind}. Passing this option to @code{gnatmake}
-(@ref{cd,,Switches for gnatmake}) will ensure the required consistency
+(@ref{ce,,Switches for gnatmake}) will ensure the required consistency
through the compilation and binding steps.
@node Units to Sources Mapping Files,Code Generation Control,Exception Handling Control,Compiler Switches
unless you actually see a performance improvement.
@node Linker Switches,Binding with gnatbind,Compiler Switches,Building Executable Programs with GNAT
-@anchor{gnat_ugn/building_executable_programs_with_gnat linker-switches}@anchor{10a}@anchor{gnat_ugn/building_executable_programs_with_gnat id31}@anchor{10b}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id31}@anchor{10a}@anchor{gnat_ugn/building_executable_programs_with_gnat linker-switches}@anchor{10b}
@section Linker Switches
@end menu
@node Running gnatbind,Switches for gnatbind,,Binding with gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat running-gnatbind}@anchor{10d}@anchor{gnat_ugn/building_executable_programs_with_gnat id33}@anchor{10e}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id33}@anchor{10d}@anchor{gnat_ugn/building_executable_programs_with_gnat running-gnatbind}@anchor{10e}
@subsection Running @code{gnatbind}
@item @code{-Ea}
Store tracebacks in exception occurrences when the target supports it.
-The "a" is for "address"; tracebacks will contain hexadecimal addresses,
+The “a” is for “address”; tracebacks will contain hexadecimal addresses,
unless symbolic tracebacks are enabled.
See also the packages @code{GNAT.Traceback} and
@item @code{-Es}
Store tracebacks in exception occurrences when the target supports it.
-The "s" is for "symbolic"; symbolic tracebacks are enabled.
+The “s” is for “symbolic”; symbolic tracebacks are enabled.
@end table
@geindex -E (gnatbind)
@itemize *
@item
-Starting the program's execution in the debugger will cause it to
+Starting the program’s execution in the debugger will cause it to
stop at the start of the @code{main} function instead of the main subprogram.
This can be worked around by manually inserting a breakpoint on that
-subprogram and resuming the program's execution until reaching that breakpoint.
+subprogram and resuming the program’s execution until reaching that breakpoint.
@item
Programs using GNAT.Compiler_Version will not link.
@item @code{--RTS=@emph{rts-path}}
Specifies the default location of the run-time library. Same meaning as the
-equivalent @code{gnatmake} flag (@ref{cd,,Switches for gnatmake}).
+equivalent @code{gnatmake} flag (@ref{ce,,Switches for gnatmake}).
@geindex -o (gnatbind)
Enable dynamic stack usage, with @code{n} results stored and displayed
at program termination. A result is generated when a task
-terminates. Results that can't be stored are displayed on the fly, at
+terminates. Results that can’t be stored are displayed on the fly, at
task termination. This option is currently not supported on Itanium
platforms. (See @ref{113,,Dynamic Stack Usage Analysis} for details.)
@end table
@node Binder Error Message Control,Elaboration Control,Consistency-Checking Modes,Switches for gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat id36}@anchor{116}@anchor{gnat_ugn/building_executable_programs_with_gnat binder-error-message-control}@anchor{117}
+@anchor{gnat_ugn/building_executable_programs_with_gnat binder-error-message-control}@anchor{116}@anchor{gnat_ugn/building_executable_programs_with_gnat id36}@anchor{117}
@subsubsection Binder Error Message Control
@end table
@node Elaboration Control,Output Control,Binder Error Message Control,Switches for gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat id37}@anchor{118}@anchor{gnat_ugn/building_executable_programs_with_gnat elaboration-control}@anchor{111}
+@anchor{gnat_ugn/building_executable_programs_with_gnat elaboration-control}@anchor{111}@anchor{gnat_ugn/building_executable_programs_with_gnat id37}@anchor{118}
@subsubsection Elaboration Control
Force elaboration order.
-@code{elab-order} should be the name of a "forced elaboration order file", that
+@code{elab-order} should be the name of a “forced elaboration order file”, that
is, a text file containing library item names, one per line. A name of the
-form "some.unit%s" or "some.unit (spec)" denotes the spec of Some.Unit. A
-name of the form "some.unit%b" or "some.unit (body)" denotes the body of
+form “some.unit%s” or “some.unit (spec)” denotes the spec of Some.Unit. A
+name of the form “some.unit%b” or “some.unit (body)” denotes the body of
Some.Unit. Each pair of lines is taken to mean that there is an elaboration
dependence of the second line on the first. For example, if the file
contains:
The given order must be consistent with Ada rules, or else @code{gnatbind} will
give elaboration cycle errors. For example, if you say x (body) should be
elaborated before x (spec), there will be a cycle, because Ada rules require
-x (spec) to be elaborated before x (body); you can't have the spec and body
+x (spec) to be elaborated before x (body); you can’t have the spec and body
both elaborated before each other.
-If you later add "with That;" to the body of This, there will be a cycle, in
-which case you should erase either "this (body)" or "that (spec)" from the
+If you later add “with That;” to the body of This, there will be a cycle, in
+which case you should erase either “this (body)” or “that (spec)” from the
above forced elaboration order file.
Blank lines and Ada-style comments are ignored. Unit names that do not exist
@end table
@node Output Control,Dynamic Allocation Control,Elaboration Control,Switches for gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat output-control}@anchor{119}@anchor{gnat_ugn/building_executable_programs_with_gnat id38}@anchor{11a}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id38}@anchor{119}@anchor{gnat_ugn/building_executable_programs_with_gnat output-control}@anchor{11a}
@subsubsection Output Control
@subsubsection Dynamic Allocation Control
-The heap control switches -- @code{-H32} and @code{-H64} --
+The heap control switches – @code{-H32} and @code{-H64} –
determine whether dynamic allocation uses 32-bit or 64-bit memory.
They only affect compiler-generated allocations via @code{__gnat_malloc};
explicit calls to @code{malloc} and related functions from the C
@end table
@node Command-Line Access,Search Paths for gnatbind,Switches for gnatbind,Binding with gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat id42}@anchor{11f}@anchor{gnat_ugn/building_executable_programs_with_gnat command-line-access}@anchor{120}
+@anchor{gnat_ugn/building_executable_programs_with_gnat command-line-access}@anchor{11f}@anchor{gnat_ugn/building_executable_programs_with_gnat id42}@anchor{120}
@subsection Command-Line Access
it.
@node Search Paths for gnatbind,Examples of gnatbind Usage,Command-Line Access,Binding with gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat search-paths-for-gnatbind}@anchor{76}@anchor{gnat_ugn/building_executable_programs_with_gnat id43}@anchor{121}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id43}@anchor{121}@anchor{gnat_ugn/building_executable_programs_with_gnat search-paths-for-gnatbind}@anchor{76}
@subsection Search Paths for @code{gnatbind}
The content of the @code{ada_object_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) unless the switch @code{-nostdlib} is
-specified. See @ref{71,,Installing a library}
+specified. See @ref{72,,Installing a library}
@end itemize
@geindex -I (gnatbind)
development environments much more flexible.
@node Examples of gnatbind Usage,,Search Paths for gnatbind,Binding with gnatbind
-@anchor{gnat_ugn/building_executable_programs_with_gnat id44}@anchor{122}@anchor{gnat_ugn/building_executable_programs_with_gnat examples-of-gnatbind-usage}@anchor{123}
+@anchor{gnat_ugn/building_executable_programs_with_gnat examples-of-gnatbind-usage}@anchor{122}@anchor{gnat_ugn/building_executable_programs_with_gnat id44}@anchor{123}
@subsection Examples of @code{gnatbind} Usage
@item @code{-M}
When linking an executable, create a map file. The name of the map file
-has the same name as the executable with extension ".map".
+has the same name as the executable with extension “.map”.
@end table
@geindex -M= (gnatlink)
@end table
@node Using the GNU make Utility,,Linking with gnatlink,Building Executable Programs with GNAT
-@anchor{gnat_ugn/building_executable_programs_with_gnat using-the-gnu-make-utility}@anchor{70}@anchor{gnat_ugn/building_executable_programs_with_gnat id48}@anchor{12b}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id48}@anchor{12b}@anchor{gnat_ugn/building_executable_programs_with_gnat using-the-gnu-make-utility}@anchor{70}
@section Using the GNU @code{make} Utility
@end menu
@node Using gnatmake in a Makefile,Automatically Creating a List of Directories,,Using the GNU make Utility
-@anchor{gnat_ugn/building_executable_programs_with_gnat using-gnatmake-in-a-makefile}@anchor{12c}@anchor{gnat_ugn/building_executable_programs_with_gnat id49}@anchor{12d}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id49}@anchor{12c}@anchor{gnat_ugn/building_executable_programs_with_gnat using-gnatmake-in-a-makefile}@anchor{12d}
@subsection Using gnatmake in a Makefile
@end example
@node Automatically Creating a List of Directories,Generating the Command Line Switches,Using gnatmake in a Makefile,Using the GNU make Utility
-@anchor{gnat_ugn/building_executable_programs_with_gnat id50}@anchor{12f}@anchor{gnat_ugn/building_executable_programs_with_gnat automatically-creating-a-list-of-directories}@anchor{12e}
+@anchor{gnat_ugn/building_executable_programs_with_gnat automatically-creating-a-list-of-directories}@anchor{12e}@anchor{gnat_ugn/building_executable_programs_with_gnat id50}@anchor{12f}
@subsection Automatically Creating a List of Directories
@end example
@node Generating the Command Line Switches,Overcoming Command Line Length Limits,Automatically Creating a List of Directories,Using the GNU make Utility
-@anchor{gnat_ugn/building_executable_programs_with_gnat id51}@anchor{130}@anchor{gnat_ugn/building_executable_programs_with_gnat generating-the-command-line-switches}@anchor{131}
+@anchor{gnat_ugn/building_executable_programs_with_gnat generating-the-command-line-switches}@anchor{130}@anchor{gnat_ugn/building_executable_programs_with_gnat id51}@anchor{131}
@subsection Generating the Command Line Switches
@end example
@node Overcoming Command Line Length Limits,,Generating the Command Line Switches,Using the GNU make Utility
-@anchor{gnat_ugn/building_executable_programs_with_gnat overcoming-command-line-length-limits}@anchor{132}@anchor{gnat_ugn/building_executable_programs_with_gnat id52}@anchor{133}
+@anchor{gnat_ugn/building_executable_programs_with_gnat id52}@anchor{132}@anchor{gnat_ugn/building_executable_programs_with_gnat overcoming-command-line-length-limits}@anchor{133}
@subsection Overcoming Command Line Length Limits
@end menu
@node Running gnatclean,Switches for gnatclean,,The File Cleanup Utility gnatclean
-@anchor{gnat_ugn/gnat_utility_programs running-gnatclean}@anchor{139}@anchor{gnat_ugn/gnat_utility_programs id3}@anchor{13a}
+@anchor{gnat_ugn/gnat_utility_programs id3}@anchor{139}@anchor{gnat_ugn/gnat_utility_programs running-gnatclean}@anchor{13a}
@subsection Running @code{gnatclean}
@end table
@node The GNAT Library Browser gnatls,,The File Cleanup Utility gnatclean,GNAT Utility Programs
-@anchor{gnat_ugn/gnat_utility_programs the-gnat-library-browser-gnatls}@anchor{137}@anchor{gnat_ugn/gnat_utility_programs id5}@anchor{13d}
+@anchor{gnat_ugn/gnat_utility_programs id5}@anchor{13d}@anchor{gnat_ugn/gnat_utility_programs the-gnat-library-browser-gnatls}@anchor{137}
@section The GNAT Library Browser @code{gnatls}
@item @code{-aO@emph{dir}}, @code{-aI@emph{dir}}, @code{-I@emph{dir}}, @code{-I-}, @code{-nostdinc}
Source path manipulation. Same meaning as the equivalent @code{gnatmake}
-flags (@ref{cd,,Switches for gnatmake}).
+flags (@ref{ce,,Switches for gnatmake}).
@end table
@geindex -aP (gnatls)
@item @code{--RTS=@emph{rts-path}}
Specifies the default location of the runtime library. Same meaning as the
-equivalent @code{gnatmake} flag (@ref{cd,,Switches for gnatmake}).
+equivalent @code{gnatmake} flag (@ref{ce,,Switches for gnatmake}).
@end table
@geindex -v (gnatls)
@end table
@node Example of gnatls Usage,,Switches for gnatls,The GNAT Library Browser gnatls
-@anchor{gnat_ugn/gnat_utility_programs id8}@anchor{142}@anchor{gnat_ugn/gnat_utility_programs example-of-gnatls-usage}@anchor{143}
+@anchor{gnat_ugn/gnat_utility_programs example-of-gnatls-usage}@anchor{142}@anchor{gnat_ugn/gnat_utility_programs id8}@anchor{143}
@subsection Example of @code{gnatls} Usage
@c -- Example: A |withing| unit has a |with| clause, it |withs| a |withed| unit
@node GNAT and Program Execution,Platform-Specific Information,GNAT Utility Programs,Top
-@anchor{gnat_ugn/gnat_and_program_execution gnat-and-program-execution}@anchor{c}@anchor{gnat_ugn/gnat_and_program_execution doc}@anchor{144}@anchor{gnat_ugn/gnat_and_program_execution id1}@anchor{145}
+@anchor{gnat_ugn/gnat_and_program_execution doc}@anchor{144}@anchor{gnat_ugn/gnat_and_program_execution gnat-and-program-execution}@anchor{c}@anchor{gnat_ugn/gnat_and_program_execution id1}@anchor{145}
@chapter GNAT and Program Execution
@end menu
@node The GNAT Debugger GDB,Running GDB,,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution the-gnat-debugger-gdb}@anchor{14e}@anchor{gnat_ugn/gnat_and_program_execution id3}@anchor{14f}
+@anchor{gnat_ugn/gnat_and_program_execution id3}@anchor{14e}@anchor{gnat_ugn/gnat_and_program_execution the-gnat-debugger-gdb}@anchor{14f}
@subsection The GNAT Debugger GDB
describes some of the additional commands that can be given to @code{GDB}.
@node Introduction to GDB Commands,Using Ada Expressions,Running GDB,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution introduction-to-gdb-commands}@anchor{152}@anchor{gnat_ugn/gnat_and_program_execution id5}@anchor{153}
+@anchor{gnat_ugn/gnat_and_program_execution id5}@anchor{152}@anchor{gnat_ugn/gnat_and_program_execution introduction-to-gdb-commands}@anchor{153}
@subsection Introduction to GDB Commands
implicit @code{with} and @code{use} clauses in effect for all user-written
packages, thus making it unnecessary to fully qualify most names with
their packages, regardless of context. Where this causes ambiguity,
-@code{GDB} asks the user's intent.
+@code{GDB} asks the user’s intent.
For details on the supported Ada syntax, see @cite{Debugging with GDB}.
@node Calling User-Defined Subprograms,Using the next Command in a Function,Using Ada Expressions,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution id7}@anchor{156}@anchor{gnat_ugn/gnat_and_program_execution calling-user-defined-subprograms}@anchor{157}
+@anchor{gnat_ugn/gnat_and_program_execution calling-user-defined-subprograms}@anchor{156}@anchor{gnat_ugn/gnat_and_program_execution id7}@anchor{157}
@subsection Calling User-Defined Subprograms
the elements in the desired format.
@node Using the next Command in a Function,Stopping When Ada Exceptions Are Raised,Calling User-Defined Subprograms,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution using-the-next-command-in-a-function}@anchor{158}@anchor{gnat_ugn/gnat_and_program_execution id8}@anchor{159}
+@anchor{gnat_ugn/gnat_and_program_execution id8}@anchor{158}@anchor{gnat_ugn/gnat_and_program_execution using-the-next-command-in-a-function}@anchor{159}
@subsection Using the @emph{next} Command in a Function
location will advance to the next statement as usual. A special case
arises in the case of a @code{return} statement.
-Part of the code for a return statement is the 'epilogue' of the function.
+Part of the code for a return statement is the ‘epilogue’ of the function.
This is the code that returns to the caller. There is only one copy of
this epilogue code, and it is typically associated with the last return
statement in the function if there is more than one return. In some
that was stepped through.
@node Stopping When Ada Exceptions Are Raised,Ada Tasks,Using the next Command in a Function,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution stopping-when-ada-exceptions-are-raised}@anchor{15a}@anchor{gnat_ugn/gnat_and_program_execution id9}@anchor{15b}
+@anchor{gnat_ugn/gnat_and_program_execution id9}@anchor{15a}@anchor{gnat_ugn/gnat_and_program_execution stopping-when-ada-exceptions-are-raised}@anchor{15b}
@subsection Stopping When Ada Exceptions Are Raised
@itemize *
@item
-@code{break`@w{`}*linespec* `@w{`}task} @emph{taskid}, @code{break} @emph{linespec} @code{task} @emph{taskid} @code{if} ...
+@code{break`@w{`}*linespec* `@w{`}task} @emph{taskid}, @code{break} @emph{linespec} @code{task} @emph{taskid} @code{if} …
@quotation
@geindex Remote Debugging with gdbserver
@node Remote Debugging with gdbserver,GNAT Abnormal Termination or Failure to Terminate,Debugging Generic Units,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution remote-debugging-with-gdbserver}@anchor{160}@anchor{gnat_ugn/gnat_and_program_execution id12}@anchor{161}
+@anchor{gnat_ugn/gnat_and_program_execution id12}@anchor{160}@anchor{gnat_ugn/gnat_and_program_execution remote-debugging-with-gdbserver}@anchor{161}
@subsection Remote Debugging with gdbserver
@code{gdb} directly on the @code{gnat1} executable. @code{gnat1} is the
front-end of GNAT, and can be run independently (normally it is just
called from @code{gcc}). You can use @code{gdb} on @code{gnat1} as you
-would on a C program (but @ref{14e,,The GNAT Debugger GDB} for caveats). The
+would on a C program (but @ref{14f,,The GNAT Debugger GDB} for caveats). The
@code{where} command is the first line of attack; the variable
@code{lineno} (seen by @code{print lineno}), used by the second phase of
@code{gnat1} and by the @code{gcc} backend, indicates the source line at
@end itemize
@node Naming Conventions for GNAT Source Files,Getting Internal Debugging Information,GNAT Abnormal Termination or Failure to Terminate,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution naming-conventions-for-gnat-source-files}@anchor{164}@anchor{gnat_ugn/gnat_and_program_execution id14}@anchor{165}
+@anchor{gnat_ugn/gnat_and_program_execution id14}@anchor{164}@anchor{gnat_ugn/gnat_and_program_execution naming-conventions-for-gnat-source-files}@anchor{165}
@subsection Naming Conventions for GNAT Source Files
@end itemize
@node Getting Internal Debugging Information,Stack Traceback,Naming Conventions for GNAT Source Files,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution id15}@anchor{166}@anchor{gnat_ugn/gnat_and_program_execution getting-internal-debugging-information}@anchor{167}
+@anchor{gnat_ugn/gnat_and_program_execution getting-internal-debugging-information}@anchor{166}@anchor{gnat_ugn/gnat_and_program_execution id15}@anchor{167}
@subsection Getting Internal Debugging Information
@geindex stack unwinding
@node Stack Traceback,Pretty-Printers for the GNAT runtime,Getting Internal Debugging Information,Running and Debugging Ada Programs
-@anchor{gnat_ugn/gnat_and_program_execution stack-traceback}@anchor{168}@anchor{gnat_ugn/gnat_and_program_execution id16}@anchor{169}
+@anchor{gnat_ugn/gnat_and_program_execution id16}@anchor{168}@anchor{gnat_ugn/gnat_and_program_execution stack-traceback}@anchor{169}
@subsection Stack Traceback
@end menu
@node Non-Symbolic Traceback,Symbolic Traceback,,Stack Traceback
-@anchor{gnat_ugn/gnat_and_program_execution non-symbolic-traceback}@anchor{16a}@anchor{gnat_ugn/gnat_and_program_execution id17}@anchor{16b}
+@anchor{gnat_ugn/gnat_and_program_execution id17}@anchor{16a}@anchor{gnat_ugn/gnat_and_program_execution non-symbolic-traceback}@anchor{16b}
@subsubsection Non-Symbolic Traceback
@code{stb.adb} at line 5, which was reached from a procedure call in
@code{stb.adb} at line 10, and so on. The @code{b~std.adb} is the binder file,
which contains the call to the main program.
-@ref{10d,,Running gnatbind}. The remaining entries are assorted runtime routines,
+@ref{10e,,Running gnatbind}. The remaining entries are assorted runtime routines,
and the output will vary from platform to platform.
It is also possible to use @code{GDB} with these traceback addresses to debug
You can then get further information by invoking the @code{addr2line}
tool as described earlier (note that the hexadecimal addresses
-need to be specified in C format, with a leading '0x').
+need to be specified in C format, with a leading ‘0x’).
@geindex traceback
@geindex symbolic
@subsection Pretty-Printers for the GNAT runtime
-As discussed in @cite{Calling User-Defined Subprograms}, GDB's
+As discussed in @cite{Calling User-Defined Subprograms}, GDB’s
@code{print} command only knows about the physical layout of program data
structures and therefore normally displays only low-level dumps, which
are often hard to understand.
@end example
@end quotation
-Once this is done, GDB's @code{print} command will automatically use
+Once this is done, GDB’s @code{print} command will automatically use
these pretty-printers when appropriate. Using the previous example:
@quotation
Pretty-printers are invoked each time GDB tries to display a value,
including when displaying the arguments of a called subprogram (in
-GDB's @code{backtrace} command) or when printing the value returned by a
-function (in GDB's @code{finish} command).
+GDB’s @code{backtrace} command) or when printing the value returned by a
+function (in GDB’s @code{finish} command).
To display a value without involving pretty-printers, @code{print} can be
invoked with its @code{/r} option:
@geindex Profiling
@node Profiling,Improving Performance,Running and Debugging Ada Programs,GNAT and Program Execution
-@anchor{gnat_ugn/gnat_and_program_execution profiling}@anchor{147}@anchor{gnat_ugn/gnat_and_program_execution id20}@anchor{170}
+@anchor{gnat_ugn/gnat_and_program_execution id20}@anchor{170}@anchor{gnat_ugn/gnat_and_program_execution profiling}@anchor{147}
@section Profiling
This section is not meant to be an exhaustive documentation of @code{gprof}.
-Full documentation for it can be found in the @cite{GNU Profiler User's Guide}
+Full documentation for it can be found in the @cite{GNU Profiler User’s Guide}
documentation that is part of this GNAT distribution.
Profiling a program helps determine the parts of a program that are executed
@end menu
@node Compilation for profiling,Program execution,,Profiling an Ada Program with gprof
-@anchor{gnat_ugn/gnat_and_program_execution id22}@anchor{173}@anchor{gnat_ugn/gnat_and_program_execution compilation-for-profiling}@anchor{174}
+@anchor{gnat_ugn/gnat_and_program_execution compilation-for-profiling}@anchor{173}@anchor{gnat_ugn/gnat_and_program_execution id22}@anchor{174}
@subsubsection Compilation for profiling
gnatmake switch to force full recompilation.
@node Program execution,Running gprof,Compilation for profiling,Profiling an Ada Program with gprof
-@anchor{gnat_ugn/gnat_and_program_execution program-execution}@anchor{175}@anchor{gnat_ugn/gnat_and_program_execution id23}@anchor{176}
+@anchor{gnat_ugn/gnat_and_program_execution id23}@anchor{175}@anchor{gnat_ugn/gnat_and_program_execution program-execution}@anchor{176}
@subsubsection Program execution
already exists, it will be overwritten.
@node Running gprof,Interpretation of profiling results,Program execution,Profiling an Ada Program with gprof
-@anchor{gnat_ugn/gnat_and_program_execution running-gprof}@anchor{177}@anchor{gnat_ugn/gnat_and_program_execution id24}@anchor{178}
+@anchor{gnat_ugn/gnat_and_program_execution id24}@anchor{177}@anchor{gnat_ugn/gnat_and_program_execution running-gprof}@anchor{178}
@subsubsection Running gprof
@code{gprof} supports numerous switches. The order of these
switch does not matter. The full list of options can be found in
-the GNU Profiler User's Guide documentation that comes with this documentation.
+the GNU Profiler User’s Guide documentation that comes with this documentation.
The following is the subset of those switches that is most relevant:
The @code{-e @emph{function}} option tells @code{gprof} not to print
information about the function @code{function_name} (and its
-children...) in the call graph. The function will still be listed
+children…) in the call graph. The function will still be listed
as a child of any functions that call it, but its index number will be
shown as @code{[not printed]}. More than one @code{-e} option may be
given; only one @code{function_name} may be indicated with each @code{-e}
The @code{-f @emph{function}} option causes @code{gprof} to limit the
call graph to the function @code{function_name} and its children (and
-their children...). More than one @code{-f} option may be given;
+their children…). More than one @code{-f} option may be given;
only one @code{function_name} may be indicated with each @code{-f}
option.
@end table
The @code{-F @emph{function}} option works like the @code{-f} option, but
only time spent in the function and its children (and their
-children...) will be used to determine total-time and
+children…) will be used to determine total-time and
percentages-of-time for the call graph. More than one @code{-F} option
may be given; only one @code{function_name} may be indicated with each
@code{-F} option. The @code{-F} option overrides the @code{-E} option.
The results of the profiling analysis are represented by two arrays: the
-'flat profile' and the 'call graph'. Full documentation of those outputs
-can be found in the GNU Profiler User's Guide.
+‘flat profile’ and the ‘call graph’. Full documentation of those outputs
+can be found in the GNU Profiler User’s Guide.
The flat profile shows the time spent in each function of the program, and how
many time it has been called. This allows you to locate easily the most
spent in each of those callers/called subprograms.
@node Improving Performance,Overflow Check Handling in GNAT,Profiling,GNAT and Program Execution
-@anchor{gnat_ugn/gnat_and_program_execution improving-performance}@anchor{17b}@anchor{gnat_ugn/gnat_and_program_execution id26}@anchor{148}
+@anchor{gnat_ugn/gnat_and_program_execution id26}@anchor{148}@anchor{gnat_ugn/gnat_and_program_execution improving-performance}@anchor{17b}
@section Improving Performance
@end menu
@node Performance Considerations,Text_IO Suggestions,,Improving Performance
-@anchor{gnat_ugn/gnat_and_program_execution performance-considerations}@anchor{17c}@anchor{gnat_ugn/gnat_and_program_execution id27}@anchor{17d}
+@anchor{gnat_ugn/gnat_and_program_execution id27}@anchor{17c}@anchor{gnat_ugn/gnat_and_program_execution performance-considerations}@anchor{17d}
@subsection Performance Considerations
@end menu
@node Controlling Run-Time Checks,Use of Restrictions,,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution id28}@anchor{17e}@anchor{gnat_ugn/gnat_and_program_execution controlling-run-time-checks}@anchor{17f}
+@anchor{gnat_ugn/gnat_and_program_execution controlling-run-time-checks}@anchor{17e}@anchor{gnat_ugn/gnat_and_program_execution id28}@anchor{17f}
@subsubsection Controlling Run-Time Checks
@geindex -O (gcc)
Without any optimization option,
-the compiler's goal is to reduce the cost of
+the compiler’s goal is to reduce the cost of
compilation and to make debugging produce the expected results.
Statements are independent: if you stop the program with a breakpoint between
statements, you can then assign a new value to any variable or change
the fastest compilation time.
Note that many other compilers do substantial optimization even
-if 'no optimization' is specified. With gcc, it is very unusual
+if ‘no optimization’ is specified. With gcc, it is very unusual
to use @code{-O0} for production if execution time is of any concern,
since @code{-O0} means (almost) no optimization. This difference
between gcc and other compilers should be kept in mind when
@itemize *
@item
-@emph{The 'hopping Program Counter':} Repeated @code{step} or @code{next}
+@emph{The ‘hopping Program Counter’:} Repeated @code{step} or @code{next}
commands show
the PC bouncing back and forth in the code. This may result from any of
the following optimizations:
@end itemize
@item
-@emph{The 'big leap':} More commonly known as @emph{cross-jumping}, in which
+@emph{The ‘big leap’:} More commonly known as @emph{cross-jumping}, in which
two identical pieces of code are merged and the program counter suddenly
jumps to a statement that is not supposed to be executed, simply because
it (and the code following) translates to the same thing as the code
a @code{break} in a C @code{switch} statement.
@item
-@emph{The 'roving variable':} The symptom is an unexpected value in a variable.
+@emph{The ‘roving variable’:} The symptom is an unexpected value in a variable.
There are various reasons for this effect:
@item
In a subprogram prologue, a parameter may not yet have been moved to its
-'home'.
+‘home’.
@item
A variable may be dead, and its register re-used. This is
other values); or re-running the code and stopping a little earlier
(perhaps before the call) and stepping to better see how the variable obtained
the value in question; or continuing to step @emph{from} the point of the
-strange value to see if code motion had simply moved the variable's
+strange value to see if code motion had simply moved the variable’s
assignments later.
@end itemize
You also need to make sure that the target architecture features a supported
SIMD instruction set. For example, for the x86 architecture, you should at
-least specify @code{-msse2} to get significant vectorization (but you don't
+least specify @code{-msse2} to get significant vectorization (but you don’t
need to specify it for x86-64 as it is part of the base 64-bit architecture).
Similarly, for the PowerPC architecture, you should specify @code{-maltivec}.
omit the non-vectorized version of the loop as well as the run-time test.
@node Other Optimization Switches,Optimization and Strict Aliasing,Vectorization of loops,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution other-optimization-switches}@anchor{18a}@anchor{gnat_ugn/gnat_and_program_execution id35}@anchor{18b}
+@anchor{gnat_ugn/gnat_and_program_execution id35}@anchor{18a}@anchor{gnat_ugn/gnat_and_program_execution other-optimization-switches}@anchor{18b}
@subsubsection Other Optimization Switches
chapter of @cite{Using the GNU Compiler Collection (GCC)}.
@node Optimization and Strict Aliasing,Aliased Variables and Optimization,Other Optimization Switches,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution optimization-and-strict-aliasing}@anchor{e4}@anchor{gnat_ugn/gnat_and_program_execution id36}@anchor{18c}
+@anchor{gnat_ugn/gnat_and_program_execution id36}@anchor{18c}@anchor{gnat_ugn/gnat_and_program_execution optimization-and-strict-aliasing}@anchor{e4}
@subsubsection Optimization and Strict Aliasing
of type @code{Int1}, and @code{Int2V} can only access objects of type
@code{Int2}, there is no possibility that the assignment to
@code{Int2V.all} affects the value of @code{Int1V.all}. This means that
-the compiler optimizer can "know" that the value @code{Int1V.all} is constant
+the compiler optimizer can “know” that the value @code{Int1V.all} is constant
for all iterations of the loop and avoid the extra memory reference
required to dereference it each time through the loop.
@end quotation
This program prints out 0 in @code{-O0} or @code{-O1}
-mode, but it prints out 1 in @code{-O2} mode. That's
+mode, but it prints out 1 in @code{-O2} mode. That’s
because in strict aliasing mode, the compiler can and
does assume that the assignment to @code{v2.all} could not
affect the value of @code{v1.all}, since different types
the Ada RM specifies that an unchecked conversion where the resulting
bit pattern is not a correct value of the target type can result in an
abnormal value and attempting to reference an abnormal value makes the
-execution of a program erroneous. That's the case here since the result
+execution of a program erroneous. That’s the case here since the result
does not point to an object of type @code{int2}. This means that the
effect is entirely unpredictable.
@end quotation
Unfortunately the problem is recognized when compiling the body of
-package @code{p2}, but the actual "bad" code is generated while
+package @code{p2}, but the actual “bad” code is generated while
compiling the body of @code{m} and this latter compilation does not see
the suspicious @code{Unchecked_Conversion}.
is to compile the entire program with options @code{-O2}
and @code{-fno-strict-aliasing}. If the performance is
satisfactory with this combination of options, then the
-advantage is that the entire issue of possible "wrong"
+advantage is that the entire issue of possible “wrong”
optimization due to strict aliasing is avoided.
To avoid the use of compiler switches, the configuration
this example, we would move the instantiation of
@code{Unchecked_Conversion} from the body of package
@code{p2} to the spec of package @code{p1}. Now the
-warning disappears. That's because any use of the
+warning disappears. That’s because any use of the
access type knows there is a suspicious unchecked
conversion, and the strict aliasing optimization
is automatically suppressed for the type.
this optimization off. If you have code that includes significant
usage of unchecked conversion, you might want to just stick with
@code{-O1} and avoid the entire issue. If you get adequate
-performance at this level of optimization level, that's probably
+performance at this level of optimization level, that’s probably
the safest approach. If tests show that you really need higher
levels of optimization, then you can experiment with @code{-O2}
and @code{-O2 -fno-strict-aliasing} to see how much effect this
particularly if you are getting the warnings described above.
@node Aliased Variables and Optimization,Atomic Variables and Optimization,Optimization and Strict Aliasing,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution id37}@anchor{18d}@anchor{gnat_ugn/gnat_and_program_execution aliased-variables-and-optimization}@anchor{18e}
+@anchor{gnat_ugn/gnat_and_program_execution aliased-variables-and-optimization}@anchor{18d}@anchor{gnat_ugn/gnat_and_program_execution id37}@anchor{18e}
@subsubsection Aliased Variables and Optimization
that otherwise might be considered to be unassigned. For example,
a variable can be passed to a procedure by reference, which takes
the address of the parameter and uses the address to modify the
-variable's value, even though it is passed as an IN parameter.
+variable’s value, even though it is passed as an IN parameter.
Consider the following example:
@quotation
levels of optimzization.
What the compiler does for such cases is to assume that marking
-a variable as aliased indicates that some "funny business" may
+a variable as aliased indicates that some “funny business” may
be going on. The optimizer recognizes the aliased keyword and
inhibits optimizations that assume the value cannot be assigned.
-This means that the above example will in fact "work" reliably,
+This means that the above example will in fact “work” reliably,
that is, it will produce the expected results.
@node Atomic Variables and Optimization,Passive Task Optimization,Aliased Variables and Optimization,Performance Considerations
Actually one can imagine some compiler which figures
out that the whole copy is not required (because only
the B field is actually accessed), but GNAT
-certainly won't do that, and we don't know of any
+certainly won’t do that, and we don’t know of any
compiler that would not handle this right, and the
above code will in practice work portably across
all architectures (that permit the Atomic declaration).
useful to disable it.
@node Passive Task Optimization,,Atomic Variables and Optimization,Performance Considerations
-@anchor{gnat_ugn/gnat_and_program_execution passive-task-optimization}@anchor{191}@anchor{gnat_ugn/gnat_and_program_execution id39}@anchor{192}
+@anchor{gnat_ugn/gnat_and_program_execution id39}@anchor{191}@anchor{gnat_ugn/gnat_and_program_execution passive-task-optimization}@anchor{192}
@subsubsection Passive Task Optimization
performance is fully portable.
Although it would theoretically be possible for GNAT to attempt to
-do this optimization, but it really doesn't make sense in the
+do this optimization, but it really doesn’t make sense in the
context of Ada 95, and none of the Ada 95 compilers implement
this optimization as far as we know. In particular GNAT never
attempts to perform this optimization.
to be modified, only the task definition itself.
@node Text_IO Suggestions,Reducing Size of Executables with Unused Subprogram/Data Elimination,Performance Considerations,Improving Performance
-@anchor{gnat_ugn/gnat_and_program_execution text-io-suggestions}@anchor{193}@anchor{gnat_ugn/gnat_and_program_execution id40}@anchor{194}
+@anchor{gnat_ugn/gnat_and_program_execution id40}@anchor{193}@anchor{gnat_ugn/gnat_and_program_execution text-io-suggestions}@anchor{194}
@subsection @code{Text_IO} Suggestions
@end menu
@node About unused subprogram/data elimination,Compilation options,,Reducing Size of Executables with Unused Subprogram/Data Elimination
-@anchor{gnat_ugn/gnat_and_program_execution id42}@anchor{197}@anchor{gnat_ugn/gnat_and_program_execution about-unused-subprogram-data-elimination}@anchor{198}
+@anchor{gnat_ugn/gnat_and_program_execution about-unused-subprogram-data-elimination}@anchor{197}@anchor{gnat_ugn/gnat_and_program_execution id42}@anchor{198}
@subsubsection About unused subprogram/data elimination
In both cases GNU binutils version 2.16 or later are required to enable it.
@node Compilation options,Example of unused subprogram/data elimination,About unused subprogram/data elimination,Reducing Size of Executables with Unused Subprogram/Data Elimination
-@anchor{gnat_ugn/gnat_and_program_execution id43}@anchor{199}@anchor{gnat_ugn/gnat_and_program_execution compilation-options}@anchor{19a}
+@anchor{gnat_ugn/gnat_and_program_execution compilation-options}@anchor{199}@anchor{gnat_ugn/gnat_and_program_execution id43}@anchor{19a}
@subsubsection Compilation options
@end menu
@node Background,Management of Overflows in GNAT,,Overflow Check Handling in GNAT
-@anchor{gnat_ugn/gnat_and_program_execution id46}@anchor{19e}@anchor{gnat_ugn/gnat_and_program_execution background}@anchor{19f}
+@anchor{gnat_ugn/gnat_and_program_execution background}@anchor{19e}@anchor{gnat_ugn/gnat_and_program_execution id46}@anchor{19f}
@subsection Background
performed on the intermediate result and an unexpected exception is
raised.
-Furthermore, when using Ada 2012's preconditions and other
+Furthermore, when using Ada 2012’s preconditions and other
assertion forms, another issue arises. Consider:
@quotation
assertions, GNAT provides comprehensive control over the handling
of intermediate overflow. GNAT can operate in three modes, and
furthemore, permits separate selection of operating modes for
-the expressions within assertions (here the term 'assertions'
+the expressions within assertions (here the term ‘assertions’
is used in the technical sense, which includes preconditions and so forth)
and for expressions appearing outside assertions.
range checks).
@node Specifying the Desired Mode,Default Settings,Management of Overflows in GNAT,Overflow Check Handling in GNAT
-@anchor{gnat_ugn/gnat_and_program_execution specifying-the-desired-mode}@anchor{e9}@anchor{gnat_ugn/gnat_and_program_execution id48}@anchor{1a2}
+@anchor{gnat_ugn/gnat_and_program_execution id48}@anchor{1a2}@anchor{gnat_ugn/gnat_and_program_execution specifying-the-desired-mode}@anchor{e9}
@subsection Specifying the Desired Mode
@end quotation
specifies that general expressions outside assertions be evaluated
-in 'minimize intermediate overflows' mode, and expressions within
-assertions be evaluated in 'eliminate intermediate overflows' mode.
+in ‘minimize intermediate overflows’ mode, and expressions within
+assertions be evaluated in ‘eliminate intermediate overflows’ mode.
This is often a reasonable choice, avoiding excessive overhead
outside assertions, but assuring a high degree of portability
when importing code from another compiler, while incurring
type (@code{STRICT} mode).
@node Default Settings,Implementation Notes,Specifying the Desired Mode,Overflow Check Handling in GNAT
-@anchor{gnat_ugn/gnat_and_program_execution id49}@anchor{1a3}@anchor{gnat_ugn/gnat_and_program_execution default-settings}@anchor{1a4}
+@anchor{gnat_ugn/gnat_and_program_execution default-settings}@anchor{1a3}@anchor{gnat_ugn/gnat_and_program_execution id49}@anchor{1a4}
@subsection Default Settings
intermediate results.
@node Implementation Notes,,Default Settings,Overflow Check Handling in GNAT
-@anchor{gnat_ugn/gnat_and_program_execution implementation-notes}@anchor{1a5}@anchor{gnat_ugn/gnat_and_program_execution id50}@anchor{1a6}
+@anchor{gnat_ugn/gnat_and_program_execution id50}@anchor{1a5}@anchor{gnat_ugn/gnat_and_program_execution implementation-notes}@anchor{1a6}
@subsection Implementation Notes
platforms).
@node Performing Dimensionality Analysis in GNAT,Stack Related Facilities,Overflow Check Handling in GNAT,GNAT and Program Execution
-@anchor{gnat_ugn/gnat_and_program_execution performing-dimensionality-analysis-in-gnat}@anchor{1a7}@anchor{gnat_ugn/gnat_and_program_execution id51}@anchor{14a}
+@anchor{gnat_ugn/gnat_and_program_execution id51}@anchor{14a}@anchor{gnat_ugn/gnat_and_program_execution performing-dimensionality-analysis-in-gnat}@anchor{1a7}
@section Performing Dimensionality Analysis in GNAT
@end quotation
The @code{Dimension} aspect of a dimensioned subtype @code{S} defines a mapping
-from the base type's Unit_Names to integer (or, more generally, rational)
+from the base type’s Unit_Names to integer (or, more generally, rational)
values. This mapping is the @emph{dimension vector} (also referred to as the
@emph{dimensionality}) for that subtype, denoted by @code{DV(S)}, and thus for each
object of that subtype. Intuitively, the value specified for each
@code{DV(@emph{op expr})}, where @emph{op} is a unary operator, is @code{DV(@emph{expr})}
@item
-@code{DV(@emph{expr1 op expr2})} where @emph{op} is "+" or "-" is @code{DV(@emph{expr1})}
+@code{DV(@emph{expr1 op expr2})} where @emph{op} is “+” or “-” is @code{DV(@emph{expr1})}
provided that @code{DV(@emph{expr1})} = @code{DV(@emph{expr2})}.
If this condition is not met then the construct is illegal.
met then the construct is illegal.
@end itemize
-Note that, by the above rules, it is illegal to use binary "+" or "-" to
+Note that, by the above rules, it is illegal to use binary “+” or “-” to
combine a dimensioned and dimensionless value. Thus an expression such as
@code{acc-10.0} is illegal, where @code{acc} is an object of subtype
@code{Acceleration}.
The dimensionality checks for relationals use the same rules as
-for "+" and "-", except when comparing to a literal; thus
+for “+” and “-“, except when comparing to a literal; thus
@quotation
If @code{T} is the base type for @emph{expr} (and the dimensionless root type of
the dimension system), then @code{DV(T(@emph{expr}))} is @code{DV(expr)}.
Thus, if @emph{expr} is of a dimensioned subtype of @code{T}, the conversion may
-be regarded as a "view conversion" that preserves dimensionality.
+be regarded as a “view conversion” that preserves dimensionality.
This rule makes it possible to write generic code that can be instantiated
with compatible dimensioned subtypes. The generic unit will contain
dimension vector for the formal parameter).
@node Stack Related Facilities,Memory Management Issues,Performing Dimensionality Analysis in GNAT,GNAT and Program Execution
-@anchor{gnat_ugn/gnat_and_program_execution stack-related-facilities}@anchor{1a8}@anchor{gnat_ugn/gnat_and_program_execution id52}@anchor{14b}
+@anchor{gnat_ugn/gnat_and_program_execution id52}@anchor{14b}@anchor{gnat_ugn/gnat_and_program_execution stack-related-facilities}@anchor{1a8}
@section Stack Related Facilities
behavior will occur. Most native systems offer some level of protection by
adding a guard page at the end of each task stack. This mechanism is usually
not enough for dealing properly with stack overflow situations because
-a large local variable could "jump" above the guard page.
+a large local variable could “jump” above the guard page.
Furthermore, when the
guard page is hit, there may not be any space left on the stack for executing
the exception propagation code. Enabling stack checking avoids
bytes. The wording is in keeping with the qualifier documented above.
@node Dynamic Stack Usage Analysis,,Static Stack Usage Analysis,Stack Related Facilities
-@anchor{gnat_ugn/gnat_and_program_execution id55}@anchor{1ab}@anchor{gnat_ugn/gnat_and_program_execution dynamic-stack-usage-analysis}@anchor{113}
+@anchor{gnat_ugn/gnat_and_program_execution dynamic-stack-usage-analysis}@anchor{113}@anchor{gnat_ugn/gnat_and_program_execution id55}@anchor{1ab}
@subsection Dynamic Stack Usage Analysis
@item
@emph{Stack Usage} is the measure done by the stack analyzer.
In order to prevent overflow, the stack
-is not entirely analyzed, and it's not possible to know exactly how
+is not entirely analyzed, and it’s not possible to know exactly how
much has actually been used.
@end itemize
This section describes some useful memory pools provided in the GNAT library
and in particular the GNAT Debug Pool facility, which can be used to detect
-incorrect uses of access values (including 'dangling references').
+incorrect uses of access values (including ‘dangling references’).
@menu
@c -- E.g. Ada |nbsp| 95
@node Platform-Specific Information,Example of Binder Output File,GNAT and Program Execution,Top
-@anchor{gnat_ugn/platform_specific_information platform-specific-information}@anchor{d}@anchor{gnat_ugn/platform_specific_information doc}@anchor{1b1}@anchor{gnat_ugn/platform_specific_information id1}@anchor{1b2}
+@anchor{gnat_ugn/platform_specific_information doc}@anchor{1b1}@anchor{gnat_ugn/platform_specific_information id1}@anchor{1b2}@anchor{gnat_ugn/platform_specific_information platform-specific-information}@anchor{d}
@chapter Platform-Specific Information
@itemize *
@item
-@strong{Zero-Cost Exceptions} ("ZCX"),
+@strong{Zero-Cost Exceptions} (“ZCX”),
which uses binder-generated tables that
are interrogated at run time to locate a handler.
@geindex SJLJ (setjmp/longjmp Exception Model)
@item
-@strong{setjmp / longjmp} ('SJLJ'),
+@strong{setjmp / longjmp} (‘SJLJ’),
which uses dynamically-set data to establish
the set of handlers
@end itemize
@end menu
@node Summary of Run-Time Configurations,,,Run-Time Libraries
-@anchor{gnat_ugn/platform_specific_information summary-of-run-time-configurations}@anchor{1b5}@anchor{gnat_ugn/platform_specific_information id3}@anchor{1b6}
+@anchor{gnat_ugn/platform_specific_information id3}@anchor{1b5}@anchor{gnat_ugn/platform_specific_information summary-of-run-time-configurations}@anchor{1b6}
@subsection Summary of Run-Time Configurations
@node Specifying a Run-Time Library,GNU/Linux Topics,Run-Time Libraries,Platform-Specific Information
-@anchor{gnat_ugn/platform_specific_information specifying-a-run-time-library}@anchor{1b7}@anchor{gnat_ugn/platform_specific_information id4}@anchor{1b8}
+@anchor{gnat_ugn/platform_specific_information id4}@anchor{1b7}@anchor{gnat_ugn/platform_specific_information specifying-a-run-time-library}@anchor{1b8}
@section Specifying a Run-Time Library
@end example
@end quotation
-It gets the effective user id, and if it's not 0 (i.e. root), it raises
+It gets the effective user id, and if it’s not 0 (i.e. root), it raises
Program_Error.
@geindex Linux
@geindex GNU/Linux
@node GNU/Linux Topics,Microsoft Windows Topics,Specifying a Run-Time Library,Platform-Specific Information
-@anchor{gnat_ugn/platform_specific_information id6}@anchor{1bb}@anchor{gnat_ugn/platform_specific_information gnu-linux-topics}@anchor{1bc}
+@anchor{gnat_ugn/platform_specific_information gnu-linux-topics}@anchor{1bb}@anchor{gnat_ugn/platform_specific_information id6}@anchor{1bc}
@section GNU/Linux Topics
@subsection Required Packages on GNU/Linux
-GNAT requires the C library developer's package to be installed.
+GNAT requires the C library developer’s package to be installed.
The name of of that package depends on your GNU/Linux distribution:
@end itemize
If using the 32-bit version of GNAT on a 64-bit version of GNU/Linux,
-you'll need the 32-bit version of the following packages:
+you’ll need the 32-bit version of the following packages:
@itemize *
@geindex Windows
@node Microsoft Windows Topics,Mac OS Topics,GNU/Linux Topics,Platform-Specific Information
-@anchor{gnat_ugn/platform_specific_information microsoft-windows-topics}@anchor{1bf}@anchor{gnat_ugn/platform_specific_information id8}@anchor{1c0}
+@anchor{gnat_ugn/platform_specific_information id8}@anchor{1bf}@anchor{gnat_ugn/platform_specific_information microsoft-windows-topics}@anchor{1c0}
@section Microsoft Windows Topics
@end menu
@node Using GNAT on Windows,Using a network installation of GNAT,,Microsoft Windows Topics
-@anchor{gnat_ugn/platform_specific_information using-gnat-on-windows}@anchor{1c1}@anchor{gnat_ugn/platform_specific_information id9}@anchor{1c2}
+@anchor{gnat_ugn/platform_specific_information id9}@anchor{1c1}@anchor{gnat_ugn/platform_specific_information using-gnat-on-windows}@anchor{1c2}
@subsection Using GNAT on Windows
@item
It is possible to link against Microsoft C libraries. Yet the preferred
solution is to use C/C++ compiler that comes with GNAT, since it
-doesn't require having two different development environments and makes the
+doesn’t require having two different development environments and makes the
inter-language debugging experience smoother.
@item
serious performance penalty.
@node CONSOLE and WINDOWS subsystems,Temporary Files,Using a network installation of GNAT,Microsoft Windows Topics
-@anchor{gnat_ugn/platform_specific_information id11}@anchor{1c5}@anchor{gnat_ugn/platform_specific_information console-and-windows-subsystems}@anchor{1c6}
+@anchor{gnat_ugn/platform_specific_information console-and-windows-subsystems}@anchor{1c5}@anchor{gnat_ugn/platform_specific_information id11}@anchor{1c6}
@subsection CONSOLE and WINDOWS subsystems
@end menu
@node Windows Calling Conventions,Introduction to Dynamic Link Libraries DLLs,,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information windows-calling-conventions}@anchor{1cf}@anchor{gnat_ugn/platform_specific_information id14}@anchor{1d0}
+@anchor{gnat_ugn/platform_specific_information id14}@anchor{1cf}@anchor{gnat_ugn/platform_specific_information windows-calling-conventions}@anchor{1d0}
@subsubsection Windows Calling Conventions
platform.
When a subprogram @code{F} (caller) calls a subprogram @code{G}
-(callee), there are several ways to push @code{G}'s parameters on the
+(callee), there are several ways to push @code{G}’s parameters on the
stack and there are several possible scenarios to clean up the stack
-upon @code{G}'s return. A calling convention is an agreed upon software
+upon @code{G}’s return. A calling convention is an agreed upon software
protocol whereby the responsibilities between the caller (@code{F}) and
the callee (@code{G}) are clearly defined. Several calling conventions
are available for Windows:
convention, @ref{1d3,,Stdcall Calling Convention}).
@node Stdcall Calling Convention,Win32 Calling Convention,C Calling Convention,Windows Calling Conventions
-@anchor{gnat_ugn/platform_specific_information stdcall-calling-convention}@anchor{1d3}@anchor{gnat_ugn/platform_specific_information id16}@anchor{1d4}
+@anchor{gnat_ugn/platform_specific_information id16}@anchor{1d4}@anchor{gnat_ugn/platform_specific_information stdcall-calling-convention}@anchor{1d3}
@subsubsection @code{Stdcall} Calling Convention
decoration at all. No leading underscore and no Stdcall suffix
@code{@@@emph{nn}}.
-This is especially important as in some special cases a DLL's entry
+This is especially important as in some special cases a DLL’s entry
point name lacks a trailing @code{@@@emph{nn}} while the exported
name generated for a call has it.
will be handled as a @code{C} calling convention on non-Windows platforms.
@node Win32 Calling Convention,DLL Calling Convention,Stdcall Calling Convention,Windows Calling Conventions
-@anchor{gnat_ugn/platform_specific_information win32-calling-convention}@anchor{1d5}@anchor{gnat_ugn/platform_specific_information id17}@anchor{1d6}
+@anchor{gnat_ugn/platform_specific_information id17}@anchor{1d5}@anchor{gnat_ugn/platform_specific_information win32-calling-convention}@anchor{1d6}
@subsubsection @code{Win32} Calling Convention
@code{Stdcall} calling convention described above.
@node DLL Calling Convention,,Win32 Calling Convention,Windows Calling Conventions
-@anchor{gnat_ugn/platform_specific_information id18}@anchor{1d7}@anchor{gnat_ugn/platform_specific_information dll-calling-convention}@anchor{1d8}
+@anchor{gnat_ugn/platform_specific_information dll-calling-convention}@anchor{1d7}@anchor{gnat_ugn/platform_specific_information id18}@anchor{1d8}
@subsubsection @code{DLL} Calling Convention
incorrectly. Hence, when possible, it is always preferable to use and
build relocatable DLLs. Both relocatable and non-relocatable DLLs are
supported by GNAT. Note that the @code{-s} linker option (see GNU Linker
-User's Guide) removes the debugging symbols from the DLL but the DLL can
+User’s Guide) removes the debugging symbols from the DLL but the DLL can
still be relocated.
As a side note, an interesting difference between Microsoft DLLs and
The import library (@code{libAPI.dll.a} or @code{API.lib}). As previously
mentioned an import library is a statically linked library containing the
import table which will be filled at load time to point to the actual
-@code{API.dll} routines. Sometimes you don't have an import library for the
+@code{API.dll} routines. Sometimes you don’t have an import library for the
DLL you want to use. The following sections will explain how to build
one. Note that this is optional.
@end menu
@node Creating an Ada Spec for the DLL Services,Creating an Import Library,,Using DLLs with GNAT
-@anchor{gnat_ugn/platform_specific_information id21}@anchor{1dd}@anchor{gnat_ugn/platform_specific_information creating-an-ada-spec-for-the-dll-services}@anchor{1de}
+@anchor{gnat_ugn/platform_specific_information creating-an-ada-spec-for-the-dll-services}@anchor{1dd}@anchor{gnat_ugn/platform_specific_information id21}@anchor{1de}
@subsubsection Creating an Ada Spec for the DLL Services
@end quotation
@node Creating an Import Library,,Creating an Ada Spec for the DLL Services,Using DLLs with GNAT
-@anchor{gnat_ugn/platform_specific_information id22}@anchor{1df}@anchor{gnat_ugn/platform_specific_information creating-an-import-library}@anchor{1e0}
+@anchor{gnat_ugn/platform_specific_information creating-an-import-library}@anchor{1df}@anchor{gnat_ugn/platform_specific_information id22}@anchor{1e0}
@subsubsection Creating an Import Library
@end table
Note that you must specify the correct suffix (@code{@@@emph{nn}})
-(see @ref{1cf,,Windows Calling Conventions}) for a Stdcall
+(see @ref{1d0,,Windows Calling Conventions}) for a Stdcall
calling convention function in the exported symbols list.
There can actually be other sections in a definition file, but these
@end example
Note that if some routines in the DLL have the @code{Stdcall} convention
-(@ref{1cf,,Windows Calling Conventions}) with stripped @code{@@@emph{nn}}
-suffix then you'll have to edit @code{api.def} to add it, and specify
+(@ref{1d0,,Windows Calling Conventions}) with stripped @code{@@@emph{nn}}
+suffix then you’ll have to edit @code{api.def} to add it, and specify
@code{-k} to @code{gnatdll} when creating the import library.
Here are some hints to find the right @code{@@@emph{nn}} suffix.
To create a Microsoft-style import library for @code{API.dll} you
should create the .def file, then build the actual import library using
-Microsoft's @code{lib} utility:
+Microsoft’s @code{lib} utility:
@quotation
@end quotation
@node Building DLLs with GNAT Project files,Building DLLs with GNAT,Using DLLs with GNAT,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information id23}@anchor{1e5}@anchor{gnat_ugn/platform_specific_information building-dlls-with-gnat-project-files}@anchor{1ce}
+@anchor{gnat_ugn/platform_specific_information building-dlls-with-gnat-project-files}@anchor{1ce}@anchor{gnat_ugn/platform_specific_information id23}@anchor{1e5}
@subsubsection Building DLLs with GNAT Project files
There is nothing specific to Windows in the build process.
See the @emph{Library Projects} section in the @emph{GNAT Project Manager}
-chapter of the @emph{GPRbuild User's Guide}.
+chapter of the @emph{GPRbuild User’s Guide}.
Due to a system limitation, it is not possible under Windows to create threads
when inside the @code{DllMain} routine which is used for auto-initialization
If you use a definition file you must export the elaboration procedures
for every package that required one. Elaboration procedures are named
-using the package name followed by "_E".
+using the package name followed by “_E”.
@item
Preparing DLL to be used.
debug information pass @code{-largs -s} to @code{gnatdll}. This
restriction does not apply to a DLL built using a Library Project.
See the @emph{Library Projects} section in the @emph{GNAT Project Manager}
-chapter of the @emph{GPRbuild User's Guide}.
+chapter of the @emph{GPRbuild User’s Guide}.
@c Limitations_When_Using_Ada_DLLs_from Ada:
initialization routine. Unfortunately, it is not possible to call
@code{adainit} from the @code{DllMain} if your program has library level
tasks because access to the @code{DllMain} entry point is serialized by
-the system (that is, only a single thread can execute 'through' it at a
+the system (that is, only a single thread can execute ‘through’ it at a
time), which means that the GNAT run-time will deadlock waiting for the
newly created task to complete its initialization.
@node Ada DLLs and Finalization,Creating a Spec for Ada DLLs,Building DLLs with gnatdll,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information id28}@anchor{1f1}@anchor{gnat_ugn/platform_specific_information ada-dlls-and-finalization}@anchor{1ec}
+@anchor{gnat_ugn/platform_specific_information ada-dlls-and-finalization}@anchor{1ec}@anchor{gnat_ugn/platform_specific_information id28}@anchor{1f1}
@subsubsection Ada DLLs and Finalization
(@ref{1e3,,Using gnatdll}).
@node Creating a Spec for Ada DLLs,GNAT and Windows Resources,Ada DLLs and Finalization,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information id29}@anchor{1f2}@anchor{gnat_ugn/platform_specific_information creating-a-spec-for-ada-dlls}@anchor{1f3}
+@anchor{gnat_ugn/platform_specific_information creating-a-spec-for-ada-dlls}@anchor{1f2}@anchor{gnat_ugn/platform_specific_information id29}@anchor{1f3}
@subsubsection Creating a Spec for Ada DLLs
@end quotation
@node Using gnatdll,,Creating the Definition File,Creating a Spec for Ada DLLs
-@anchor{gnat_ugn/platform_specific_information using-gnatdll}@anchor{1e3}@anchor{gnat_ugn/platform_specific_information id31}@anchor{1f5}
+@anchor{gnat_ugn/platform_specific_information id31}@anchor{1f5}@anchor{gnat_ugn/platform_specific_information using-gnatdll}@anchor{1e3}
@subsubsection Using @code{gnatdll}
@item @code{-k}
-Removes the @code{@@@emph{nn}} suffix from the import library's exported
+Removes the @code{@@@emph{nn}} suffix from the import library’s exported
names, but keeps them for the link names. You must specify this
option if you want to use a @code{Stdcall} function in a DLL for which
the @code{@@@emph{nn}} suffix has been removed. This is the case for most
@item @code{-k}
Kill @code{@@@emph{nn}} from exported names
-(@ref{1cf,,Windows Calling Conventions}
+(@ref{1d0,,Windows Calling Conventions}
for a discussion about @code{Stdcall}-style symbols.
@end table
@end quotation
@node Using Resources,,Compiling Resources,GNAT and Windows Resources
-@anchor{gnat_ugn/platform_specific_information using-resources}@anchor{1fd}@anchor{gnat_ugn/platform_specific_information id35}@anchor{1fe}
+@anchor{gnat_ugn/platform_specific_information id35}@anchor{1fd}@anchor{gnat_ugn/platform_specific_information using-resources}@anchor{1fe}
@subsubsection Using Resources
@item
First develop and build the GNAT shared library using a library project
-(let's assume the project is @code{mylib.gpr}, producing the library @code{libmylib.dll}):
+(let’s assume the project is @code{mylib.gpr}, producing the library @code{libmylib.dll}):
@end enumerate
@quotation
@end example
@end quotation
-If you are using a 64-bit toolchain, the above becomes...
+If you are using a 64-bit toolchain, the above becomes…
@quotation
@end enumerate
@node Debugging a DLL,Setting Stack Size from gnatlink,Using GNAT DLLs from Microsoft Visual Studio Applications,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information id36}@anchor{201}@anchor{gnat_ugn/platform_specific_information debugging-a-dll}@anchor{202}
+@anchor{gnat_ugn/platform_specific_information debugging-a-dll}@anchor{201}@anchor{gnat_ugn/platform_specific_information id36}@anchor{202}
@subsubsection Debugging a DLL
This is the simplest case. Both the DLL and the program have @code{GDB}
compatible debugging information. It is then possible to break anywhere in
-the process. Let's suppose here that the main procedure is named
+the process. Let’s suppose here that the main procedure is named
@code{ada_main} and that in the DLL there is an entry point named
@code{ada_dll}.
(@ref{14d,,Running and Debugging Ada Programs}).
@node Program Built with Foreign Tools and DLL Built with GCC/GNAT,,Program and DLL Both Built with GCC/GNAT,Debugging a DLL
-@anchor{gnat_ugn/platform_specific_information program-built-with-foreign-tools-and-dll-built-with-gcc-gnat}@anchor{205}@anchor{gnat_ugn/platform_specific_information id38}@anchor{206}
+@anchor{gnat_ugn/platform_specific_information id38}@anchor{205}@anchor{gnat_ugn/platform_specific_information program-built-with-foreign-tools-and-dll-built-with-gcc-gnat}@anchor{206}
@subsubsection Program Built with Foreign Tools and DLL Built with GCC/GNAT
@end example
@item
-Use the Windows @emph{Task Manager} to find the process ID. Let's say
+Use the Windows @emph{Task Manager} to find the process ID. Let’s say
that the process PID for @code{main.exe} is 208.
@item
@ref{14d,,Running and Debugging Ada Programs}.
@node Setting Stack Size from gnatlink,Setting Heap Size from gnatlink,Debugging a DLL,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information setting-stack-size-from-gnatlink}@anchor{127}@anchor{gnat_ugn/platform_specific_information id39}@anchor{207}
+@anchor{gnat_ugn/platform_specific_information id39}@anchor{207}@anchor{gnat_ugn/platform_specific_information setting-stack-size-from-gnatlink}@anchor{127}
@subsubsection Setting Stack Size from @code{gnatlink}
@end itemize
@node Setting Heap Size from gnatlink,,Setting Stack Size from gnatlink,Mixed-Language Programming on Windows
-@anchor{gnat_ugn/platform_specific_information setting-heap-size-from-gnatlink}@anchor{128}@anchor{gnat_ugn/platform_specific_information id40}@anchor{208}
+@anchor{gnat_ugn/platform_specific_information id40}@anchor{208}@anchor{gnat_ugn/platform_specific_information setting-heap-size-from-gnatlink}@anchor{128}
@subsubsection Setting Heap Size from @code{gnatlink}
@end itemize
@node Windows Specific Add-Ons,,Mixed-Language Programming on Windows,Microsoft Windows Topics
-@anchor{gnat_ugn/platform_specific_information windows-specific-add-ons}@anchor{209}@anchor{gnat_ugn/platform_specific_information win32-specific-addons}@anchor{20a}
+@anchor{gnat_ugn/platform_specific_information win32-specific-addons}@anchor{209}@anchor{gnat_ugn/platform_specific_information windows-specific-add-ons}@anchor{20a}
@subsection Windows Specific Add-Ons
@end menu
@node Win32Ada,wPOSIX,,Windows Specific Add-Ons
-@anchor{gnat_ugn/platform_specific_information win32ada}@anchor{20b}@anchor{gnat_ugn/platform_specific_information id41}@anchor{20c}
+@anchor{gnat_ugn/platform_specific_information id41}@anchor{20b}@anchor{gnat_ugn/platform_specific_information win32ada}@anchor{20c}
@subsubsection Win32Ada
@end quotation
To build the application you just need to call gprbuild for the
-application's project, here p.gpr:
+application’s project, here p.gpr:
@quotation
@end quotation
To build the application you just need to call gprbuild for the
-application's project, here p.gpr:
+application’s project, here p.gpr:
@quotation
@end quotation
@node Mac OS Topics,,Microsoft Windows Topics,Platform-Specific Information
-@anchor{gnat_ugn/platform_specific_information mac-os-topics}@anchor{20f}@anchor{gnat_ugn/platform_specific_information id43}@anchor{210}
+@anchor{gnat_ugn/platform_specific_information id43}@anchor{20f}@anchor{gnat_ugn/platform_specific_information mac-os-topics}@anchor{210}
@section Mac OS Topics
@geindex OS X
-This section describes topics that are specific to Apple's OS X
+This section describes topics that are specific to Apple’s OS X
platform.
@menu
@item
Select the Keychain Access -> Certificate Assistant ->
-Create a Certificate... menu
+Create a Certificate… menu
@item
Then:
@item
Choose a name for the new certificate (this procedure will use
-"gdb-cert" as an example)
+“gdb-cert” as an example)
@item
-Set "Identity Type" to "Self Signed Root"
+Set “Identity Type” to “Self Signed Root”
@item
-Set "Certificate Type" to "Code Signing"
+Set “Certificate Type” to “Code Signing”
@item
-Activate the "Let me override defaults" option
+Activate the “Let me override defaults” option
@end itemize
@item
-Click several times on "Continue" until the "Specify a Location
-For The Certificate" screen appears, then set "Keychain" to "System"
+Click several times on “Continue” until the “Specify a Location
+For The Certificate” screen appears, then set “Keychain” to “System”
@item
-Click on "Continue" until the certificate is created
+Click on “Continue” until the certificate is created
@item
Finally, in the view, double-click on the new certificate,
-and set "When using this certificate" to "Always Trust"
+and set “When using this certificate” to “Always Trust”
@item
Exit the Keychain Access application and restart the computer
@end example
@end quotation
-where "gdb-cert" should be replaced by the actual certificate
+where “gdb-cert” should be replaced by the actual certificate
name chosen above, and <gnat_install_prefix> should be replaced by
the location where you installed GNAT. Also, be sure that users are
in the Unix group @code{_developer}.
@node Example of Binder Output File,Elaboration Order Handling in GNAT,Platform-Specific Information,Top
-@anchor{gnat_ugn/example_of_binder_output example-of-binder-output-file}@anchor{e}@anchor{gnat_ugn/example_of_binder_output doc}@anchor{212}@anchor{gnat_ugn/example_of_binder_output id1}@anchor{213}
+@anchor{gnat_ugn/example_of_binder_output doc}@anchor{212}@anchor{gnat_ugn/example_of_binder_output example-of-binder-output-file}@anchor{e}@anchor{gnat_ugn/example_of_binder_output id1}@anchor{213}
@chapter Example of Binder Output File
@geindex Binder output (example)
This Appendix displays the source code for the output file
-generated by @emph{gnatbind} for a simple 'Hello World' program.
+generated by @emph{gnatbind} for a simple ‘Hello World’ program.
Comments have been added for clarification purposes.
@example
@c -- Example: A |withing| unit has a |with| clause, it |withs| a |withed| unit
@node Elaboration Order Handling in GNAT,Inline Assembler,Example of Binder Output File,Top
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-order-handling-in-gnat}@anchor{f}@anchor{gnat_ugn/elaboration_order_handling_in_gnat doc}@anchor{214}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id1}@anchor{215}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat doc}@anchor{214}@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-order-handling-in-gnat}@anchor{f}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id1}@anchor{215}
@chapter Elaboration Order Handling in GNAT
@end example
@end quotation
-The elaboration of @code{Server}'s spec materializes function @code{Func}, making it
-callable. The elaboration of @code{Client}'s spec elaborates the declaration of
+The elaboration of @code{Server}’s spec materializes function @code{Func}, making it
+callable. The elaboration of @code{Client}’s spec elaborates the declaration of
@code{Val}. This invokes function @code{Server.Func}, however the body of
-@code{Server.Func} has not been elaborated yet because @code{Server}'s body comes
-after @code{Client}'s spec in the elaboration order. As a result, the value of
+@code{Server.Func} has not been elaborated yet because @code{Server}’s body comes
+after @code{Client}’s spec in the elaboration order. As a result, the value of
constant @code{Val} is now undefined.
Without any guarantees from the language, an undetected ABE problem may hinder
respect to control and data flow.
@node Checking the Elaboration Order,Controlling the Elaboration Order in Ada,Elaboration Order,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat id4}@anchor{21a}@anchor{gnat_ugn/elaboration_order_handling_in_gnat checking-the-elaboration-order}@anchor{21b}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat checking-the-elaboration-order}@anchor{21a}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id4}@anchor{21b}
@section Checking the Elaboration Order
Pragma @code{Elaborate_Body} requires that the body of a unit is elaborated
immediately after its spec. This restriction guarantees that no client
scenario can invoke a server target before the target body has been
-elaborated because the spec and body are effectively "glued" together.
+elaborated because the spec and body are effectively “glued” together.
@example
package Server is
orders exist) even if maintenance changes the bodies of targets.
@node Controlling the Elaboration Order in GNAT,Mixing Elaboration Models,Controlling the Elaboration Order in Ada,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat id6}@anchor{21e}@anchor{gnat_ugn/elaboration_order_handling_in_gnat controlling-the-elaboration-order-in-gnat}@anchor{21f}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat controlling-the-elaboration-order-in-gnat}@anchor{21e}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id6}@anchor{21f}
@section Controlling the Elaboration Order in GNAT
may not diagnose certain elaboration issues or install run-time checks.
@node Mixing Elaboration Models,ABE Diagnostics,Controlling the Elaboration Order in GNAT,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat mixing-elaboration-models}@anchor{220}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id7}@anchor{221}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat id7}@anchor{220}@anchor{gnat_ugn/elaboration_order_handling_in_gnat mixing-elaboration-models}@anchor{221}
@section Mixing Elaboration Models
@end example
@end quotation
-In the example above, the elaboration of @code{Guaranteed_ABE}'s body elaborates
+In the example above, the elaboration of @code{Guaranteed_ABE}’s body elaborates
the declaration of @code{Val}. This invokes function @code{ABE}, however the body of
@code{ABE} has not been elaborated yet. GNAT emits the following diagnostic:
elaborated at that point.
@node SPARK Diagnostics,Elaboration Circularities,ABE Diagnostics,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat spark-diagnostics}@anchor{224}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id9}@anchor{225}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat id9}@anchor{224}@anchor{gnat_ugn/elaboration_order_handling_in_gnat spark-diagnostics}@anchor{225}
@section SPARK Diagnostics
@end quotation
@node Elaboration Circularities,Resolving Elaboration Circularities,SPARK Diagnostics,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat id10}@anchor{226}@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-circularities}@anchor{227}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-circularities}@anchor{226}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id10}@anchor{227}
@section Elaboration Circularities
@end itemize
@node Elaboration-related Compiler Switches,Summary of Procedures for Elaboration Control,Resolving Elaboration Circularities,Elaboration Order Handling in GNAT
-@anchor{gnat_ugn/elaboration_order_handling_in_gnat id12}@anchor{22a}@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-related-compiler-switches}@anchor{22b}
+@anchor{gnat_ugn/elaboration_order_handling_in_gnat elaboration-related-compiler-switches}@anchor{22a}@anchor{gnat_ugn/elaboration_order_handling_in_gnat id12}@anchor{22b}
@section Elaboration-related Compiler Switches
@item @code{-gnatw.f}
-Turn on warnings for suspicious Subp'Access
+Turn on warnings for suspicious Subp’Access
When this switch is in effect, GNAT will treat @code{'Access} of an entry,
operator, or subprogram as a potential call to the target and issue warnings:
@end quotation
@node Inline Assembler,GNU Free Documentation License,Elaboration Order Handling in GNAT,Top
-@anchor{gnat_ugn/inline_assembler inline-assembler}@anchor{10}@anchor{gnat_ugn/inline_assembler doc}@anchor{230}@anchor{gnat_ugn/inline_assembler id1}@anchor{231}
+@anchor{gnat_ugn/inline_assembler doc}@anchor{230}@anchor{gnat_ugn/inline_assembler id1}@anchor{231}@anchor{gnat_ugn/inline_assembler inline-assembler}@anchor{10}
@chapter Inline Assembler
@end menu
@node Basic Assembler Syntax,A Simple Example of Inline Assembler,,Inline Assembler
-@anchor{gnat_ugn/inline_assembler id2}@anchor{232}@anchor{gnat_ugn/inline_assembler basic-assembler-syntax}@anchor{233}
+@anchor{gnat_ugn/inline_assembler basic-assembler-syntax}@anchor{232}@anchor{gnat_ugn/inline_assembler id2}@anchor{233}
@section Basic Assembler Syntax
The assembler used by GNAT and gcc is based not on the Intel assembly
language, but rather on a language that descends from the AT&T Unix
-assembler @code{as} (and which is often referred to as 'AT&T syntax').
+assembler @code{as} (and which is often referred to as ‘AT&T syntax’).
The following table summarizes the main features of @code{as} syntax
and points out the differences from the Intel conventions.
See the gcc @code{as} and @code{gas} (an @code{as} macro
@display
@emph{Register names}@w{ }
@display
-gcc / @code{as}: Prefix with '%'; for example @code{%eax}@w{ }
+gcc / @code{as}: Prefix with ‘%’; for example @code{%eax}@w{ }
Intel: No extra punctuation; for example @code{eax}@w{ }
@end display
@end display
@display
@emph{Immediate operand}@w{ }
@display
-gcc / @code{as}: Prefix with '$'; for example @code{$4}@w{ }
+gcc / @code{as}: Prefix with ‘$’; for example @code{$4}@w{ }
Intel: No extra punctuation; for example @code{4}@w{ }
@end display
@end display
@display
@emph{Address}@w{ }
@display
-gcc / @code{as}: Prefix with '$'; for example @code{$loc}@w{ }
+gcc / @code{as}: Prefix with ‘$’; for example @code{$loc}@w{ }
Intel: No extra punctuation; for example @code{loc}@w{ }
@end display
@end display
@display
@emph{Hexadecimal numbers}@w{ }
@display
-gcc / @code{as}: Leading '0x' (C language syntax); for example @code{0xA0}@w{ }
-Intel: Trailing 'h'; for example @code{A0h}@w{ }
+gcc / @code{as}: Leading ‘0x’ (C language syntax); for example @code{0xA0}@w{ }
+Intel: Trailing ‘h’; for example @code{A0h}@w{ }
@end display
@end display
The assembly code you included is clearly indicated by
the compiler, between the @code{#APP} and @code{#NO_APP}
-delimiters. The character before the 'APP' and 'NOAPP'
-can differ on different targets. For example, GNU/Linux uses '#APP' while
-on NT you will see '/APP'.
+delimiters. The character before the ‘APP’ and ‘NOAPP’
+can differ on different targets. For example, GNU/Linux uses ‘#APP’ while
+on NT you will see ‘/APP’.
If you make a mistake in your assembler code (such as using the
wrong size modifier, or using a wrong operand for the instruction) GNAT
uses the @code{"r"} (register) constraint, telling the compiler to
store the variable in a register.
-If the constraint is preceded by the equal character '=', it tells
+If the constraint is preceded by the equal character ‘=’, it tells
the compiler that the variable will be used to store data into it.
In the @code{Get_Flags} example, we used the @code{"g"} (global) constraint,
For a short subprogram such as the @code{Incr} function in the previous
section, the overhead of the call and return (creating / deleting the stack
frame) can be significant, compared to the amount of code in the subprogram
-body. A solution is to apply Ada's @code{Inline} pragma to the subprogram,
+body. A solution is to apply Ada’s @code{Inline} pragma to the subprogram,
which directs the compiler to expand invocations of the subprogram at the
point(s) of call, instead of setting up a stack frame for out-of-line calls.
Here is the resulting program:
thus saving the overhead of stack frame setup and an out-of-line call.
@node Other Asm Functionality,,Inlining Inline Assembler Code,Inline Assembler
-@anchor{gnat_ugn/inline_assembler other-asm-functionality}@anchor{23c}@anchor{gnat_ugn/inline_assembler id7}@anchor{23d}
+@anchor{gnat_ugn/inline_assembler id7}@anchor{23c}@anchor{gnat_ugn/inline_assembler other-asm-functionality}@anchor{23d}
@section Other @code{Asm} Functionality
@end menu
@node The Clobber Parameter,The Volatile Parameter,,Other Asm Functionality
-@anchor{gnat_ugn/inline_assembler the-clobber-parameter}@anchor{23e}@anchor{gnat_ugn/inline_assembler id8}@anchor{23f}
+@anchor{gnat_ugn/inline_assembler id8}@anchor{23e}@anchor{gnat_ugn/inline_assembler the-clobber-parameter}@anchor{23f}
@subsection The @code{Clobber} Parameter
identification of the registers that are used by the Inline Assembly
statements.
-Using a register that the compiler doesn't know about
+Using a register that the compiler doesn’t know about
could be a side effect of an instruction (like @code{mull}
storing its result in both eax and edx).
It can also arise from explicit register usage in your
@itemize *
@item
-Use 'register' name @code{cc} to indicate that flags might have changed
+Use ‘register’ name @code{cc} to indicate that flags might have changed
@item
-Use 'register' name @code{memory} if you changed a memory location
+Use ‘register’ name @code{memory} if you changed a memory location
@end itemize
@node The Volatile Parameter,,The Clobber Parameter,Other Asm Functionality
-@anchor{gnat_ugn/inline_assembler the-volatile-parameter}@anchor{240}@anchor{gnat_ugn/inline_assembler id9}@anchor{241}
+@anchor{gnat_ugn/inline_assembler id9}@anchor{240}@anchor{gnat_ugn/inline_assembler the-volatile-parameter}@anchor{241}
@subsection The @code{Volatile} Parameter
Although setting @code{Volatile} to @code{True} prevents unwanted
optimizations, it will also disable other optimizations that might be
important for efficiency. In general, you should set @code{Volatile}
-to @code{True} only if the compiler's optimizations have created
+to @code{True} only if the compiler’s optimizations have created
problems.
@node GNU Free Documentation License,Index,Inline Assembler,Top
-@anchor{share/gnu_free_documentation_license gnu-fdl}@anchor{1}@anchor{share/gnu_free_documentation_license doc}@anchor{242}@anchor{share/gnu_free_documentation_license gnu-free-documentation-license}@anchor{243}
+@anchor{share/gnu_free_documentation_license doc}@anchor{242}@anchor{share/gnu_free_documentation_license gnu-fdl}@anchor{1}@anchor{share/gnu_free_documentation_license gnu-free-documentation-license}@anchor{243}
@chapter GNU Free Documentation License
@strong{Preamble}
The purpose of this License is to make a manual, textbook, or other
-functional and useful document "free" in the sense of freedom: to
+functional and useful document “free” in the sense of freedom: to
assure everyone the effective freedom to copy and redistribute it,
with or without modifying it, either commercially or noncommercially.
Secondarily, this License preserves for the author and publisher a way
to get credit for their work, while not being considered responsible
for modifications made by others.
-This License is a kind of "copyleft", which means that derivative
+This License is a kind of “copyleft”, which means that derivative
works of the document must themselves be free in the same sense. It
complements the GNU General Public License, which is a copyleft
license designed for free software.
world-wide, royalty-free license, unlimited in duration, to use that
work under the conditions stated herein. The @strong{Document}, below,
refers to any such manual or work. Any member of the public is a
-licensee, and is addressed as "@strong{you}". You accept the license if you
+licensee, and is addressed as “@strong{you}”. You accept the license if you
copy, modify or distribute the work in a way requiring permission
under copyright law.
-A "@strong{Modified Version}" of the Document means any work containing the
+A “@strong{Modified Version}” of the Document means any work containing the
Document or a portion of it, either copied verbatim, or with
modifications and/or translated into another language.
-A "@strong{Secondary Section}" is a named appendix or a front-matter section of
+A “@strong{Secondary Section}” is a named appendix or a front-matter section of
the Document that deals exclusively with the relationship of the
-publishers or authors of the Document to the Document's overall subject
+publishers or authors of the Document to the Document’s overall subject
(or to related matters) and contains nothing that could fall directly
within that overall subject. (Thus, if the Document is in part a
textbook of mathematics, a Secondary Section may not explain any
commercial, philosophical, ethical or political position regarding
them.
-The "@strong{Invariant Sections}" are certain Secondary Sections whose titles
+The “@strong{Invariant Sections}” are certain Secondary Sections whose titles
are designated, as being those of Invariant Sections, in the notice
that says that the Document is released under this License. If a
section does not fit the above definition of Secondary then it is not
Invariant Sections. If the Document does not identify any Invariant
Sections then there are none.
-The "@strong{Cover Texts}" are certain short passages of text that are listed,
+The “@strong{Cover Texts}” are certain short passages of text that are listed,
as Front-Cover Texts or Back-Cover Texts, in the notice that says that
the Document is released under this License. A Front-Cover Text may
be at most 5 words, and a Back-Cover Text may be at most 25 words.
-A "@strong{Transparent}" copy of the Document means a machine-readable copy,
+A “@strong{Transparent}” copy of the Document means a machine-readable copy,
represented in a format whose specification is available to the
general public, that is suitable for revising the document
straightforwardly with generic text editors or (for images composed of
format whose markup, or absence of markup, has been arranged to thwart
or discourage subsequent modification by readers is not Transparent.
An image format is not Transparent if used for any substantial amount
-of text. A copy that is not "Transparent" is called @strong{Opaque}.
+of text. A copy that is not “Transparent” is called @strong{Opaque}.
Examples of suitable formats for Transparent copies include plain
ASCII without markup, Texinfo input format, LaTeX input format, SGML
machine-generated HTML, PostScript or PDF produced by some word
processors for output purposes only.
-The "@strong{Title Page}" means, for a printed book, the title page itself,
+The “@strong{Title Page}” means, for a printed book, the title page itself,
plus such following pages as are needed to hold, legibly, the material
this License requires to appear in the title page. For works in
-formats which do not have any title page as such, "Title Page" means
-the text near the most prominent appearance of the work's title,
+formats which do not have any title page as such, “Title Page” means
+the text near the most prominent appearance of the work’s title,
preceding the beginning of the body of the text.
-The "@strong{publisher}" means any person or entity that distributes
+The “@strong{publisher}” means any person or entity that distributes
copies of the Document to the public.
-A section "@strong{Entitled XYZ}" means a named subunit of the Document whose
+A section “@strong{Entitled XYZ}” means a named subunit of the Document whose
title either is precisely XYZ or contains XYZ in parentheses following
text that translates XYZ in another language. (Here XYZ stands for a
-specific section name mentioned below, such as "@strong{Acknowledgements}",
-"@strong{Dedications}", "@strong{Endorsements}", or "@strong{History}".)
-To "@strong{Preserve the Title}"
+specific section name mentioned below, such as “@strong{Acknowledgements}”,
+“@strong{Dedications}”, “@strong{Endorsements}”, or “@strong{History}”.)
+To “@strong{Preserve the Title}”
of such a section when you modify the Document means that it remains a
-section "Entitled XYZ" according to this definition.
+section “Entitled XYZ” according to this definition.
The Document may include Warranty Disclaimers next to the notice which
states that this License applies to the Document. These Warranty
If you publish printed copies (or copies in media that commonly have
printed covers) of the Document, numbering more than 100, and the
-Document's license notice requires Cover Texts, you must enclose the
+Document’s license notice requires Cover Texts, you must enclose the
copies in covers that carry, clearly and legibly, all these Cover
Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on
the back cover. Both covers must also clearly and legibly identify
@item
Preserve in that license notice the full lists of Invariant Sections
-and required Cover Texts given in the Document's license notice.
+and required Cover Texts given in the Document’s license notice.
@item
Include an unaltered copy of this License.
@item
-Preserve the section Entitled "History", Preserve its Title, and add
+Preserve the section Entitled “History”, Preserve its Title, and add
to it an item stating at least the title, year, new authors, and
publisher of the Modified Version as given on the Title Page. If
-there is no section Entitled "History" in the Document, create one
+there is no section Entitled “History” in the Document, create one
stating the title, year, authors, and publisher of the Document as
given on its Title Page, then add an item describing the Modified
Version as stated in the previous sentence.
Preserve the network location, if any, given in the Document for
public access to a Transparent copy of the Document, and likewise
the network locations given in the Document for previous versions
-it was based on. These may be placed in the "History" section.
+it was based on. These may be placed in the “History” section.
You may omit a network location for a work that was published at
least four years before the Document itself, or if the original
publisher of the version it refers to gives permission.
@item
-For any section Entitled "Acknowledgements" or "Dedications",
+For any section Entitled “Acknowledgements” or “Dedications”,
Preserve the Title of the section, and preserve in the section all
the substance and tone of each of the contributor acknowledgements
and/or dedications given therein.
or the equivalent are not considered part of the section titles.
@item
-Delete any section Entitled "Endorsements". Such a section
+Delete any section Entitled “Endorsements”. Such a section
may not be included in the Modified Version.
@item
-Do not retitle any existing section to be Entitled "Endorsements"
+Do not retitle any existing section to be Entitled “Endorsements”
or to conflict in title with any Invariant Section.
@item
appendices that qualify as Secondary Sections and contain no material
copied from the Document, you may at your option designate some or all
of these sections as invariant. To do this, add their titles to the
-list of Invariant Sections in the Modified Version's license notice.
+list of Invariant Sections in the Modified Version’s license notice.
These titles must be distinct from any other section titles.
-You may add a section Entitled "Endorsements", provided it contains
+You may add a section Entitled “Endorsements”, provided it contains
nothing but endorsements of your Modified Version by various
-parties---for example, statements of peer review or that the text has
+parties—for example, statements of peer review or that the text has
been approved by an organization as the authoritative definition of a
standard.
Make the same adjustment to the section titles in the list of
Invariant Sections in the license notice of the combined work.
-In the combination, you must combine any sections Entitled "History"
+In the combination, you must combine any sections Entitled “History”
in the various original documents, forming one section Entitled
-"History"; likewise combine any sections Entitled "Acknowledgements",
-and any sections Entitled "Dedications". You must delete all sections
-Entitled "Endorsements".
+“History”; likewise combine any sections Entitled “Acknowledgements”,
+and any sections Entitled “Dedications”. You must delete all sections
+Entitled “Endorsements”.
@strong{6. COLLECTIONS OF DOCUMENTS}
A compilation of the Document or its derivatives with other separate
and independent documents or works, in or on a volume of a storage or
-distribution medium, is called an "aggregate" if the copyright
+distribution medium, is called an “aggregate” if the copyright
resulting from the compilation is not used to limit the legal rights
-of the compilation's users beyond what the individual works permit.
+of the compilation’s users beyond what the individual works permit.
When the Document is included in an aggregate, this License does not
apply to the other works in the aggregate which are not themselves
derivative works of the Document.
If the Cover Text requirement of section 3 is applicable to these
copies of the Document, then if the Document is less than one half of
-the entire aggregate, the Document's Cover Texts may be placed on
+the entire aggregate, the Document’s Cover Texts may be placed on
covers that bracket the Document within the aggregate, or the
electronic equivalent of covers if the Document is in electronic form.
Otherwise they must appear on printed covers that bracket the whole
the translation and the original version of this License or a notice
or disclaimer, the original version will prevail.
-If a section in the Document is Entitled "Acknowledgements",
-"Dedications", or "History", the requirement (section 4) to Preserve
+If a section in the Document is Entitled “Acknowledgements”,
+“Dedications”, or “History”, the requirement (section 4) to Preserve
its Title (section 1) will typically require changing the actual
title.
Each version of the License is given a distinguishing version number.
If the Document specifies that a particular numbered version of this
-License "or any later version" applies to it, you have the option of
+License “or any later version” applies to it, you have the option of
following the terms and conditions either of that specified version or
of any later version that has been published (not as a draft) by the
Free Software Foundation. If the Document does not specify a version
number of this License, you may choose any version ever published (not
as a draft) by the Free Software Foundation. If the Document
specifies that a proxy can decide which future versions of this
-License can be used, that proxy's public statement of acceptance of a
+License can be used, that proxy’s public statement of acceptance of a
version permanently authorizes you to choose that version for the
Document.
@strong{11. RELICENSING}
-"Massive Multiauthor Collaboration Site" (or "MMC Site") means any
+“Massive Multiauthor Collaboration Site” (or “MMC Site”) means any
World Wide Web server that publishes copyrightable works and also
provides prominent facilities for anybody to edit those works. A
public wiki that anybody can edit is an example of such a server. A
-"Massive Multiauthor Collaboration" (or "MMC") contained in the
+“Massive Multiauthor Collaboration” (or “MMC”) contained in the
site means any set of copyrightable works thus published on the MMC
site.
-"CC-BY-SA" means the Creative Commons Attribution-Share Alike 3.0
+“CC-BY-SA” means the Creative Commons Attribution-Share Alike 3.0
license published by Creative Commons Corporation, a not-for-profit
corporation with a principal place of business in San Francisco,
California, as well as future copyleft versions of that license
published by that same organization.
-"Incorporate" means to publish or republish a Document, in whole or
+“Incorporate” means to publish or republish a Document, in whole or
in part, as part of another Document.
-An MMC is "eligible for relicensing" if it is licensed under this
+An MMC is “eligible for relicensing” if it is licensed under this
License, and if all works that were first published under this License
somewhere other than this MMC, and subsequently incorporated in whole
or in part into the MMC, (1) had no cover texts or invariant sections,
under the terms of the GNU Free Documentation License, Version 1.3
or any later version published by the Free Software Foundation;
with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
-A copy of the license is included in the section entitled "GNU
-Free Documentation License".
+A copy of the license is included in the section entitled “GNU
+Free Documentation License”.
@end quotation
If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts,
-replace the "with ... Texts." line with this:
+replace the “with … Texts.” line with this:
@quotation
@printindex ge
-@anchor{gnat_ugn/gnat_utility_programs switches-related-to-project-files}@w{ }
@anchor{cf}@w{ }
+@anchor{gnat_ugn/gnat_utility_programs switches-related-to-project-files}@w{ }
@c %**end of body
@bye
projects / platform / upstream / gcc.git / commitdiff