Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Ada Programming/All Chapters

From Wikibooks, the open-content textbooks collection
< Ada Programming

This Wikibook was voted Book of the Month for

September 2005!

Contents
1 Basic
1.1 Things to look out for
1.1.1 comb format
1.1.1.1 if statements
1.1.1.2 procedures
1.1.1.3 functions
1.1.1.4 records
1.1.1.5 class records
1.1.1.6 package declarations
1.1.1.7 generic declarations
1.1.2 Type and subtype
1.1.3 Constrained types and unconstrained types
1.1.4 Dynamic types
Augusta Ada King,
1.1.5 Separation of interface Countess of Lovelace.
1.2 "Hello, world!" programs
1.2.1 "Hello, world!"
1.2.2 "Hello, world!" with renames
1.2.3 "Hello, world!" with use
1.2.4 FAQ: Why is "Hello, world!" sooo big?
2 Installing
2.1 GNAT 3.15p, the latest public GMGPL release
2.2 GNAT GPL Edition (Ada 2005)
2.3 The GNU Ada Project
2.4 Prebuilt packages as part of larger distributions
2.4.1 Mac OS X
2.4.2 Linux
2.4.2.1 SuSE
2.4.2.2 Debian
2.4.2.3 Mandrake
2.4.3 Windows
2.4.3.1 AIDE
2.4.3.2 MinGW
2.4.3.3 Cygwin
2.4.4 MS-DOS
2.4.4.1 DJGPP
2.4.5 Solaris 8, 9, 10 on SPARC and x86
2.5 Build your own
2.5.1 Linux
2.5.2 Windows
2.5.2.1 Cygwin
2.6 See also
2.6.1 Wikibook
3 Building
3.1 Building with various compilers
3.1.1 GNAT
3.1.1.1 GNAT commandline
3.1.1.2 GNAT IDE
3.1.2 Rational APEX
3.1.3 ObjectAda
3.1.4 Macintosh OS X
3.1.5 To be completed
3.2 Compiling our Demo Source
3.2.1 GNAT

1 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

3.2.2 Rational APEX

3.2.3 ObjectAda
3.2.3.1 ObjectAda commandline
3.3 See also
3.3.1 Wikibook
4 Control
4.1 Conditionals
4.1.1 if-else
4.1.2 Optimizing hints
4.1.3 case
4.2 unconditionals
4.2.1 return
4.2.2 goto
4.2.2.1 Isn't goto evil?
4.3 loops
4.3.1 endless loop
4.3.2 loop with condition at the beginning
4.3.3 loop with condition at the end
4.3.4 loop with condition in the middle
4.3.5 for loop
4.3.5.1 for loop on arrays
4.3.5.2 Working Demo
4.4 See also
4.4.1 Wikibook
4.4.2 Ada Reference Manual
5 Subtypes
5.1 Types in Ada
5.2 Subtype categories
5.2.1 Anonymous subtype
5.2.2 Base type
5.2.3 Constrained subtype
5.2.4 Definite subtype
5.2.5 Indefinite subtype
5.2.6 Named subtype
5.2.7 Unconstrained subtype
5.3 Type declaration
5.3.1 Declaring new types
5.3.2 Declaring subtypes
5.3.3 Type vs. subtype
5.3.4 Converting subtypes
5.4 Converting data
5.4.1 Evaluate as
5.4.2 Rename view
5.4.3 Checked conversion
5.4.3.1 In object-oriented programming
5.4.4 Address conversion
5.4.5 Unchecked conversion
5.4.6 Overlays
5.5 See also
5.5.1 Wikibook
5.5.2 Ada Reference Manual
6 Types
6.1 Types in Ada
6.2 Strong typing
6.3 Type classification
6.4 Predefined types
6.5 See also
6.5.1 Wikibook
6.5.2 Ada Reference Manual
7 Integer types
7.1 Working demo
7.2 See also
7.2.1 Wikibook
7.2.2 Ada Reference Manual
8 Unsigned integer types
8.1 See also
8.1.1 Wikibook
8.1.2 Ada Reference Manual
9 Enumerations

2 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

9.1 Operators and attributes

9.2 Enumeration literals
9.2.1 Characters as enumeration literals
9.3 Enumeration subtypes
9.4 See also
9.4.1 Wikibook
9.4.2 Ada Reference Manual
10 Floating point types
10.1 Description
10.2 See also
10.2.1 Wikibook
10.2.2 Ada Reference Manual
11 Fixed point types
11.1 Description
11.2 Binary fixed point
11.3 Decimal fixed point
11.4 See also
11.4.1 Wikibook
11.4.2 Ada 95 Reference Manual
11.4.3 Ada 2005 Reference Manual
12 Arrays
12.1 Declaring arrays
12.1.1 Basic syntax
12.1.2 With known subrange
12.1.3 With unknown subrange
12.1.4 With aliased elements
12.2 Using arrays
12.3 See also
12.3.1 Wikibook
12.3.2 Ada Reference Manual
12.3.3 Ada Quality and Style Guide
13 Records
13.1 Basic record
13.2 Null record
13.3 Discriminated record
13.4 Variant record
13.5 Union
13.6 Tagged record
13.7 Abstract tagged record
13.8 With aliased elements
13.9 See also
13.9.1 Wikibook
13.9.2 Ada Reference Manual
13.9.2.1 Ada 95
13.9.2.2 Ada 2005
13.9.2.3 Ada Issues
14 Access types
14.1 Different access types
14.1.1 Pool access
14.1.2 Access all
14.1.3 Access constant
14.1.4 Anonymous access
14.1.5 Not null access
14.1.6 Constant anonymous access
14.1.7 Access to subprogram
14.1.8 Anonymous access to subprogram
14.2 Using access types
14.2.1 Creating object in a storage pool
14.2.2 Deleting object from a storage pool
14.2.3 Implicit dereferencing
14.3 Access FAQ
14.3.1 Access vs. access all
14.3.2 Access performance
14.3.3 Access vs. System.Address
14.3.4 C compatible pointer
14.3.5 Where is void*?
14.4 See also
14.4.1 Wikibook
14.4.2 Ada Reference Manual

3 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

14.4.2.1 Ada 95
14.4.2.2 Ada 2005
14.4.3 Ada Quality and Style Guide
15 Strings
15.1 Fixed-length string handling
15.2 Bounded-length string handling
15.3 Unbounded-length string handling
15.4 See also
15.4.1 Wikibook
15.4.2 Ada 95 Reference Manual
15.4.3 Ada 2005 Reference Manual
16 Subprograms
16.1 Procedures
16.2 Functions
16.3 Named parameters
16.4 Default parameters
16.5 See also
16.5.1 Wikibook
16.5.2 Ada 95 Reference Manual
16.5.3 Ada 2005 Reference Manual
16.5.4 Ada Quality and Style Guide
17 Packages
17.1 Parts of a package
17.1.1 The public package specification
17.1.2 The private package specification
17.1.3 The package body
17.2 Using packages
17.2.1 Standard with
17.2.2 Private with
17.2.3 Limited with
17.2.4 With type
17.3 Package organisation
17.3.1 Child packages
17.3.2 Nested packages
17.3.3 Subunits
17.4 See also
17.4.1 Wikibook
17.4.2 Wikipedia
17.4.3 Ada 95 Reference Manual
17.4.4 Ada 2005 Reference Manual
18 Input Output
18.1 Text I/O
18.2 Direct I/O
18.3 Sequential I/O
18.4 Storage I/O
18.5 Stream I/O
18.6 See also
18.6.1 Wikibook
18.6.2 Ada 95 Reference Manual
18.6.3 Ada 2005 Reference Manual
18.6.4 Ada Quality and Style Guide
19 Exceptions
19.1 Robustness
19.2 Modules, preconditions and postconditions
19.3 Predefined exceptions
19.4 Input-output exceptions
19.5 Exception declarations
19.6 Raising exceptions
19.7 Exception handling and propagation
19.8 Information about an exception occurrence
19.9 See also
19.9.1 Wikibook
19.9.2 Ada 95 Reference Manual
19.9.3 Ada 2005 Reference Manual
19.9.4 Ada Quality and Style Guide
20 Generics
20.1 Parametric polymorphism (generic units)
20.2 See also
20.2.1 Wikibook

4 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

20.2.2 Wikipedia
20.2.3 Ada Reference Manual
21 Tasking
21.1 Tasks
21.1.1 Rendezvous
21.1.2 Selective Wait
21.1.3 Guards
21.2 Protected types
21.3 Entry families
21.4 Termination
21.5 Timeout
21.6 Conditional entry calls
21.7 Requeue statements
21.8 Scheduling
21.9 Interfaces
21.10 See also
21.10.1 Wikibook
21.10.2 Ada Reference Manual
21.10.2.1 Ada 95
21.10.2.2 Ada 2005
21.11 Ada Quality and Style Guide
22 Object Orientation
22.1 Object-orientation on Ada
22.1.1 The package
22.1.1.1 A little note for C++ programmers
22.1.2 The tagged record
22.1.2.1 The class-wide type
22.1.3 Primitive operations
22.1.4 Interfaces
22.2 Class names
22.2.1 Classes/Class
22.2.2 Class/Object
22.2.3 Class/Class_Type
22.3 See also
22.3.1 Wikibook
22.3.2 Wikipedia
22.3.3 Ada Reference Manual
22.3.3.1 Ada 95
22.3.3.2 Ada 2005
22.3.4 Ada Quality and Style Guide
23 Ada 2005
23.1 Language features
23.1.1 Character set
23.1.2 Interfaces
23.1.3 Union
23.1.4 With
23.1.5 Access types
23.1.5.1 Not null access
23.1.5.2 Anonymous access
23.2 Language library
23.2.1 Container
23.2.2 Scan Filesystem Directories and
Environment Variables
23.2.3 Numerics
23.3 Real-Time and High Integrity Systems
23.3.1 Ravenscar profile
23.3.2 New scheduling policies
23.3.3 Dynamic priorities for protected objects
23.4 Summary of what's new
23.4.1 New keywords
23.4.2 New pragmas
23.4.3 New attributes
23.4.4 New packages
23.5 See also
23.5.1 Wikibook
23.5.2 Pages in the category Ada 2005
23.6 External links
23.6.1 Papers and presentations
23.6.2 Rationale

5 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

23.6.3 Language Requirements

23.6.4 Ada Reference Manual
23.6.5 Ada Issues
24 Tips
24.1 Full declaration of a type can be deferred to the
unit's body
24.2 Lambda calculus through generics
24.3 See also
24.3.1 Wikibook
24.3.2 Ada Reference Manual
25 Algorithms
25.1 Introduction
25.2 Chapter 1: Introduction
25.2.1 To Lower
25.2.2 Equal Ignore Case
25.3 Chapter 6: Dynamic Programming
25.3.1 Fibonacci numbers
25.3.1.1 Simple Implementation
25.3.1.2 Cached Implementation
25.3.1.3 Memory Optimized Implementation
25.3.1.4 No 64 bit integers
26 Function overloading
26.1 Description
26.2 Demonstration
26.2.1 calling the first function
26.2.2 calling the second function
26.3 Function overloading in Ada
26.4 See also
26.4.1 Wikibook
26.4.2 Ada 95 Reference Manual
26.4.3 Ada 2005 Reference Manual
27 Mathematical calculations
27.1 Simple calculations
27.1.1 Addition
27.1.2 Subtraction
27.1.3 Multiplication
27.1.4 Division
27.2 Exponential calculations
27.2.1 Power of
27.2.2 Root
27.2.3 Logarithm
27.2.4 Demonstration
27.3 Higher math
27.3.1 Trigonometric calculations
27.3.2 Hyperbolic calculations
27.3.3 Complex arithmethic
27.3.4 Vector and Matrix Arithmetic
27.4 See also
27.4.1 Wikibook
27.4.2 Ada 95 Reference Manual
27.4.3 Ada 2005 Reference Manual
28 Statements
29 Variables
29.1 Assignment statements
29.2 Uses
29.3 See also
29.3.1 Ada Reference Manual
30 Lexical elements
30.1 Character set
30.2 Lexical elements
30.2.1 Identifiers
30.2.2 Numbers
30.2.3 Character literals
30.2.4 String literals
30.2.5 Delimiters
30.2.6 Comments
30.2.7 Reserved words
30.3 See also
30.3.1 Wikibook

6 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

30.3.2 Ada Reference Manual

31 Keywords
31.1 Language summary keywords
31.2 List of keywords
31.3 See also
31.3.1 Wikibook
31.3.2 Ada 95 Reference Manual
31.3.3 Ada 2005 Reference Manual
31.3.4 Ada Quality and Style Guide
32 Delimiters
32.1 Single character delimiters
32.2 Compound character delimiters
32.3 Others
32.4 See also
32.4.1 Wikibook
32.4.2 Ada 95 Reference Manual
32.4.3 Ada 2005 Reference Manual
33 Operators
33.1 Standard operators
33.1.1 Logical operators
33.1.2 Relational operators
33.1.3 Binary adding operators
33.1.4 Unary adding operators
33.1.5 Multiplying operator
33.1.6 Highest precedence operator
33.2 Shortcut operators
33.3 Membership tests
33.4 See also
33.4.1 Wikibook
33.4.2 Ada 95 Reference Manual
33.4.3 Ada 2005 Reference Manual
33.4.4 Ada Quality and Style Guide
34 Attributes
34.1 Language summary attributes
34.2 List of language defined attributes
34.2.1 A – B
34.2.2 C
34.2.3 D – F
34.2.4 G – L
34.2.5 M
34.2.6 O – R
34.2.7 S
34.2.8 T – V
34.2.9 W – Z
34.3 List of implementation defined attributes
34.3.1 A – D
34.3.2 E – H
34.3.3 I – N
34.3.4 O – T
34.3.5 U – Z
34.4 See also
34.4.1 Wikibook
34.4.2 Ada 95 Reference Manual
34.4.3 Ada 2005 Reference Manual
35 Pragmas
35.1 Description
35.2 List of language defined pragmas
35.2.1 A – H
35.2.2 I – O
35.2.3 P – R
35.2.4 S – Z
35.3 List of implementation defined pragmas
35.3.1 A – C
35.3.2 D – H
35.3.3 I – L
35.3.4 M – S
35.3.5 T – Z
35.4 See also
35.4.1 Wikibook

7 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

35.4.2 Ada Reference Manual

35.4.2.1 Ada 95
35.4.2.2 Ada 2005
36 Libraries: Standard
36.1 Implementation
36.2 Portability
36.3 See also
36.3.1 Wikibook
36.3.2 Ada Reference Manual
36.3.3 Ada Quality and Style Guide
37 Libraries: Ada
37.1 List of language defined child units
37.1.1 A – C
37.1.2 D – F
37.1.3 G – R
37.1.4 R – S
37.1.5 T – U
37.1.6 W – Z
37.2 List of implementation defined child units
37.2.1 A – K
37.2.2 L – Q
37.2.3 R – Z
37.3 See also
37.3.1 Wikibook
37.3.2 Ada Reference Manual
38 Libraries: Interfaces
38.1 Child Packages
38.2 See also
38.2.1 Wikibook
38.2.2 Ada Reference Manual
38.2.2.1 Ada 95
38.2.2.2 Ada 2005
39 Libraries: System
40 Libraries: GNAT
40.1 Child packages
40.2 See also
40.2.1 External links
40.2.2 Wikibook
41 Libraries
41.1 Predefined Language Libraries
41.2 Other Language Libraries
41.3 See also
41.3.1 Wikibook
41.3.2 Ada Reference Manual
42 Libraries: Multi-Purpose
42.1 See also
42.1.1 Wikibook
42.1.2 Ada Reference Manual
43 Libraries: Container
43.1 See also
43.1.1 Wikibook
43.1.2 Ada Reference Manual
44 Libraries: GUI
44.1 See also
44.1.1 Wikibook
44.1.2 Ada Reference Manual
45 Libraries: Distributed
45.1 See also
45.1.1 Wikibook
45.1.2 Ada Reference Manual
46 Libraries: Database
46.1 See also
46.1.1 Wikibook
46.1.2 Ada Reference Manual
47 Libraries: Web
47.1 See also
47.1.1 Wikibook
47.1.2 Ada Reference Manual
48 Libraries: IO

8 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

48.1 See also

48.1.1 Wikibook
48.1.2 Ada Reference Manual
49 Platform
49.1 See also
49.1.1 Wikibook
49.1.2 Ada Reference Manual
49.1.3 Ada Quality and Style Guide
50 Platform: Linux
50.1 See also
50.1.1 Wikibook
50.1.2 Ada Reference Manual
50.1.3 External resources
51 Platform: Windows
51.1 See also
51.1.1 Wikibook
51.1.2 Ada Reference Manual
52 Platform: VM
52.1 See also
52.1.1 Wikibook
52.1.2 Ada Reference Manual
53 Portals
53.1 See also
53.1.1 Wikibook
53.1.2 Ada Reference Manual
53.1.3 Ada Quality and Style Guide
54 GNU Free Documentation License
54.1 0. PREAMBLE
54.2 1. APPLICABILITY AND DEFINITIONS
54.3 2. VERBATIM COPYING
54.4 3. COPYING IN QUANTITY
54.5 4. MODIFICATIONS
54.6 5. COMBINING DOCUMENTS
54.7 6. COLLECTIONS OF DOCUMENTS
54.8 7. AGGREGATION WITH INDEPENDENT WORKS
54.9 8. TRANSLATION
54.10 9. TERMINATION
54.11 10. FUTURE REVISIONS OF THIS LICENSE
54.12 External links

Basic

Things to look out for

It will help to be prepared to spot a number of significant features of Ada that are important
for learning its syntax and semantics.

comb format
There is a comb format in all the control structures and module structures. See the following
examples for the comb format. You don't have to understand what the examples do yet - just
look for the similarities in layout.

if statements

9 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

if Boolean expression then

statements
elsif Boolean expression then
statements
else
statements
end if;

procedures

procedure P (parameters : in out type) is

declarations
begin
statements
exception
handlers
end P;

functions

function F (parameters : in type) return type is

declarations
begin
statements
exception
handlers
end F;

records

type R (discriminant : type) is

record
declarations
end record;

class records

type C (discriminant : type) is new parent class declaration

and interface declarations
with
record
declarations
end record;

package declarations

package P is
declarations
private
declarations
end P;

generic declarations

generic
declarations
package P is
declarations
private
declarations
end P;

Note that semicolons consistently terminate statements and declarations; and that the empty
string is not a valid statement: the null statement is null;.

10 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Type and subtype

There is an important distinction between type and subtype: a type is given by a set of
values and their operations. A subtype is given by a type, and a constraint that limits the set
of values. Values are always of a type. Objects (constants and variables) are of a subtype.
This generalizes, clarifies and systematizes a relationship, e.g. between Integer and 1..100,
that is handled ad hoc in the semantics of Pascal.

Constrained types and unconstrained types

There is an important distinction between constrained types and unconstrained types. An
unconstrained type has one or more free parameters that affect its size or shape. A
constrained type fixes the values of these parameters and so determines its size and shape.
Loosely speaking, objects must be of a constrained type, but formal parameters may be of an
unconstrained type (they adopt the constraint of any corresponding actual parameter). This
solves the problem of array parameters in Pascal (among other things).

Dynamic types
Where values in Pascal or C must be static (e.g. the subscript bounds of an array) they may
be dynamic in Ada. However, static expressions are required in certain cases where dynamic
evaluation would not permit a reasonable implementation (e.g. in setting the number of
digits of precision of a floating point type).

Separation of interface
Ada consistently supports a separation of interface and mechanism. You can see this in the
format of a package, which separates its declaration from its body; and in the concept of a
private type, whose representation in terms of Ada data structures is inaccessible outside the
scope containing its definition.

"Hello, world!" programs

"Hello, world!"
A common example of a language's syntax is the Hello world program. Here a
straight-forward Ada Implementation:

File: hello_world_1.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/hello_world_1.adb?only_with_tag=HEAD&view=mar
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/hello_world_1.adb) ,
download page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

with Ada.Text_IO;

procedure Hello is
begin
Ada.Text_IO.Put_Line("Hello, world!");
end Hello;

The with statement adds the package Ada.Text_IO to the program. It contains all
functionality needed for textual Input/Output. It makes the declarations (i.e. all types and the
operations on them) within Ada.Text_IO visible by selection. In Ada, packages are used as
toolboxes, providing a collection of tools and types in one easy-to-access module.

Next we declare a main procedure. In Ada the main procedure does not need to be called
"main". It is implementation defined which subprograms can be used as main subprograms.
However, an implementation is required to support all main subprograms that are public

11 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

parameterless library procedures. (The last sentence is a quote from the reference manual,
RM 10.2(29).)

The call on Ada.Text_IO.Put_Line actually writes the "Hello World".

Since with only makes the content of a package visible by selection, we need to prefix the
procedure name Put_Line with the package name Ada.Text_IO. If you need procedures from
a package more often some form of shortcut is needed. There are two options open:

"Hello, world!" with renames

By renaming a package it is possible to give a shorter alias to any package name. This
reduces the typing involved while still keeping some of the readability.

File: hello_world_2.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/hello_world_2.adb?only_with_tag=HEAD&view=mar
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/hello_world_2.adb) ,
download page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

with Ada.Text_IO;
procedure Hello is
package IO renames Ada.Text_IO;
begin
IO.Put_Line("Hello, world!");
IO.New_Line;
IO.Put_Line("I am an Ada program with package rename.");
end Hello;

renames can also be used for procedures, functions, variables, array elements. It can not be
used for types - a type rename can be accomplished with subtype.

"Hello, world!" with use

The use clause makes all the content of a package directly visible. It allows even less typing
but removes some of the readability. My suggested "rule of thumb": use for the most used
package and renames for all other packages. You might have another rule (for example,
always use Ada.Text_IO, never use anything else).

File: hello_world_3.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/hello_world_3.adb?only_with_tag=HEAD&view=mar
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/hello_world_3.adb) ,
download page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

with Ada.Text_IO;
procedure Hello is
use Ada.Text_IO;
begin
Put_Line("Hello, world!");
New_Line;
Put_Line("I am an Ada program with package use.");
end Hello;

use can be used for packages and in the form of use type for types. use type makes only the
operators of the given type directly visible but not any other operations on the type.

FAQ: Why is "Hello, world!" sooo big?

Ada beginners frequently ask how it can be that such a simple program as "Hello, world!"
results in such a large executable. The reason has nothing to do with Ada but can usually be
found in the compiler and linker options used - or better not used.

12 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Standard behavior for Ada compilers — or good compilers in general — is not to create the
best code possible but to be optimized for ease of use. This is done to not frighten away
potential new users by providing a system which does not work "out of the box".

The GNAT project files which you can download alongside the example programs use better
tuned compiler, binder and linker options. If you use those your "Hello, world!" will be a lot
smaller:

32K ./Linux-i686-Debug/hello_world_1
8,0K ./Linux-i686-Release/hello_world_1
36K ./Linux-x86_64-Debug/hello_world_1
12K ./Linux-x86_64-Release/hello_world_1
1,1M ./Windows_NT-i686-Debug/hello_world_1.exe
16K ./Windows_NT-i686-Release/hello_world_1.exe
32K ./VMS-AXP-Debug/hello_world_1.exe
12K ./VMS-AXP-Release/hello_world_1.exe

For comparison the sizes for a plain gnat make compile:

497K hello_world_1 (Linux i686)

500K hello_world_1 (Linux x86_64)
1,5M hello_world_1.exe (Windows_NT i686)
589K hello_world_1.exe (VMS AXP)

Installing
The only free and fully functional Ada compiler available is the GNAT Compiler, which is part
of the GNU Compiler Collection. GNAT is the only compiler that supports all the annexes of
the Ada standard.

GNAT 3.15p, the latest public GMGPL release

Beginners using Windows, Linux, or Solaris are best off downloading the prebuilt compiler of
the latest public GMGPL release by AdaCore. While the prebuilt compiler has not been
updated recently, it is still sufficient for most users. The Libre Compiler has passed the Ada
Conformity Assessment Test Suite (ACATS). The latest version is GNAT 3.15p; it uses GCC
2.8.1 as its backend. The binary distribution from AdaCore also contains an Ada-aware
version of the GNU Debugger (GDB), and a graphical front-end to GDB called the GNU
Visual Debugger (GVD).

The following packages are suggested:

Linux
ftp://ftp.cs.kuleuven.ac.be/pub/Ada-Belgium/mirrors/gnu-ada/3.15p/gnat-3.15p-i686-pc-redha
ftp://ftp.cs.kuleuven.ac.be/pub/Ada-Belgium/mirrors/gnu-ada/3.15p/florist-3.15p-src.tgz
ftp://ftp.cs.kuleuven.ac.be/pub/Ada-Belgium/mirrors/gnu-ada/3.15p/asis/asis-3.15p-src.tgz
http://libre.adacore.com/gps/gps-2.1.0-academic-x86-linux.tgz
Windows
ftp://ftp.cs.kuleuven.ac.be/pub/Ada-Belgium/mirrors/gnu-ada/3.15p/winnt/gnat-3.15p-nt.exe
ftp://ftp.cs.kuleuven.ac.be/pub/Ada-Belgium/mirrors/gnu-ada/3.15p/winnt/gnatwin-3.15p.exe
ftp://ftp.cs.kuleuven.ac.be/pub/Ada-Belgium/mirrors/gnu-ada/3.15p/asis/asis-3.15p-src.tgz
http://libre.adacore.com/gps/gps-2.1.0-academic-x86-windows.exe
OS/2
ftp://ftp.cs.kuleuven.ac.be/pub/Ada-Belgium/mirrors/gnu-ada/3.15p/contrib/os2/gnat-3.15p-os

FLORIST is a library that provides a POSIX programming interface to the operating system.

ASIS, the Ada Semantic Interface Specification, is a library that allows Ada programs to
examine and manipulate other Ada programs.

13 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

GPS, the GNAT Programming System, is a full-featured integrated development

environment, written in Ada. It allows you to program in Ada, C and C++.

These are optional add-ons to the compiler.

GNAT GPL Edition (Ada 2005)

This is the latest public relase of GNAT by AdaCore, but take into accout that the run-time
license is now license under the GPL, so you can only distribute your developed programs if
you license them under the GPL.

You can download GNAT GPL Edition from the Libre site: http://libre.adacore.com/

The GNU Ada Project

The GNU Ada Project provides source and binary packages of various GNAT versions for a
varaity of operating systems.

Most notably the The GNU Ada Project also provides the scripts used to create the packages.
This may be helpfull if you plan to port the compiler to another platform or create a so called
cross compiler.

You can find The GNU Ada Project at: http://gnuada.sourceforge.net. There are GPL and
GMGPL licenced version available.

Prebuilt packages as part of larger distributions

There are various distributions containing a copy of the GNAT compiler. You should however
check the version of your compiler:

gcc --version
gcc (GCC) 4.0.1
Copyright (C) 2004 Free Software Foundation, Inc.
Dies ist freie Software; die Kopierbedingungen stehen in den Quellen. Es
gibt KEINE Garantie; auch nicht für VERKAUFBARKEIT oder FÜR SPEZIELLE ZWECKE.

GCC-Versions beginning with 3.3. are buggy and you should either try to upgrade to a 3.4.
version or later, or stick with GNAT 3.15p.

Mac OS X
GNAT for Macintosh (http://www.adapower.net/macos/) provides a version of the GNAT
Compiler, Xcode integration and bindings.

Linux
Most versions of Linux come with GNAT packages as part of their GCC distribution. These
can be used instead of the Libre Version.

SuSE

All versions of SuSE Linux have a GNAT compiler included. SuSE versions 9.2 and higher
also contains ASIS, Florist and GLADE libraries. The following two packages are needed:

gnat
gnat-runtime

For 64 bit system you will need the 32 bit compatibility packages as well:

14 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

gnat-32bit
gnat-runtime-32bit

Debian

The GNU/Ada compiler (GNAT) can be installed on a Debian system with this command:

apt-get install gnat

This will also give you a list of related packages, which are likely to be useful for an Ada
programmer.

`gnat' is GNAT 3.15p (the Libre version), with several bug fixes. Besides this version, Debian
`sarge' also carries `gnat-3.3' (not recommended) and `gnat-3.4'.

There is a Debian Policy for Ada (http://www.ada-france.org/debian/debian-ada-policy.html) ,

which coordinates all Ada packages in the distribution. In particular, this Policy makes `gnat'
the compiler used for all Ada packages. This allows you to use all Ada libraries in the same
program. Debian carries many Ada libraries in separate packages; for example, see the
packages `asis-programs', `libflorist-3.15p-1-dev', `gnat-gdb' and `gnat-gps' for the add-ons
provided on the Libre site (`gvd' is in Debian `woody' but was removed from `sarge').

Mandrake

The GNU/Ada compiler (GNAT) can be installed on a Mandrake system with this command:

urpmi gnat

Windows
Both MinGW for Windows and Cygwin have GNAT as part of their GCC distribution.

AIDE

AIDE - Ada Instant Development Environment

(http://stephane.rochebrune.org/aide/aide.html) is a complete one-click, just-works Ada
distribution for Windows, consisting of GNAT, comprehensive documentation, tools and
libraries. All are precompiled, and source code is also available. The installation procedure is
particularly easy. AIDE is intended for beginners and teachers, but can also be used by
advanced users.

MinGW

MinGW - Minimalist GNU for Windows (http://mingw.sourceforge.net) contains a version the

GNAT Compiler.

The following list should help you install. {I may have forgotten something - but this is wiki,
just add to the list}

1. Install MinGW-3.1.0-1.exe.
1. extract binutils-2.15.91-20040904-1.tar.gz.
2. extract mingw-runtime-3.5.tar.gz.
3. extract gcc-core-3.4.2-20040916-1.tar.gz.
4. extract gcc-ada-3.4.2-20040916-1.tar.gz.
5. extract gcc-g++-3.4.2-20040916-1.tar.gz (Optional).
6. extract gcc-g77-3.4.2-20040916-1.tar.gz (Optional).
7. extract gcc-java-3.4.2-20040916-1.tar.gz (Optional).
8. extract gcc-objc-3.4.2-20040916-1.tar.gz (Optional).

15 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

9. extract w32api-3.1.tar.gz.
2. Install mingw32-make-3.80.0-3.exe (Optional).
3. Install gdb-5.2.1-1.exe (Optional).
4. Install MSYS-1.0.10.exe (Optional).
5. Install msysDTK-1.0.1.exe (Optional).
1. extract msys-automake-1.8.2.tar.bz2 (Optional).
2. extract msys-autoconf-2.59.tar.bz2 (Optional).
3. extract msys-libtool-1.5.tar.bz2 (Optional).

I have made good experience in using D:\MinGW as target directory for all installations and
extractiations.

Also noteworthy is that the the Windows version for GNAT from Libre is also based on
MinGW.

Cygwin

Cygwin (http://www.cygwin.com) the Linux-like environment for Windows also contains a

version the GNAT Compiler. The Cygwin version of GNAT is older than the MinGW version
and does not support DLLs and Multi-Threading (as of 11.2004).

MS-DOS
DJGPP has GNAT as part of their GCC distribution.

DJGPP

DJGPP (http://www.delorie.com/djgpp/) is a port of a comprehensive collection of GNU

utilities to MS-DOS with 32-bit extensions, and is actively supported (as of 1.2005). It
includes the whole GCC compiler collection, that now includes Ada. See the DJGPP
(http://www.delorie.com/djgpp/) website for installation instructions.

DJGPP programs run also in a DOS command box in Windows, as well as in native MS-DOS
systems.

Solaris 8, 9, 10 on SPARC and x86

Download GCC from http://www.blastwave.org. It is the full compiler suite with the Ada
frontend included.

Build your own

If you want the latest features, including the experimental new Ada 2005 features, you will
need to build your own compiler.

Linux
For Linux users, there are instructions for building your own GNAT compiler at:
http://ada.krischik.com/index.php/Articles/CompileGNAT

You can also join the http://gnuada.sourceforge.net project.

Windows
Cygwin

A new Cygwin build is done just the same way the Linux build is done.

See also

16 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Wikibook
Ada Programming

Building
Ada programs are usually easier to build than programs written in other languages like C or
C++, which frequently require a makefile. This is because an Ada source file already
specifies the dependencies of its source unit. See the with keyword for further details.

Building an Ada program is not defined by the Reference Manual, so this process is
absolutely dependent on the compiler. Usually the compiler kit includes a make tool which
compiles a main program and all its dependencies, and links an executable file.

Building with various compilers

GNAT
With GNAT, you can run this command:

gnat make <your_unit_file>

If the file contains a procedure, gnatmake will generate an executable file with the
procedure as main program. Otherwise, e.g. a package, gnatmake will compile the unit and
all its dependencies.

GNAT commandline

gnatmake can be written as one word gnatmake or two words gnat make. For a full list of
gnat commands just type gnat without any further commandline option. The output will look
something like this:

GNAT 3.4.3 Copyright 1996-2004 Free Software Foundation, Inc.

List of available commands

GNAT BIND gnatbind
GNAT CHOP gnatchop
GNAT CLEAN gnatclean
GNAT COMPILE gnatmake -f -u -c
GNAT ELIM gnatelim
GNAT FIND gnatfind
GNAT KRUNCH gnatkr
GNAT LINK gnatlink
GNAT LIST gnatls
GNAT MAKE gnatmake
GNAT NAME gnatname
GNAT PREPROCESS gnatprep
GNAT PRETTY gnatpp
GNAT STUB gnatstub
GNAT XREF gnatxref

Commands FIND, LIST, PRETTY, STUB and XREF accept project file switches -vPx, -Pprj and -Xnam=val

For further help on the option just type the command (one word or two words - as you like)
without any further commandline option.

GNAT IDE

The GNAT toolchain comes with an IDE (Integrated Development Environment) called GPS (GNAT
Programming System). You need to download and install it separately. The GPS features a

17 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

graphical user interface.

There are also GNAT plugins for Emacs (Ada Mode (http://libre.adacore.com/adamode/) ) and
KDevelop available.

Rational APEX
Rational APEX is a complete development environment comprising a language sensitive
editor, compiler, debugger, coverage analyser, configuration management and much more.
You normally work with APEX running a GUI.

APEX has been built for the development of big programs. Therefore the basic entity of APEX
is a subsystem, a directory with certain traits recognized by APEX. All Ada compilation units
have to reside in subsystems.

You can define an export set, i.e. the set of Ada units visible to other subsystems. However
for a subsystem A to gain visibility to another subsystem B, A has to import B. After
importing, A sees all units in B's export set. (This is much like the with-clauses, but here
visibility means only potential visibility for Ada: units to be actually visible must be
mentioned in a with-clause of course; units not in the export set cannot be used in
with-clauses of Ada units in external subsystems.)

Normally subsystems should be hierarchically ordered, i.e. form a directed graph. But for
special uses, subsystems can also mutually import one another.

For configuration management, a subsystem is decomposed in views, subdirectories of the

subsystem. Views hold different development versions of the Ada units. So actually it's not
subsystems which import other subsystems, rather subsystem views import views of other
subsystems. (Of course, the closure of all imports must be consistent - it cannot be the case
that e.g. subsystem (A, view A1) imports subsytems (B, B1) and (C, C1), whereas (B, B1)
imports (C, C2)).

A view can be defined to be the development view. Other views then hold releases at
different stages.

Each Ada compilation unit has to reside in a file of its own. When compiling an Ada unit, the
compiler follows the with-clauses. If a unit is not found within the subsystem holding the
compilee, the compiler searches the import list (only the direct imports are considered, not
the closure).

Units can be taken under version control. In each subsystem, a set of histories can be
defined. An Ada unit can be taken under control in a history. If you want to edit it, you first
have to check it out - it gets a new version number. After the changes, you can check it in
again, i.e. make the changes permanent (or you abandon your changes, i.e. go back to the
previous version). You normally check out units in the development view only; check-outs in
release views can be forbidden.

You can select which version shall be the active one; normally it is the one latest checked in.
You can even switch histories to get different development paths. e.g. different bodies of the
same specification for different targets.

ObjectAda
ObjectAda is a set of tools for editing, compiling, navigating and debugging programs written
in Ada. There are various editions of ObjectAda. With some editions you compile programs
for the same platform and operating systems on which you run the tools. These are called
native. With others, you can produce programs for different operating systems and
platforms. One possible platform is the Java virtual machine.

These remarks apply to the native Microsoft Windows edition. You can run the translation

18 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

tools either from the IDE or from the command line.

Whether you prefer to work from the IDE, or from the command line, a little bookkeeping is
required. This is done by creating a project. Each project consists of a number of source files,
and a number of settings like search paths for additional Ada libraries and other
dependences. Each project also has at least one target. Typically, there is a debug target,
and a release target. The names of the targets indicate their purpose. At one time you
compile for debugging, typically during development, at other times you compile with
different settings, for example when the program is ready for release. Some (all
commercial?) editions of ObjectAda permit a Java (VM) target.

Macintosh OS X
Apple's free (gratis) IDE, XCode, is included with every Macintosh (but requires an explicit
installation step from DVD-ROM or CD-ROM) and is also downloadable from
http://developer.apple.com. XCode uses the GNU Compiler Collection and thus supports Ada,
GDB, etc., and also includes myriad tools for optimizing code which are unique to the
Macintosh platform. However, GNAT must be installed separately as it is (as of 2005) not
distributed as part of XCode. Get the binary and/or sources at http://www.macada.org/, along
with numerous tools and bindings including bindings to Apple's Carbon frameworks which
allow the development of complete, "real" Mac programs, all in Ada.

To be completed
You can help Wikibooks by adding the build information for other compilers. Click on the edit
link over this title.

Compiling our Demo Source

Once you have downloaded (https://sourceforge.net/project/showfiles.php?group_id=124904)
our example programs you might wonder how to compile them.

First you need to extract the sources. Use your favorite zip tool to achieve that. On extraction
a directory with the same name as the filename is created. Beware: WinZip might also create
a directory equaling the filename so Windows users need to be careful using the right option
otherwise they end up with wikibook-ada-1_2_0.src\wikibook-ada-1_2_0.

Once you extraced the files you will find all sources in wikibook-ada-1_2_0/Source. You could
compile them right there. For your convinience we also provide ready made project files for
the following IDEs (If you find a directory for an IDEs not named it might be in the making and not actualy
work).

GNAT
You will find multi-target GNAT Project files and a multi-make Makefile file in
wikibook-ada-2_0_0/GNAT. For i686 Linux and Windows you can compile any demo using:

gnat make -P project_file

you can also open them inside the GPS with

gps -P project_file

For other target platform it is a bit more difficult since you need to tell the project files which
target you want to create. The following options can be used:

style ("Debug", "Release")

19 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

you can define if you like a debug or release version so you can compare how the options
affect size and speed.
os ("Linux", "OS2", "Windows_NT", "VMS")
choose your operating system. Since there is no Ada 2005 available for OS/2 don't expect
all examples to compile.
target ("i686", "x86_64", "AXP")
choose your CPU - "i686" is any form of 32bit Intel or AMD CPU, "x86_64" is an 64 bit
Intel or AMD CPU and if you have an "AXP" then you know it.

Remember to type all options as they are shown. To compile a debug version on x86_64
Linux you type:

gnat make -P project_file -Xstyle=Debug -Xos=Linux -Xtarget=x86_64

As said in the beginning there is also a makefile available that will automatically dertermine
the target used. So if you have a GNU make you can save yourself a lot of typing by using:

make project

or even use

make all

to make all examples in debug and release in one go.

Each compile is stored inside it's own directory which is created in the form of
wikibook-ada-2_0_0/GNAT/OS-Target-Style. Emtpy directorys are provided inside the
archive.

Rational APEX
APEX uses the subsystem and view directory structure, so you will have to create those first
and copy the source files into the view. After creating a view using the architecture model of
your choice, use the menu option "Compile -> Maintenance -> Import Text Files". In the
Import Text Files dialog, add "wikibook-ada-2_0_0/Source/*.ad?" to select the Ada source
files from the directory you orignally extracted to. Apex uses the file extensions .1.ada for
specs and .2.ada for bodies -- don't worry, the import text files command will change these
automatically.

To link an example, select its main subprogram in the directory viewer and click the link
button in the toolbar, or "Compile -> Link" from the menu. Double-click the executable to run
it. You can use the shift-key modifier to bypass the link or run dialog.

ObjectAda
ObjectAda commandline

The following describes using the ObjectAda tools for Windows in a console window.

Before you can use the ObjectAda tools from the command line, make sure the PATH
enviroment variable lists the directory containing the ObjectAda tools. Something like

set path=%path%;P:\Programs\Aonix\ObjectAda\bin

A minimal ObjectAda project can have just one source file. like the Hello World program
provided in

20 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

File: hello_world_1.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/hello_world_1.adb?only_with_tag=HEAD&view=mar
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/hello_world_1.adb) ,
download page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

To build an executable from this source file, follow these steps (assuming the current
directory is a fresh one and contains the above mentioned source file):

1. Register your source files.

X:\some\directory> adareg hello_world_1.adb

This makes your sources known to the ObjectAda tools. Have a look at the file UNIT.MAP
created by adareg in the current directory if you like seeing what is happening under the
hood.

1. Compile the source file.

X:\some\directory> adacomp hello_world_1.adb

Front end of hello_world_1.adb succeeded with no errors.

1. Build the executable program.

X:\some\directory> adabuild hello_world_1

ObjectAda Professional Edition Version 7.2.2: adabuild
Copyright (c) 1997-2002 Aonix. All rights reserved.
Linking...
Link of hello completed successfully

Notice that you specify the name of the main unit as argument to adabuild, not the name of
the source file. In this case, it is Hello_World_1 as in

procedure Hello_World_1 is

More information about the tools can be found in the user guide Using the command line
interface, installed with the ObjectAda tools.

See also
GNAT Online Documentation
GNAT User's Guide (http://gcc.gnu.org/onlinedocs/gcc-4.0.1/gnat_ugn_unw/)

Wikibook
Ada Programming

Control
Conditionals
Conditional clauses are blocks of code that will only execute if a particular expression (the
condition) is true.

21 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

if-else
The if-else statement is the simplest of the conditional statements. They are also called
branches, as when the program arrives at an "if" statement during its execution, control will
"branch" off into one of two or more "directions". An if-else statement is generally in the
following form:

if condition then
statement;
else
other statement;
end if ;

If the original condition is met, then all the code within the first statement is executed. The
optional else section specifies an alternative statement that will be executed if the condition
is false. Exact syntax will vary between programming languages, but the majority of
programming languages (especially procedural and structured languages) will have some
form of if-else conditional statement built-in. The if-else statement can usually be extended to
the following form:

if condition then
statement;
elsif condition then
other statement;
elsif condition then
other statement;
...
else condition then
another statement;
end if;

Only one statement in the entire block will be executed. This statement will be the first one
with a condition which evaluates to be true. The concept of an if-else-if structure is easier to
understand with the aid of an example:

with Ada.Text_IO;
use Ada.Text_IO;
...
type Degrees is new Float range -273.15 .. Float'Last;
...
Temperature : Degrees;
...
if Temperature >= 40.0 then
Put_Line ("It's extremely hot");
elsif Temperature >= 30.0 then
Put_Line ("It's hot");
elsif Temperature >= 20.0 then
Put_Line ("It's warm");
elsif Temperature >= 10.0 then
Put_Line ("It's cool");
elsif Temperature >= 0.0 then
Put_Line ("It's cold");
else
Put_Line ("It's freezing");
end if;

Optimizing hints
When this program executes, the computer will check all conditions in order until one of
them matches its concept of truth. As soon as this occurs, the program will execute the
statement immediately following the condition and continue on, without checking any other
condition for truth. For this reason, when you are trying to optimize a program, it is a good
idea to sort your if-else conditions in descending probability. This will ensure that in the most
common scenarios, the computer has to do less work, as it will most likely only have to check
one or two "branches" before it finds the statement which it should execute. However, when
writing programs for the first time, try not to think about this too much lest you find yourself
undertaking premature optimization.

Having said all that, you should be aware that an optimizing compiler might rearrange your

22 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

if statement at will when the statement in question is free from side effects. Among other
techniques optimizing compilers might even apply jump tables and binary searches.

In Ada, conditional statements with more than one conditional do not use short-circuit
evaluation by default. In order to mimic C/C++'s short-circuit evaluation, use and then or or
else between the conditions.

case
Often it is necessary to compare one specific variable against several constant expressions.
For this kind of conditional expression the case statement exists. The above example is such
a case and could also be written like this:

case X is
when 1 =>

Walk_The_Dog;
when 5 =>

Launch_Nuke;

when 8 | 10 =>
Sell_All_Stock;

when others =>

Self_Destruct;

end case;

unconditionals
Unconditionals let you change the flow of your program without a condition. You should be
careful when using unconditionals. Often they make programs difficult to understand. Read
Isn't goto evil? for more information.

return
End a function and return to the calling procedure or function.

For procedures:

return;

For functions:

return Value;

goto
transfer control to the statement after the label.

goto Label;

Dont_Do_Something;
<<Label>>
...

Isn't goto evil?

One often hears that goto is evil and one should avoid using goto. But it is often overlooked

23 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

that any return, which is not the last statement inside a procedure or function, is also an
unconditional statement - a goto in disguise.

Therefore if you have functions and procedures with more than one return statement you
can just as well use goto. When it comes down to readability the following two samples are
almost the same:

procedure Use_Return is
begin
Do_Something;

if Test then
return;
end if;
Do_Something_Else;

return;
end Use_Return;

procedure Use_Goto is
begin
Do_Something;

if Test then
goto Exit_Use_Goto;
end if;
Do_Something_Else;

<<Exit_Use_Goto>>
return;
end Use_Goto;

Because the use of a goto needs the declaration of a label, the goto is in fact as twice as
readable than the use of return. So if readability is your concern and not a strict "don't use
goto" programming rule then you should rather use goto than multiple returns. Best, of
course, is the structured approach where neither goto nor multiple returns are needed:

procedure Use_If is
begin
Do_Something;

if not Test then

Do_Something_Else;

end if;
return;
end Use_If;

loops
Loops allow you to have a set of statements repeated over and over again.

endless loop
The endless loop is a loop which never ends and the statements inside are repeated forever.
Never is meant as a relative term here — if the computer is switched off then even endless
loops will end very abruptly.

Endless_Loop :
loop

Do_Something;

end loop Endless_Loop;

The loop name is an optional feature of Ada. Naming loops is nice for readability but not

24 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

strictly needed.

loop with condition at the beginning

This loop has a condition at the beginning. The statements are repeated as long as the
condition is met. If the condition is not met at the very beginning then the statements inside
the loop are never executed.

While_Loop :
while X <= 5 loop

X := Calculate_Something;
end loop While_Loop;

loop with condition at the end

This loop has a condition at the end and the statements are repeated until the condition is
met. Since the check is at the end the statements are at least executed once.

Until_Loop :
loop
X := Calculate_Something;

exit Until_Loop when X > 5;

end loop Until_Loop;

loop with condition in the middle

Sometimes you need to first make a calculation and exit the loop when a certain criterion is
met. However when the criterion is not met there is something else to be done. Hence you
need a loop where the exit condition is in the middle.

Exit_Loop :
loop
X := Calculate_Something;
exit Exit_Loop when X > 5;

Do_Something (X);
end loop Exit_Loop;

In Ada the exit condition can be combined with any other loop statement as well. You can
also have more then one exit statement. You can also exit a named outer loop if you have
several loops inside each other.

for loop
Quite often one needs a loop where a specific variable is counted from a given start value up
or down to a specific end value. You could use the while loop here - but since this is a very
common loop there is an easier syntax available.

For_Loop :
for I in Integer range 1 .. 10 loop

Do_Something (I)

end loop For_Loop;

You don't have to declare both type and range as seen in the example. If you leave out the
type then the compiler will determine the type by context and leave out the range then the
loop will iterate over every valid value for the type given.

25 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

As always with Ada: when "determine by context" gives two or more possible options then an
error will be displayed and then you have to name the type to be used. Ada will only do
"guess-works" when it is safe to do so.

for loop on arrays

Another very common situation is the need for a loop which iterates over every element of an
array. The following sample code shows you how to achieve this:

Array_Loop :
for I in X'Range loop

X (I) := Get_Next_Element;

end loop Array_Loop;

With X being an array. Note: This syntax is mostly used on arrays - hence the name - but will
also work with other types when a full iteration is needed.

Working Demo

The following Demo shows how to iterate over every element of an integer type.

File: range_1.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/range_1.adb?only_with_tag=HEAD&view=markup
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/range_1.adb) , download page
(https://sourceforge.net/project/showfiles.php?group_id=124904) )

with Ada.Text_IO;
procedure Range_1 is
type Range_Type is range -5 .. 10;
package T_IO renames Ada.Text_IO;
package I_IO is new Ada.Text_IO.Integer_IO (Range_Type);
begin
for A in Range_Type loop
I_IO.Put (Item => A,
Width => 3,
Base => 10);
if A < Range_Type'Last then
T_IO.Put (",");
else
T_IO.New_Line;
end if;
end loop;
end Range_1;

See also
Wikibook
Ada Programming

Ada Reference Manual

5.3 If Statements (http://www.adaic.com/standards/95lrm/html/RM-5-3.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-5-3.html) )
5.4 Case Statements (http://www.adaic.com/standards/95lrm/html/RM-5-4.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-5-4.html) )
5.5 Loop Statements (http://www.adaic.com/standards/95lrm/html/RM-5-5.html)
(Annotated (http://www.adaic.com/standards/95aarm/html/AA-5-5.html) )
5.6 Block Statements (http://www.adaic.com/standards/95lrm/html/RM-5-6.html)
(Annotated (http://www.adaic.com/standards/95aarm/html/AA-5-6.html) )
5.7 Exit Statements (http://www.adaic.com/standards/95lrm/html/RM-5-7.html) (Annotated

26 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

(http://www.adaic.com/standards/95aarm/html/AA-5-7.html) )
5.8 Goto Statements (http://www.adaic.com/standards/95lrm/html/RM-5-8.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-5-8.html) )
6.5 Return Statements (http://www.adaic.com/standards/95lrm/html/RM-6-5.html)
(Annotated (http://www.adaic.com/standards/95aarm/html/AA-6-5.html) )

Subtypes
This Page describes how to declare new types, how they are related to each other and how to
convert them. If you are looking for actual types available in Ada see Ada
Programming/Types.

Types in Ada
The Ada typing system is hierarchical like in some other languages. However Ada uses its
own vernacular when talking about type hierarchies.

What C++ calls sub- and supertypes, Ada calls child and parent (or ancestor) types. The
ultimate ancestor of some type is called the root type. Different types in a hierarchy are
incompatible, but may be converted into one another. Types in disjunct hierarchies cannot be
converted into one another.

The term supertype does not exist in Ada.

There is however another mechanism called subtyping. A subtype is not a new type but it
may add constraints to the type. Objects of different subtypes of a common type are
compatible; assignments between them force certain language defined checks to be
performed.

type T is ...;
subtype S is T [constraint];

The constraint is optional. To be exact: The type declaration declares a type and its first
subtype T. The type itself is anonymous and can be named with the Base attribute: T'Base. S
is a subtype of T.

Subtype categories
Ada supports various categories of subtypes which have different abilities. Here is an
overview in alphabetical order.

Anonymous subtype
A subtype which does not have a name assigned to it. Such a subtype is created with a
variable declaration:

X : String (1 .. 10) := (others => ' ');

Here, (1 .. 10) is the constraint. This variable declaration is equivalent to:

subtype Anonymous_String_Type is String (1 .. 10);

X : Anonymous_String_Type := (others => ' ');

27 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Base type
Within this document we almost always speak of subtypes. But where there is a subtype
there must also be a base type from which it is derived. In Ada all base types are anonymous
and only subtypes may be named.

But it is still possible to use base type by the use of the 'Base attribute.

Constrained subtype
A subtype of an indefinite subtype that does add a constraint. The following example defines
a 10 character string sub-type.

subtype String_10 is String (1 .. 10);

If all constraints of an original indefinite subtype are defined then the new sub-type is a
definite subtype.

Definite subtype
A definite subtype is a subtype whose size is known at compile-time. All subtypes which are
not indefinite subtypes are, by definition, definite subtypes.

Objects of definite subtypes may be declared without additional constraints.

Indefinite subtype
An indefinite subtype is a subtype whose size is not known at compile-time but is
dynamically calculated at run-time. An indefinite subtype does not by itself provide enough
information to create an object; an additional constraint or explicit initialization expression is
necessary in order to calculate the actual size and therefore create the object.

X : String := "This is a string";

X is an object of the indefinite (sub)type String. Its constraint is derived implicitly from its
initial value. X may change its value, but not its bounds.

It should be noted that it is not necessary to initialize the object from a literal. You can also
use a function. For example:

X : String := Ada.Command_Line.Argument (1);

This statement reads the first command-line argument and assigns it to X.

Named subtype
A subtype which has a name assigned to it. These subtypes are created with the keyword
type (remember that types are always anonymous, the name in a type declaration is the
name of the first subtype) or subtype. For example:

type Count_To_Ten is range 1 .. 10;

Count_to_Ten is the first subtype of a suitable integer base type. If you however would like to
use this as an index constraint on String, the following declaration is illegal:

28 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

subtype Ten_Characters is String (Count_to_Ten);

This is because String has Positive as index, which is a subtype of Integer (these declarations
are taken from package Standard):

subtype Positive is Integer range 1 .. Integer'Last;

type String is (Positive range <>) of Character;

So you have to use the following declarations:

subtype Count_To_Ten is Integer range 1 .. 10;

subtype Ten_Characters is String (Count_to_Ten);

Now Ten_Characters is the name of that subtype of String which is constrained to

Count_To_Ten. You see that posing constraints on types versus subtypes has very different
effects.

Unconstrained subtype
A subtype of an indefinite subtype that does not add a constraint only introduces a new name
for the original subtype.

subtype My_String is String;

My_String and String are interchangeable.

Type declaration
Declaring new types
New types are declared with the keyword type.

type Range_10 is range 1 .. 10;

You may also specify a parent type:

type Integer_10 is new Integer range 1 .. 10;

Both declarations create a new type hierarchy and name the first subtype.

Declaring subtypes
Subtypes are declared with the keyword subtype.

subtype Integer_10 is Integer range 1 .. 10;

Type vs. subtype

In the examples above we have two declarations of Integer_10. But which is right, which is
wrong? When to use " type Integer_10" when " subtype Integer_10"?

Unlike C/C++ Ada never converts types automatically. Even if converting them would be
safe. The following example won't work:

29 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

type Integer_1 is new Integer range 1 .. 10;

type Integer_2 is new Integer range 1 .. 10;

X1 : Integer_1 := 5;
X2 : Integer_2 := X1;

See Checked Conversion if you want to know how to convert types.

This is different for subtypes. All the subtypes sharing the same base type don't actually need
to be converted when interchanged. The above example with subtypes will work fine (base
type is Integer):

subtype Integer_1 is Integer range 1 .. 10;

subtype Integer_2 is Integer range 1 .. 10;

X1 : Integer_1 := 5;
X2 : Integer_2 := X1;

Converting subtypes
Sometimes however it may be necessary to explicitly convert subtypes.

subtype My_String is String range 21 .. 35;

X1 : String := "Ada is my name."; -- bounds 1 .. 15

My_String (X1) -- bounds 21 .. 35

The conversion result My_String (X1) now has the same contents as X1, but different bounds.
Note that the equality operation does not compare the bounds, only the contents. Thus:

B : Boolean := (X1 = My_String (X1)); -- True

Converting data
Data does not always come in the format you need them and you face the task of converting
them. Ada as a true multi-purpose language with a special emphasis on "mission critical",
"system programming" and "safety" has several converting techniques.

This is a short pragmatic overview of data conversions. The examples are all numeric, but
there are conversions for most kinds of data types. As the most difficult part is choosing the
right type of conversion, I have sorted them so that you should try the first one first; the last
technique is "the last resort if all other fails". Also added are few related techniques which
you might choose instead of actually converting the data.

Since the most important aspect is not the result of a successful conversion, but how the
system will react to an invalid conversion, all examples also demonstrate faulty conversions.

Evaluate as
This is not really a conversion. It only tells the compiler how a given expression should be
evaluated, most important in case of overloading resolution problems.

The Syntax is:

Type_Name'(Expression)

This means that the expression has to be evaluated as having the given type.

Imagine you have two enumeration types directly visible with homographic literals, like so:

30 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

type Enum_1 is (A, B, C);

type Enum_2 is (A, X, Y, Z);

then

Enum_1'(A)

tells the compiler that you mean that A which is of type Enum_1. Normally you would not
need this kind of qualified expression; overload resolution does this for you. But there are
cases where this syntax is required.

As seen in the following example, this syntax if often used when creating new objects. If you
try to compile the example, it will fail with a compilation error since the compiler will
determine that 256 is not in range of Byte.

File: convert_interpret_as.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/convert_interpret_as.adb?only_with_tag=HEAD&vie
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/convert_interpret_as.adb) ,
download page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

with Ada.Text_IO;

procedure Convert_Evaluate_As is
type Byte is mod 2**8;
type Byte_Ptr is access Byte;

package T_IO renames Ada.Text_IO;

package M_IO is new Ada.Text_IO.Modular_IO (Byte);

A : constant Byte_Ptr := new Byte'(256);

begin
T_IO.Put ("A = ");
M_IO.Put (Item => A.all,
Width => 5,
Base => 10);
end Convert_Evaluate_As;

Rename view
This technique too, is not really a conversion but just creates a different view to your data. It
is used in object oriented programming and only available to classes - called tagged types in
Ada.

type Parent_Type is tagged null record;

type Child_Type is new Parent_Type with null record;

Child_Instance : Child_Type;
Parent_View : Parent_Type'Class renames Parent_Type'Class (Child_Instance);

Renaming the view of a tagged type creates no code and no data is copied, it only gives a
new name to something which already exists. Performance is optimal since the rename is
completely done at compile time.

Checked conversion
The checked conversion is in syntax rather similar to the "evaluate as". It does not use the '
(called tick) and thus looks much like a function call.

Type_Name (Expression)

As the chapter heading suggests, the conversion is checked at runtime and if it is invalid, a
CONSTRAINT_ERROR exception will be raised. The data also need to be convertible.

31 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

I: Integer := Integer (10); -- Unnecessary explicit type conversion

J: Integer := 10; -- Implicit conversion from universal integer
K: Integer := Integer'(10); -- Use the value 10 of type Integer
-- (qualification not necessary here).

The following example shows the conversion of two integer types. When you compile the
example with GNAT, you will get several warnings. In our case, the compiler determines that
the runtime check will always fail and warns us about that.

Remember: Since the optimizer checks for the necessity of runtime checks and removes
them if they are not needed, you should normally not worry about the performance
implications of checked conversions.

File: convert_checked.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/convert_checked.adb?only_with_tag=HEAD&view=m
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/convert_checked.adb) ,
download page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

with Ada.Text_IO;

procedure Convert_Checked is
type Short is range -128 .. +127;
type Byte is mod 256;

package T_IO renames Ada.Text_IO;

package I_IO is new Ada.Text_IO.Integer_IO (Short);
package M_IO is new Ada.Text_IO.Modular_IO (Byte);
A : Short := -1;
B : Byte;
begin
B := Byte (A);
T_IO.Put ("A = ");
I_IO.Put (Item => A,
Width => 5,
Base => 10);
T_IO.Put (", B = ");
M_IO.Put (Item => B,
Width => 5,
Base => 10);
end Convert_Checked;

In object-oriented programming

Within object-oriented programming you have to distinguish between specific types and
class-wide types.

With specific types, only conversions to ancestors are possible and, of course, are checked.
There are no conversions to derived, i.e. child types (where would you get the further components
from?); extension aggregates have to be used instead.

type Parent_Type is tagged null record;

type Child_Type is new Parent_Type with null record;

Child_Instance : Child_Type;
Parent_Instance : Parent_Type := Parent_Type (Child_Instance);

With class wide types, conversions to ancestor and child types are possible and are checked
as well. These conversions are only view conversions.

type Parent_Type is tagged null record;

type Child_Type is new Parent_Type with null record;
Child_Instance : Child_Type;
Parent_View : Parent_Type'Class := Parent_Type'Class (Child_Instance);
Child_View : Child_Type'Class := Child_Type'Class (Parent_View);

Before consider a view conversion on a class-wide type you should check if a view rename is

32 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

not more appropiate.

Address conversion
Ada's access type is not just a memory location (a thin pointer). Depending on
implementation and the access type used, the access might keep additional information (a fat
pointer). For example Gnat keeps two memory addresses for each access to an indefinite
object - one for the data and one for the constraint informations (Size, First, Last).

If you want to convert an access to a simple memory location you can use the package
System.Address_To_Access_Conversions. Note however that an address and a fat pointer
cannot be converted reversibly into one another.

The address of an array object is the address of its first component. Thus the bounds get lost
in such a conversion.

type My_Array is array (Positive range <>) of Something;

A: My_Array (50 .. 100);

A'Address = A(A'First)'Address

Unchecked conversion
One of the great criticisms of Pascal was "there is no escape". The reason was that
sometimes you have to convert the incompatible. For this purpose, Ada has the generic
function Unchecked_Conversion:

generic
type Source (<>) is limited private;
type Target (<>) is limited private;
function Ada.Unchecked_Conversion (S : Source) return Target;

Unchecked_Conversion will bit-copy the data and there are absolutely no checks. It is your
chore to make sure that the requirements on unchecked conversion as stated in RM 13.9
(http://www.adaic.com/standards/95lrm/html/RM-13-9.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-13-9.html) ) are fulfilled; if not, the result is
implementation dependent and may even lead to abnormal data.

A function call to an (instance) will copy the source to the destination. The compiler may also
do a conversion in place (every instance has the convention Intrinsic).

To use Unchecked_Conversion you need to instantiate the generic.

In the example below, you can see how this is done. When run, the example it will output "A
= -1, B = 255". No error will be reported, but is this the result you expect?

File: convert_unchecked.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/convert_unchecked.adb?only_with_tag=HEAD&view
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/convert_unchecked.adb) ,
download page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

33 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

with Ada.Text_IO;
with Ada.Unchecked_Conversion;

procedure Convert_Unchecked is

type Short is range -128 .. +127;

type Byte is mod 256;

package T_IO renames Ada.Text_IO;

package I_IO is new Ada.Text_IO.Integer_IO (Short);
package M_IO is new Ada.Text_IO.Modular_IO (Byte);

function Convert is new Ada.Unchecked_Conversion (Source => Short,

Target => Byte);

A : constant Short := -1;

B : Byte;

begin

B := Convert (A);
T_IO.Put ("A = ");
I_IO.Put (Item => A,
Width => 5,
Base => 10);
T_IO.Put (", B = ");
M_IO.Put (Item => B,
Width => 5,
Base => 10);

end Convert_Unchecked;

Overlays
If the copying of the result of Unchecked_Conversion is too much waste in terms of
performance, then you can try overlays, i.e. address mappings. By using overlays, both
objects share the same memory location. If you assign a value to one, the other changes as
well. The syntax is:

for Target'Address use expression;

pragma Import (Ada, Target);

where expression defines the address of the source object.

While overlays might look more elegant than Unchecked_Conversion, you should be aware
that they are even more dangerous and have even greater potential for doing something very
wrong. For example if Source'Size < Target'Size and you assign a value to Target, you
might inadvertently write into memory allocated to a different object.

You have to take care also of implicit initialisations of objects of the target type, since they
would overwrite the actual value of the source object. The Import pragma with convention
Ada can be used to prevent this, since it avoids the implicit initialisation, RM B.1
(http://www.adaic.com/standards/95lrm/html/RM-B-1.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-B-1.html) ).

The example below does the same as the example from "Unchecked Conversion".

File: convert_address_mapping.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/convert_address_mapping.adb?only_with_tag=HEAD
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/convert_address_mapping.adb)
, download page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

34 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

with Ada.Text_IO;

procedure Convert_Address_Mapping is
type Short is range -128 .. +127;
type Byte is mod 256;

package T_IO renames Ada.Text_IO;

package I_IO is new Ada.Text_IO.Integer_IO (Short);
package M_IO is new Ada.Text_IO.Modular_IO (Byte);
A : aliased Short;
B : aliased Byte;
for B'Address use A'Address;
pragma Import (Ada, B);
begin
A := -1;
T_IO.Put ("A = ");
I_IO.Put (Item => A,
Width => 5,
Base => 10);
T_IO.Put (", B = ");
M_IO.Put (Item => B,
Width => 5,
Base => 10);
end Convert_Address_Mapping;

See also
Wikibook
Ada Programming

Ada Reference Manual

3.2.1 Type Declarations (http://www.adaic.com/standards/95lrm/html/RM-3-2-1.html)
(Annotated (http://www.adaic.com/standards/95aarm/html/AA-3-2-1.html) )
3.3 Objects and Named Numbers
(http://www.adaic.com/standards/95lrm/html/RM-3-3.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-3-3.html) )
3.7 Discriminants (http://www.adaic.com/standards/95lrm/html/RM-3-7.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-3-7.html) )
3.10 Access Types (http://www.adaic.com/standards/95lrm/html/RM-3-10.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-3-10.html) )
4.9 Static Expressions and Static Subtypes
(http://www.adaic.com/standards/95lrm/html/RM-4-9.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-4-9.html) )
13.9 Unchecked Type Conversions
(http://www.adaic.com/standards/95lrm/html/RM-13-9.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-13-9.html) )
13.3 Operational and Representation Attributes
(http://www.adaic.com/standards/95lrm/html/RM-13-3.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-13-3.html) )
Annex K (informative) Language-Defined Attributes
(http://www.adaic.com/standards/95lrm/html/RM-K.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-K.html) )

Types
This page describes the various types available in Ada. If you want to know how to declare
new types, how they relate to each other and how to convert them see Ada
Programming/Subtypes

Types in Ada

35 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

If you look at Ada's list of keywords, you will notice that there is no int or INTEGER like for
example with C/C++.

Ada has only a very small set of predefined types, rather new types are defined according to
domain specific needs. Thus Ada is more like PL/I where data types are described in terms of
what is needed and not chosen from a predefined set.

Unlike PL/I, the description of a data type is not done "low level" in terms of bits but "high
level" using human readable values. If a low level specification is needed as well, optional
representation clauses can be used.

Example:

type Day_Of_Month is range 1 .. 31;

for Day_Of_Month'Size use 8;

The two statements in detail:

1. The type is defined as a range of whole numbers with lower bound 1 and upper bound
31. No values outside this range can be assigned to objects of this type. The type is also
given the name "Day_Of_Month".
2. Representation clause: use 8 bit of storage. If Size is not specified then the compiler will
choose a suitable size.

You should not specify representation clauses if there is no pressing need (like e.g.
interfacing to external devices). The more freedom the compiler has, the better code can be
generated.

Strong typing
Objects of different types in Ada are incompatible, i.e. may not be assigned or mixed, even if
they have matching value ranges.

type My_Integer is range -10 .. 10;

type Your_Integer is range -10 .. 10;
type His_Integer is new Your_Integer;
M: My_Integer;
Y: Your_Integer;
H: His_Integer;
M := Y; -- illegal
H := Y; -- illegal

This prevents inadvertent mixing of apples and oranges. If you really need to combine
objects of different types, you have to use type conversions.

Should you need many type conversions, i.e. if Ada's strong typing gets into your way, this
generally is an indication of bad program design. Consider using subtype instead.

Type classification

36 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Ada type hierarchy

In the predefined package Standard, the most basic types are defined. As stated before, you
normally do not use those types, rather define your own ones. This is the set of type classes
you have at your convenience. Do follow the links to get more information.

Signed Integers (int, INTEGER)

Signed Integers are called range in Ada.
Unsigned Integers (unsigned, CARDINAL)
Unsigned Integers are called Modular Types. Apart from being unsigned they also have
wrap-around functionality.
Enumerations (enum, char, bool, BOOLEAN)
Ada Enumeration types are a separate type family.
Floating point (float, double, REAL)
Floating point values are defined by the digits needed.
Binary and Decimal Fixed Point (DECIMAL)
Fixed point type are defined by their delta.
Arrays ([], ARRAY [] OF, STRING)
Arrays with compile-time determined and run-time determined size are supported.
Records (struct, class, union, RECORD)
Ada uses records for compound types and classes.
Access (*, ^, POINTER TO)
Ada's Access types may be more than just a simple memory address.

Predefined types
Are you missing specific types?

These types are predefined in the Standard package:

Integer
This type covers at least the range -2**15+1 .. +2**15-1 (RM 3.5.4 (21)
(http://www.adaic.com/standards/95lrm/html/RM-3-5-4.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-3-5-4.html) )).
Float
There is only a very weak implementation requirement on this type (RM 3.5.7 (14)
(http://www.adaic.com/standards/95lrm/html/RM-3-5-7.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-3-5-7.html) )).
Character
In Ada, characters are a special form of Enumerations. There are two predefined kinds of
character types: 8-bit characters (called Character) and 16-bit characters (called
Wide_Character). In Ada 2005, a 32-bit character type called Wide_Wide_Character will
be added. You can also specify your own character types.
String

37 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

In Ada, strings are a special form of Arrays, namely arrays of characters. Since there are
two kinds of characters, there are also two kinds of strings: String is an array of
Character, Wide_String is an array of Wide_Character. For ease of treatment of strings,
there are special packages in three variants, one for handling fixed length strings:
Ada.Strings.Fixed; one for strings with varying lengths below a certain upper bound:
Ada.Strings.Bounded; and one for strings of unbounded lengths: Ada.Strings.Unbounded
(for the wide kinds, prefix each name with Wide_ or Wide_Wide_).
Boolean
A Boolean in Ada is an Enumeration of False and True.

See also
Wikibook
Ada Programming
Ada Programming/Subtypes
Programming:Types, general concepts about types in programming

Ada Reference Manual

Section 3: Declarations and Types
(http://www.adaic.com/standards/95lrm/html/RM-3.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-3.html) )

Integer types
A range is an integer value which ranges from a First to a last Last. It is defined as

range First .. Last

When a value is assigned to a range it is checked for vality and an exceptions is raised when
the value is not within First to Last.

Working demo
The following Demo defines a new range from -5 to 10 and then prints the whole range out.

File: range_1.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/range_1.adb?only_with_tag=HEAD&view=markup
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/range_1.adb) , download page
(https://sourceforge.net/project/showfiles.php?group_id=124904) )

38 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

with Ada.Text_IO;

procedure Range_1 is
type Range_Type is range -5 .. 10;

package T_IO renames Ada.Text_IO;

package I_IO is new Ada.Text_IO.Integer_IO (Range_Type);

begin
for A in Range_Type loop
I_IO.Put (
Item => A,
Width => 3,
Base => 10);

if A < Range_Type'Last then

T_IO.Put (",");
else
T_IO.New_Line;
end if;
end loop;
end Range_1;

See also
Wikibook
Ada Programming
Ada Programming/Types
Ada Programming/Keywords/range

Ada Reference Manual

4.4 Expressions (http://www.adaic.com/standards/95lrm/html/RM-4-4.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-4-4.html) )
3.5.4 Integer Types (http://www.adaic.com/standards/95lrm/html/RM-3-5-4.html)
(Annotated (http://www.adaic.com/standards/95aarm/html/AA-3-5-4.html) )

Unsigned integer types

A mod is an unsigned integer value which ranges from 0 to a Last value. It is defined as

mod Modulus

Where Last is Modulus - 1; The mod type has a wrap around functionality so that
and

You can use range to sub-range a modular type:

type Byte is mod 256;

subtype Half_Byte is Byte range 0 .. 127;

But beware: the Modulus of Half_Byte is still 256! Arithmetic with such a type is interesting
to say the least.

See also
Wikibook
Ada Programming
Ada Programming/Types
Ada Programming/Keywords/mod

39 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Ada Reference Manual

4.4 Expressions (http://www.adaic.com/standards/95lrm/html/RM-4-4.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-4-4.html) )
3.5.4 Integer Types (http://www.adaic.com/standards/95lrm/html/RM-3-5-4.html)
(Annotated (http://www.adaic.com/standards/95aarm/html/AA-3-5-4.html) )

Enumerations
An enumeration type is defined as a list of possible values:

type Primary_Color is (Red, Green, Blue);

Like for numeric types, where e.g. 1 is an integer literal, Red, Green and Blue are called the
literals of this type. There are no other values assignable to objects of this type.

Operators and attributes

Apart from equality ("="), the only operators on enumeration types are the ordering
operators: "<", "<=", "=", "/=", ">=", ">", where the order relation is given implicitly by the
sequence of literals: Each literal has a position, starting with 0 for the first, incremented by
one for each successor. This position can be queried via the 'Pos attribute; the inverse is 'Val,
which returns the corresponding literal. In our example:

Primary_Color'Pos (Red) = 0
Primary_Color'Val (0) = Red

There are two other important attributes: Image and Value (don't confuse Val with Value).
Image returns the string representation of the value (in capital letters), Value is the inverse:

Primary_Color'Image ( Red ) = "RED"

Primary_Color'Value ("Red") = Red

These attributes are important for simple IO (there are more elaborate IO facilities in
Ada.Text_IO for enumeration types). Note that, since Ada is case-insensitive, the string given
to 'Value can be in any case.

Enumeration literals
Literals are overloadable, i.e. you can have another type with the same literals.

type Traffic_Light is (Red, Yellow, Green);

Overload resolution within the context of use of a literal normally resolves which Red is
meant. Only if you have an unresolvable overloading conflict, you can qualify with special
syntax which Red is meant:

Primary_Color'(Red)

Like many other declarative items, enumeration literals can be renamed. In fact, such a
literal is a actually function, so it has to be renamed as such:

40 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

function Red return P.Primary_Color renames P.Red;

Here, Primary_Color is assumed to be defined in package P, which is visible at the place of

the renaming declaration. Renaming makes Red directly visible without necessity to resort
the use-clause.

Note that redeclaration as a function does not affect the staticness of the literal.

Characters as enumeration literals

Rather unique to Ada is the use of character literals as enumeration literals:

type ABC is ('A', 'B', 'C');

This literal 'A' has nothing in common with the literal 'A' of the predefined type Character
(or Wide_Character).

Every type that has at least one character literal is a character type. For every character
type, string literals and the concatenation operator "&" are also implicitly defined.

type My_Character is (No_Character, 'a', Literal, 'z');

type My_String is array (Positive range <>) of My_Character;
S: My_String := "aa" & Literal & "za" & 'z';
T: My_String := ('a', 'a', Literal, 'z', 'a', 'z');

In this example, S and T have the same value.

Ada's Character type is defined that way. See Ada Programming/Libraries/Standard.

Enumeration subtypes
You can use range to subtype an enumeration type:

subtype Capital_Letter is Character range 'A' .. 'Z';

See also
Wikibook
Ada Programming
Ada Programming/Types
Ada Programming/Libraries/Standard

Ada Reference Manual

3.5.1 Enumeration Types (http://www.adaic.com/standards/95lrm/html/RM-3-5-1.html)
(Annotated (http://www.adaic.com/standards/95aarm/html/AA-3-5-1.html) )

Floating point types

Description

41 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

To define a floating point type you only have to say how many digits are needed:

digits Num_Digits

If you like you can declare the minimum range needed as well:

digits Num_Digits range Low .. High

This facility is a great benefit of Ada over (most) other programming languages. In other
languages, you just choose between "float" and "long float", and what most people do is:

choose float if they don't care about accuracy

otherwise, choose long float, because it is the best you can get

In either case, you don't know what accuracy you get.

In Ada, you specify the accuracy you need, and the compiler will choose an appropriate
floating point type with at least the accuracy you asked for. This way, your requirement is
guaranteed. Moreover, if the computer has more than two floating point types available, the
compiler can make use of all of them.

See also
Wikibook
Ada Programming
Ada Programming/Types
Ada Programming/Types/range
Ada Programming/Types/delta
Ada Programming/Keywords/digits

Ada Reference Manual

3.5.7 Floating Point Types (http://www.adaic.com/standards/95lrm/html/RM-3-5-7.html)
(Annotated (http://www.adaic.com/standards/95aarm/html/AA-3-5-7.html) )

Fixed point types

Description
A fixed point type defines a set of values that are evenly spaced according to the fixed point
type's "delta" value. In contrast, floating point values are all spaced according to powers of
two. When you want to represent a real number with a floating point type, the number
actually stored will vary. When you represent a number as a fixed point type, you can be sure
that the number stored will be accurate within the bounds specified by the delta.

For example, if you define a fixed point type with a delta of 0.1, you will be able to accurately
store the values 0.1, 1.0, 2.2, 5.7, etc. You will not be able to accurately store the value 0.01.
Instead, the value will be rounded down to 0.0.

If the compiler accepts your fixed point type definition, it guarantees that values represented
by that type will have at least the degree of accuracy specified (or greater). If the compiler
can not support the type definition (e.g. due to limited hardware) then a compile-time error
will result.

42 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Binary fixed point

For a binary fixed point you just define the delta with a range:

delta Delta range Low .. High

The delta can be any real value -- for example you may define a circle with one arcsecond
resolution with:

delta 1 / (60 * 60) range 0.0 .. 360.0

There is one rather strange rule about fixed and floating point variables: Because of the way
they are internally represented the range might only go up to 'Last - Delta. This is a bit
like a circle -- there 0° and 360° is also the same.

Decimal fixed point

You define a decimal fixed point by defining the delta and the number of digits needed:

delta Delta digits Num_Digits

Delta needs to be a positive or negative power of 10 - otherwise the type will not be a
decimal fixed point.

delta 10 ** +2 digits 12
delta 10 ** -2 digits 12

If you like you can also define the minimum range needed:

delta Delta_Value digits Num_Digits range Low .. High

See also
Wikibook
Ada Programming
Ada Programming/Types
Ada Programming/Types/range
Ada Programming/Types/digits
Ada Programming/Keywords/delta

Ada 95 Reference Manual

3.5.9 Fixed Point Types (http://www.adaic.com/standards/95lrm/html/RM-3-5-9.html)
(Annotated (http://www.adaic.com/standards/95aarm/html/AA-3-5-9.html) )

Ada 2005 Reference Manual

3.5.9 Fixed Point Types (http://www.adaic.com/standards/rm-amend/html/RM-3-5-9.html)
(Annotated (http://www.adaic.com/standards/rm-amend/html/AA-3-5-9.html) )

Arrays

43 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

An array is a collection of elements which can be accessed by an index. In Ada any definite
type is allowed as element and any discrete type, i.e. Range, Modular or Enumeration, can be
used as an index.

Declaring arrays
Ada's arrays are quite powerful and so there are quite a few syntax variations, which are
presented below.

Basic syntax
The basic form of an Ada array is:

array (Index_Range) of Element_Type

where Index_Range is a range of values within a discrete index type, and Element_Type is a
definite subtype. The array consists of one element of "Element_Type" for each possible
value in the given range. If you for example want to count how often a specific letter appears
inside a text, you could use:

type Character_Counter is array (Character) of Natural;

Do not use Integer as the element type, since negative occurrences do not seem sensible.

With known subrange

Often you don't need an array of all possible values of the index type. In this case you can
subtype your index type to the actually needed range.

subtype Index_Sub_Type is Index_Type range First .. Last

array (Index_Sub_Type) of Element_Type

Since this may involve a lot of typing and you may also run out of useful names for new
subtypes, the array declaration allows for a shortcut:

array (Index_Type range First .. Last) of Element_Type

Since First and Last are expressions of Index_Type, a simpler form of the above is:

array (First .. Last) of Element_Type

Note that if First and Last are numeric literals, this implies the index type Integer.

If in the example above the character counter should only count upper case characters and
discard all other characters, you can use the following array type:

type Character_Counter is array (Character range 'A' .. 'Z') of Natural;

With unknown subrange

Sometimes the range actually needed is not known until runtime or you need objects of
different lengths. In lower level languages like C, you would now have to resort to heap
memory. Not with Ada. Here we have the box '<>', which allows us to declare indefinite

44 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

arrays:

array (Index_Type range <>) of Element_Type

When you declare objects of such a type, the bounds must of course be given and the object
is constrained to them.

The predefined type String is such a type. It is defined as

type String is array (Positive range <>) of Character;

You define objects of such an unconstrained type in several ways (the extrapolation to other
arrays than String should be obvious):

Text : String (10 .. 20);

Input: String := Read_from_some_file;

(These declaration additionally define anonymous subtypes of String.) In the first example,
the range of indices is explicitly given. In the second example, the range is implicitly defined
from the initial expression, which here could be via a function reading data from some file.
Both objects are constrained to their ranges, i.e. they cannot grow nor shrink.

With aliased elements

If you come from C/C++, you are probably used to the fact that every element of an array
has an address. The C/C++ standards actually demands that.

In Ada, this is not true. Consider the following array:

type Day_Of_Month is range 1 .. 31;

type Day_Has_Appointment is array (Day_Of_Month) of Boolean;
pragma Pack (Day_Has_Appointment);

Since we have packed the array, the compiler will use as little storage as possible. And in
most cases this will mean that 8 boolean values will fit into one byte.

So Ada knows about arrays where more then one element shares one address. So what if you
need to address each single element. Just not using pragma Pack is not enough. If the CPU
has very fast bit access, the compiler might pack the array without being told. You need to
tell the compiler that you need to address each element via an access.

type Day_Of_Month is range 1 .. 31;

type Day_Has_Appointment is array (Day_Of_Month) of aliased Boolean;

Using arrays
When accessing to elements the index is specified between parenthesis. It is also possible to
access slices in this way:

Vector_A (1 .. 3) := Vector_B (3 .. 5);

The operator "&" can be used to concatenate arrays:

Name := First_Name & ' ' & Last_Name;

45 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

In both cases, if the resulting array does not fit in the destination array, Constraint_Error is
raised.

If you try to access an existing element by indexing outside the array bounds,
Constraint_Error is raised (unless checks are suppressed).

See also
Wikibook
Ada Programming
Ada Programming/Types
Programming:Data_Structures
Programming:Data_Structures:Arrays

Ada Reference Manual

3.6 Array Types (http://www.adaic.com/standards/95lrm/html/RM-3-6.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-3-6.html) )

Ada Quality and Style Guide

10.5.7 Packed Boolean Array Shifts
(http://www.adaic.org/docs/95style/html/sec_10/10-5-7.html)

Records
A record is a composite type that groups one or more fields. A field can be of any type, even
a record.

Basic record
type Basic_Record is
record
A : Integer;
end record;

Null record
The null record is when a type without data is needed. There are two ways to declare a null
record:

type Null_Record is
record
null;
end record;

type Null_Record is null record;

For the compiler they are the same. However, programmers often use the first variant if the
type is not finished yet to show that they are planning to expand the type later, or they
usually use the second if the (tagged) record is a base class in object oriented programming.

Discriminated record

46 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

type Discriminated_Record (Size : Natural) is

record
A : String (1 .. Size);
end record;

Variant record
The variant record is a special type of discriminated record where the presence of some
components depend on the value of the discriminant.

type Traffic_Light is (Red, Yellow, Green);

type Variant_Record (Option : Traffic_Light) is

record
-- common components

case Option is
when Red =>
-- components for red
when Yellow =>
-- components for yellow
when Green =>
-- components for green
end case;
end record;

Union
This language feature will be made available in the forthcoming Ada 2005 standard.

type Traffic_Light is (Red, Yellow, Green);

type Union (Option : Traffic_Light := Traffic_Light'First) is
record
-- common components

case Option is
when Red =>
-- components for red
when Yellow =>
-- components for yellow
when Green =>
-- components for green
end case;
end record;

pragma Unchecked_Union (Union);

pragma Convention (C, Union); -- optional

The difference to a variant record is such that Option is not actually stored inside the record
and never checked for correctness - it's just a dummy.

This kind of records are usually used for interfacing with C but can be used for other
purposes as well (then without pragma Convention (C, Union);).

Tagged record
The tagged record is one part of what in other languages is called a class. It is the basic
foundation of object orientated programming in Ada. The other two parts a class in Ada
needs is a package and primitive operations.

type Person is tagged

record
Name : String (1 .. 10);
Gender : Gender_Type;
end record;

47 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

type Programmer is new Person with

record
Skilled_In : Language_List;
end record;

Ada 2005 only:

type Programmer is new Person

and Printable
with
record
Skilled_In : Language_List;
end record;

Abstract tagged record

An abstract type has at least an abstract primitive operation, i.e. one of its operations is not
defined and then its derivative types has to provide an implementation.

With aliased elements

If you come from C/C++, you are probably used to the fact that every element of a record -
which is not part of a bitset - has an address. In Ada, this is not true because records, just
like arrays, can be packed. And just like arrays you can use aliased to ensure that an
element can be accessed via an access type.

type Basic_Record is
record
A : aliased Integer;
end record ;

Please note: each element needs its own aliased.

See also
Wikibook
Ada Programming
Ada Programming/Types
Ada Programming/Keywords/record
Ada Programming/Keywords/null
Ada Programming/Keywords/abstract
Ada Programming/Keywords/case
Ada Programming/Keywords/when
Ada Programming/Pragmas/Unchecked_Union

Ada Reference Manual

Ada 95

3.8 Record Types (http://www.adaic.com/standards/95lrm/html/RM-3-8.html) (Annotated

(http://www.adaic.com/standards/95aarm/html/AA-3-8.html) )

Ada 2005

3.8 Record Types (http://www.adaic.com/standards/rm-amend/html/RM-3-8.html)

(Annotated (http://www.adaic.com/standards/rm-amend/html/AA-3-8.html) )
Annex B.3.3 Pragma Unchecked_Union
(http://www.adaic.com/standards/rm-amend/html/RM-B-3-3.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-B-3-3.html) )

48 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Ada Issues

AI-00216 Unchecked unions -- variant records with no run-time discriminant

(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00216.TXT)

Access types

Different access types

Pool access
Handles an access to an object which was created on one specific heap (or storage pool as it
is called in Ada). May not point to a stack or library level (static) object or an object of an
different storage pool.

type Day_Of_Month is range 1 .. 31;

type Day_Of_Month_Access is access Day_Of_Month;

Remember that Ada support user defined storage pools. You can defined the storage pool
used with

for Day_Of_Month_Access'Storage use Pool_Name;

Access all
Handles an access to an object which was created on any storage pool, on the stack or at
library level (static).

type Day_Of_Month is range 1 .. 31;

type Day_Of_Month_Access is access all Day_Of_Month;

Access constant
Handles an access either to a constant or variable object which was created on any storage
pool, on the stack or at library level (static), but with a restriction to read-only usage of the
referenced object, whether it be intrinsically a constant or a variable.

type Day_Of_Month is range 1 .. 31;

type Day_Of_Month_Access is access constant Day_Of_Month;

Anonymous access
An anonymous access is used as a parameter to a function, procedure or a discriminated
type. Here some examples:

procedure Test (Some_Day : access Day_Of_Month);

task type Thread (

Execute_For_Day : access Day_Of_Month)
is
-- ...In Ada 2005 a
end Thread;

49 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

type Day_Data (
Store_For_Day : access Day_Of_Month)
is record
-- components
end record;

Before you use an anonymous access you should consider if the "out" or "in out" modifier is
not more appropriate - see access performance to see why.

This language feature will be made available in the forthcoming Ada 2005 standard.

In Ada 2005 an anonymous access will also be allowed as part of a record:

type Object is record

M : Integer;
Next : access Object;
end record;

Not null access

This language feature will be made available in the forthcoming Ada 2005 standard.

All access types can be modified with "not null":

type Day_Of_Month_Access is not null access Day_Of_Month;

The type must then always point to an object, so initializations are compulsory.

Constant anonymous access

This language feature will be made available in the forthcoming Ada 2005 standard.

An anonymous access to a constant object.

procedure Test (Some_Day : access constant Day_Of_Month);

Access to subprogram
An access to subprogram allows us to call a subprogram without knowing its name nor its
declaration location. One of the uses of this kind of access is the well known callbacks.

type Callback_Procedure
is access procedure (
Id : Integer;
Text : String);

type Callback_Function
is access function (
The_Alarm : in Alarm)
return
Natural;

For getting an access to a subprogram the attribute Access is applied to a subprogram name
with the proper prototype.

procedure Process_Event (
Id : Integer;
Text : String);

My_Callback : Callback_Procedure := ProcessEvent'Access;

50 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Anonymous access to subprogram

This language feature will be made available in the forthcoming Ada 2005 standard.

procedure Test (
Call_Back : access procedure (
Id : Integer;
Text : String));

Using access types

Creating object in a storage pool
Objects in a storage pool are created with the keyword new:

Father : Person_Ref := new Person'(Father_First_Name, Father_Last_Name);

Deleting object from a storage pool

Although the Ada standard mentioned the use of a garbage collector which would
automatically remove all unneeded objects that had been created on the heap (storage pool),
only Ada compilers targeting a virtual machine like Java or .NET actually have garbage
collectors.

Therefore in order to delete an object from the heap you will need the generic unit
Ada.Unchecked_Deallocation.

with Ada.Unchecked_Deallocation;

procedure Deallocation_Sample is
type Vector is array (Integer range <>) of Float;
type Vector_Ref is access Vector;
procedure Free_Vector is new Ada.Unchecked_Deallocation
(Object => Vector, Name => Vector_Ref);
VA : Vector_Ref;

begin
VA := new Vector (1 .. 10);
VA.all := (others => 0.0);
-- ... Do whatever you need to do with the vector
Free_Vector (VA); -- The memory is deallocated and VA is now null
end Deallocation_Sample;

Since Ada does allow for user defined storage pools you could also try a garbage collector
library.

Implicit dereferencing
If you declare a record type, and an access type for it, thus:

type Person is record

First_Name : String (1..30);
Last_Name : String (1..20);
end record;

type Person_Access is access Person;

you can use these types as follows:

Father : Person_Access := new Person'(Father_First_Name, Father_Last_Name);

...
Ada.Text_IO.Put(Father.all.First_Name);

51 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

However, .all is implicit if omitted, so we can write more concisely:

Ada.Text_IO.Put(Father.First_Name);

and be careful:

Obj1 : Person_Access := new Person'(...);

Obj2 : Person_Access := new Person'(...);

Obj1 := Obj2; -- Obj1 now refers to the same person as Obj2 (shallow copy)
Obj1.all := Obj2.all; -- Obj1 still refers to a different object from Obj2,
-- but it has the same content (deep copy).

Implicit dereferencing also applies to arrays:

type Vector is array (0..3) of Complex;

type Vector_Access is access Vector;
VA : Vector_Access := new Vector;
...
C : Complex := VA(3); -- a shorter equivalent for VA.all(3)

Access FAQ
A few "Frequently Asked Question" and "Frequently Encountered Problems" (mostly from
former C users) regarding Ada's access types.

Access vs. access all

An access all can do anything a simple access can do. So one might ask: "Why use access
at all?" - And indeed some programmers never use simple access.

But this is wrong because access all is more error prone! One example: When
Unchecked_Deallocation is used on an access all it is not checked that the object actually
belongs to the proper storage pool - or if the object belongs to any storage pool at all. The
following example, invalidly and perhaps disastrously, will try to deallocate a stack object:

declare
type Day_Of_Month is range 1 .. 31;
type Day_Of_Month_Access is access all Day_Of_Month;

procedure Free
is new Ada.Unchecked_Deallocation (
Object => Day_Of_Month
Name => Day_Of_Month_Access);

A : aliased Day_Of_Month;
Ptr : Day_Of_Month_Access := A'Access;
begin
Free(Ptr);
end;

With a simple access you know at least that you won't try to deallocate a stack object.

Depending on the implementation an access might also render better performance then
access all.

Access performance
Ada performs run-time checks on access types, so not all access types render the same
performance. In other places of the Ada Programming we suggest that you should not care
about runtime checks since the optimizer will remove them when they are not needed.
However former C programmers often use anonymous access - which have worse
performance - instead of of using "out" or "in out" which has best performance. Here a

52 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

performance list - including the access modifiers - from best to worse:

1. "in" modifier : parameter need only to be passed into the function.

2. "out" modifier : parameter need only to be passed from the function.
3. "in out" modifier : the compiler is free to use "call by value", "call by register" or "call by
reference" and therefore best performance is to be expected.
4. pool access : the access is always within a storage pool and only checks for not null are
performed.
5. access all : additional checks maybe needed.
6. anonymous access : complex "stack deeps level" checks are needed so an "anonymous
access" can be safely converted from and to an "access all" or "pool access".

Access vs. System.Address

An access is not a memory address. It is something more. For example, an "access to String"
often needs some way of storing the string size as well. If you need a simple address and are
not concerned about strong-typing, you may consider using the System.Address type.

C compatible pointer
The correct way to create a C compatible access is to use pragma Convention:

type Day_Of_Month is range 1 .. 31;

for Day_Of_Month'Size use Interfaces.C.int'Size;

pragma Convention (
Convention => C,
Entity => Day_Of_Month);
type Day_Of_Month_Access is access Day_Of_Month;

pragma Convention (
Convention => C,
Entity => Day_Of_Month_Access);

pragma Convention should be used on any type you want to use in C. The compiler should
warn you if the type cannot be made C compatible.

You may also consider the following - shorter - alternative when declaring Day_Of_Month:

type Day_Of_Month is new Interfaces.C.int range 1 .. 31;

Before you use access types in C you should consider using the normal "in", "out" and "in
out" modifiers. pragma Export and pragma Import knows how parameters are usually
passed in C and will use a pointer to pass a parameter automatically where a "normal" C
programmer would have used them as well.

Of course the definition of a "normal" C programmer is not left to change, the RM contains
precise rules on when to use a pointer for "in", "out", and "in out" - see "B.3 Interfacing with
C (http://www.adaic.com/standards/95lrm/html/RM-B-3.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-B-3.html) )".

Where is void*?
While actually been a problem for "interfacing with C", here is a possible solution:

53 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

procedure Test
is
subtype Pvoid is System.Address;
-- the declare in C, like this.
-- int C_fun(int *)

function C_fun(pv : Pvoid) return Integer;

pragma Import (C,C_fun,"C_fun");

Pointer : Pvoid ;

Input_Parameter : Integer := 32;

Return_Value : Integer;
begin
Pointer := Input_Parameter'Address;
Return_Value := C_fun(Pointer);
end Test;

Less portable but perhaps more usable (for 32 bit CPUs):

type void is mod 2 ** 32;

for void'Size use 32;

With GNAT you can get 32/64 bit portability by using:

type void is mod System.Memory_Size;

for void'Size use System.Word_Size;

See also
Wikibook
Ada Programming
Ada Programming/Types

Ada Reference Manual

Ada 95

4.8 Allocators (http://www.adaic.com/standards/95lrm/html/RM-4-8.html) (Annotated

(http://www.adaic.com/standards/95aarm/html/AA-4-8.html) )
13.11 Storage Management
(http://www.adaic.com/standards/95lrm/html/RM-13-11.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-13-11.html) )
13.11.2 Unchecked Storage Deallocation
(http://www.adaic.com/standards/95lrm/html/RM-13-11-2.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-13-11-2.html) )
3.7 Discriminants (http://www.adaic.com/standards/95lrm/html/RM-3-7.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-3-7.html) )
3.10 Access Types (http://www.adaic.com/standards/95lrm/html/RM-3-10.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-3-10.html) )
6.1 Subprogram Declarations (http://www.adaic.com/standards/95lrm/html/RM-6-1.html)
(Annotated (http://www.adaic.com/standards/95aarm/html/AA-6-1.html) )
B.3 Interfacing with C (http://www.adaic.com/standards/95lrm/html/RM-B-3.html)
(Annotated (http://www.adaic.com/standards/95aarm/html/AA-B-3.html) )

Ada 2005

4.8 Allocators (http://www.adaic.com/standards/rm-amend/html/RM-4-8.html) (Annotated

(http://www.adaic.com/standards/rm-amend/html/AA-4-8.html) )
13.11 Storage Management
(http://www.adaic.com/standards/rm-amend/html/RM-13-11.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-13-11.html) )
13.11.2 Unchecked Storage Deallocation
(http://www.adaic.com/standards/rm-amend/html/RM-13-11-2.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-13-11-2.html) )
3.7 Discriminants (http://www.adaic.com/standards/rm-amend/html/RM-3-7.html)

54 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

(Annotated (http://www.adaic.com/standards/rm-amend/html/AA-3-7.html) )
3.10 Access Types (http://www.adaic.com/standards/rm-amend/html/RM-3-10.html)
(Annotated (http://www.adaic.com/standards/rm-amend/html/AA-3-10.html) )
6.1 Subprogram Declarations
(http://www.adaic.com/standards/rm-amend/html/RM-6-1.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-6-1.html) )
B.3 Interfacing with C (http://www.adaic.com/standards/rm-amend/html/RM-B-3.html)
(Annotated (http://www.adaic.com/standards/rm-amend/html/AA-B-3.html) )

Ada Quality and Style Guide

5.4.5 Dynamic Data (http://www.adaic.org/docs/95style/html/sec_5/5-4-5.html)
5.9.2 Unchecked Deallocation (http://www.adaic.org/docs/95style/html/sec_5/5-9-2.html)

Strings
Ada supports three different types of strings. Each string type is designed to solve a different
problem.

In addition, every string type is implemented for each available Characters type (Character,
Wide_Character, Wide_Wide_Character) giving a complement of nine combinations.

Fixed-length string handling

Fixed-Length Strings are arrays of Character, and consequently of a fixed length. Since a
fixed length string is an indefinite subtype the length does not need to be known at compile
time - the length may well be calculated at run time. In the following example the length is
calculated from command-line argument 1:

X : String := Ada.Command_Line.Argument (1);

However once the length has been calculated and the strings have been created the length
stays constant. Try the following program which shows a typical mistake:

File: show_commandline_1.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/show_commandline_1.adb?only_with_tag=HEAD&vie
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/show_commandline_1.adb) ,
download page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

with Ada.Text_IO;
with Ada.Command_Line;
procedure Show_Commandline_1 is

package T_IO renames Ada.Text_IO;

package CL renames Ada.Command_Line;

X : String := CL.Argument (1);

begin
T_IO.Put ("Argument 1 = ");
T_IO.Put_Line (X);

X := CL.Argument (2);

T_IO.Put ("Argument 2 = ");

T_IO.Put_Line (X);
end Show_Commandline_1;

The program will only work when the 1st and 2nd parameter have the same length. This is
even true when the 2nd parameter is shorter. There is neither an automatic padding of

55 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

shorter strings nor an automatic truncation of longer strings.

Having said that, the package Ada.Strings.Fixed contains a set of procedures and functions
for Fixed-Length String Handling which allows padding of shorter strings and truncation of
longer strings.

Try the following example to see how it works:

File: show_commandline_2.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/show_commandline_2.adb?only_with_tag=HEAD&vie
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/show_commandline_2.adb) ,
download page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

with Ada.Text_IO;
with Ada.Command_Line;
with Ada.Strings.Fixed;

procedure Show_Commandline_2 is

package T_IO renames Ada.Text_IO;

package CL renames Ada.Command_Line;
package S renames Ada.Strings;
package SF renames Ada.Strings.Fixed;

X : String := CL.Argument (1);

begin
T_IO.Put ("Argument 1 = ");
T_IO.Put_Line (X);
SF.Move (
Source => CL.Argument (2),
Target => X,
Drop => S.Right,
Justify => S.Left,
Pad => S.Space);
T_IO.Put ("Argument 2 = ");
T_IO.Put_Line (X);
end Show_Commandline_2;

Bounded-length string handling

Bounded-Length String can be used when the maximum length of a string is known and/or
restricted. This is often the case in database applications where only a limited amount of
characters can be stored.

Like Fixed-Length Strings the maximum length does not need to be known at compile time -
it can also be calculated at runtime - as the example below shows:

File: show_commandline_3.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/show_commandline_3.adb?only_with_tag=HEAD&vie
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/show_commandline_3.adb) ,
download page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

56 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

with Ada.Text_IO;
with Ada.Command_Line;
with Ada.Strings.Bounded;
procedure Show_Commandline_3 is

package T_IO renames Ada.Text_IO;

package CL renames Ada.Command_Line;

function Max_Lenght (
Value_1 : Integer;
Value_2 : Integer)
return
Integer;

function Max_Lenght (
Value_1 : Integer;
Value_2 : Integer)
return
Integer
is
Retval : Integer;
begin
if Value_1 > Value_2 then
Retval := Value_1;
else
Retval := Value_2;
end if;
return Retval;
end Max_Lenght;
pragma Inline (Max_Lenght);

package SB
is new Ada.Strings.Bounded.Generic_Bounded_Length (
Max => Max_Lenght (
Value_1 => CL.Argument (1)'Length,
Value_2 => CL.Argument (2)'Length));
X : SB.Bounded_String
:= SB.To_Bounded_String (CL.Argument (1));

begin
T_IO.Put ("Argument 1 = ");
T_IO.Put_Line (SB.To_String (X));
X := SB.To_Bounded_String (CL.Argument (2));

T_IO.Put ("Argument 2 = ");

T_IO.Put_Line (SB.To_String (X));
end Show_Commandline_3;

You should know that Bounded-Length Strings have some distinct disadvantages. Most
noticeable is that each Bounded-Length String is a different type which makes converting
them rather cumbersome. Also a Bounded-Length String type always allocates memory for
the maximum permitted string length for the type. The memory allocation for a
Bounded-Length String is equal to the maximum number of string "characters" plus an
implementation dependent number containing the string length (each character can require
allocation of more than one byte per character, depending on the underlying character type
of the string, and the length number is 4 bytes long for the Windows GNAT Ada compiler
v3.15p, for example).

Unbounded-length string handling

Last but not least there is the Unbounded-Length String. In fact: If you are not doing
embedded or database programming this will be the string type you are going to use most
often as it gives you the maximum amount of flexibility.

As the name suggest the Unbounded-Length String can hold strings of almost any length -
limited only to the value of Integer'Last or your available heap memory.

File: show_commandline_4.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/show_commandline_4.adb?only_with_tag=HEAD&vie
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/show_commandline_4.adb) ,
download page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

57 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

with Ada.Text_IO;
with Ada.Command_Line;
with Ada.Strings.Unbounded;
procedure Show_Commandline_4 is

package T_IO renames Ada.Text_IO;

package CL renames Ada.Command_Line;
package SU renames Ada.Strings.Unbounded;
X : SU.Unbounded_String
:= SU.To_Unbounded_String (CL.Argument (1));
begin
T_IO.Put ("Argument 1 = ");
T_IO.Put_Line (SU.To_String (X));

X := SU.To_Unbounded_String (CL.Argument (2));

T_IO.Put ("Argument 2 = ");
T_IO.Put_Line (SU.To_String (X));
end Show_Commandline_4;

As you see the Unbounded-Length String example is also the shortest (discarding the first
example - which is buggy) - this makes using Unbounded-Length Strings very appealing.

See also
Wikibook
Ada Programming

Ada 95 Reference Manual

2.6 String Literals (http://www.adaic.com/standards/95lrm/html/RM-2-6.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-2-6.html) )
3.6.3 String Types (http://www.adaic.com/standards/95lrm/html/RM-3-6-3.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-3-6-3.html) )
A.4.3 Fixed-Length String Handling
(http://www.adaic.com/standards/95lrm/html/RM-A-4-3.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-A-4-3.html) )
A.4.4 Bounded-Length String Handling
(http://www.adaic.com/standards/95lrm/html/RM-A-4-4.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-A-4-4.html) )
A.4.5 Unbounded-Length String Handling
(http://www.adaic.com/standards/95lrm/html/RM-A-4-5.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-A-4-5.html) )

Ada 2005 Reference Manual

2.6 String Literals (http://www.adaic.com/standards/rm-amend/html/RM-2-6.html)
(Annotated (http://www.adaic.com/standards/rm-amend/html/AA-2-6.html) )
3.6.3 String Types (http://www.adaic.com/standards/rm-amend/html/RM-3-6-3.html)
(Annotated (http://www.adaic.com/standards/rm-amend/html/AA-3-6-3.html) )
A.4.3 Fixed-Length String Handling
(http://www.adaic.com/standards/rm-amend/html/RM-A-4-3.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-A-4-3.html) )
A.4.4 Bounded-Length String Handling
(http://www.adaic.com/standards/rm-amend/html/RM-A-4-4.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-A-4-4.html) )
A.4.5 Unbounded-Length String Handling
(http://www.adaic.com/standards/rm-amend/html/RM-A-4-5.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-A-4-5.html) )

Subprograms

58 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

In Ada the subprograms are classified into two categories: procedures and functions.
Procedures are called as sentences and do not return any value, whereas the functions are
called as components of expressions and return a value, usually assigned to an object
(variable or constant).

Procedures
A procedure call in Ada constitutes a sentence by itself.

The parameters that can be passed to a procedure can be of three different modes:

in: the formal parameter is a constant and allows only reading the value of the associated
real parameter.
in out: the formal parameter is a variable and the real parameter value can be read or
written.
out: the formal parameter is a variable and the procedure assigns a value to it. In Ada 95
you can later read the value, but in Ada 83 out parameters were write-only.

For example:

procedure A_Test (A, B: in Integer; C: out Integer) is

begin
C := A + B;
end A_Test;

When the procedure is called with the sentence A_Test (5 + P, 48, Q);, the expressions 5
+ P and 48 are evaluated (expressions are only allowed for in parameters), and then
assigned to the formal parameters A and B, that behave like constants. Then, the value A + B
is assigned to formal variable C. In this case, formal parameter C is a new variable whose
value will be assigned to the real parameter Q when the procedure finishes. In Ada 83 if you
wanted to read the value of Q, besides being able to modify it, C would have to use in out
mode. This restriction was later removed in Ada 95, it is now the programmer's responsibility
to read an out parameter only after having assigned a value to it.

Within a procedure, the return sentence can be used without arguments to exit the
procedure and return the control to the caller.

For example, to solve an equation of the kind :

with Ada.Numerics.Elementary_Functions;
use Ada.Numerics.Elementary_Functions;

procedure Quadratic_Equation
(A, B, C : Float; -- By default it is "in".
R1, R2 : out Float;
Valid : out Boolean)
is
Z : Float;
begin
Z := B**2 - 4.0 * A * C;
if Z > 0.0 or A = 0.0 then
Valid := False; -- Being out parameter, it must be modified at least once.
R1 := 0.0;
R2 := 0.0;
else
Valid := True;
R1 := (-B + Sqrt (Z)) / (2.0 * A);
R2 := (-B - Sqrt (Z)) / (2.0 * A);
end if;
end Quadratic_Equation;

Suppose that a function SQRT exists that calculates the square root of the last parameter. If
the roots are real, they are given back in R1 and R2, but if they are complex or the equation
degenerates (A = 0), the execution of the procedure finishes after assigning to the Valid
variable the False value, so that it is controlled after the call to the procedure. Notice that
the out parameters must be modified at least once, and that if a mode is not specified, it is
implied in.

59 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Functions
A function is a subprogram that can be invoked as part of an expression. Functions can only
take in parameters, another mode cannot be specified (the in mode is mandatory and the
default). In this sense, Ada functions behave more like mathematical functions than in other
languages. The specification of the function is necessary to show to the clients all the
information needed to invoke it.

A function body example can be:

function Minimum (A, B : Integer) return Integer is

begin
if A <= B then
return B;
else
return A;
end if;
end Minimum;

The formal parameters of a function behave as local constants whose values are provided by
the corresponding real parameters. The sentence return is used to indicate the value
returned by the function call and to give back the control to the expression that called the
function. The expression of the sentence return is of arbitrary complexity and must be of the
same type declared in the specification. If an incompatible type is used, the compiler gives
an error. If the restrictions of a subtype are not fulfilled, e.g. a range, it raises a
Constraint_Error exception.

The body of the function can contain several return sentences and the execution of any of
them will finish the function, returning control to the sentence that invoked it. If the flow of
control within the function branches several ways, it is necessary to make sure that each one
of them is finished with a return sentence. If at run time the end of a function is reached
without encountering a return statement, the exception Program_Error is raised. Therefore,
the body of a function must have at least one return sentence.

Every call to a function produces a new copy of any object declared within it, including the
parameters. When the function finalizes, its objects disappear. Therefore, it is possible to call
the function recursively. For example, consider this implementation of the factorial function:

function Factorial (N : Positive) return Positive is

begin
if N = 1 then
return 1;
else
return (N * Factorial (N - 1));
end if;
end Factorial;

When evaluating the expression Factorial (4); the function will be called with parameter 4
and within the function it will try to evaluate the expression Factorial (3), calling itself as
a function, but in this case parameter N would be 3 (each call copies the parameters) and so
on until N = 1 is evaluated which will finalize the recursion and then the expression will
begin to be completed in the reverse order.

A formal parameter of a function can be of any type, including vectors or records.

Nevertheless, it cannot be an anonymous type, that is, its type must be declared before, for
example:

60 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

type Float_Vector is array (Positive range <>) of Float;

function Add_Components (V: Float_Vector) return Float is

Result : Float := 0.0;
begin
for I in V'Range loop
Result := Result + V(I);
end loop;
return Result;
end Add_Components;

In this example, the function can be used on a vector of arbitrary dimension. Therefore, there
are no static bounds in the parameters passed to the functions. For example, it is possible to
be used in the following way:

V4 : Float_Vector (1 .. 4) := (1.2, 3.4, 5.6, 7.8);

Sum : Float;

Sum := Add_Components (V4);

In the same way, a function can also return a type whose bounds are not known a priori. For
example:

function Invert_Components (V : Float_Vector) return Float_Vector is

Result : Float_Vector(V'Range); -- Fix the bounds of the vector to be returned.
begin
for I in V'Range loop
Result(I) := V (V'First + V'Last - I);
end loop;
return Result;
end Invert_Components;

The variable Result has the same bounds as V, so the returned vector will always have the
same dimension as the one passed as parameter.

A value returned by a function can be used without assigning it to a variable, it can be

referenced as an expression. For example, Invert_Components (V4) (1), where the first
element of the vector returned by the function would be obtained (in this case, the last
element of V4, 7.8).

Named parameters
In both procedures and function calls, the order of parameters can be altered using named
notation, that is, the name of the formal parameter followed of the symbol => and then the
real parameter. For example:

Quadratic_Equation (Valid => OK, A => 1.0, B => 2.0, C => 3.0, R1 => P, R2 => Q);
F := Factorial (N => (3 + I));

This involves knowing the formal parameters names which are always specified in the
subprogram specification. As the real parameter is assigned one by one to the real one, there
is no problem of ambiguity. Remember that the formal parameter goes to the left of the =>
symbol; in the case where the real parameter has the same name as the formal one, there
would not be any ambiguity since they are in different scopes.

Default parameters
On the other hand, formal parameters, both in procedures and in functions, might have
default values. They can, therefore, be skipped in the subprogram call. For example:

procedure By_Default_Example (A : in Integer := 0;

B : in Integer := 0);

61 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Can be called in these ways:

By_Default_Example (5, 7); -- A = 5, B = 7

By_Default_Example (5); -- A = 5, B = 0
By_Default_Example; -- A = 0, B = 0
By_Default_Example (B => 3); -- A = 0, B = 3
By_Default_Example (1, B => 2); -- A = 1, B = 2

In the first sentence, a "regular call" is used (with positional notation), in the second, it is
used positional and then by default, third it uses all the parameters by default, in fourth
named and by default, and, finally, the fifth uses positional and named notation. When mixing
both notations, the positional one has to precede the named one.

See also
Wikibook
Ada Programming
Ada Programming/Operators

Ada 95 Reference Manual

Section 6: Subprograms (http://www.adaic.com/standards/95lrm/html/RM-6.html)
(Annotated (http://www.adaic.com/standards/95aarm/html/AA-6.html) )
4.4 Expressions (http://www.adaic.com/standards/95lrm/html/RM-4-4.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-4-4.html) )

Ada 2005 Reference Manual

Section 6: Subprograms (http://www.adaic.com/standards/rm-amend/html/RM-6.html)
(Annotated (http://www.adaic.com/standards/rm-amend/html/AA-6.html) )
4.4 Expressions (http://www.adaic.com/standards/rm-amend/html/RM-4-4.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-4-4.html) )

Ada Quality and Style Guide

4.1.3 Subprograms (http://www.adaic.org/docs/95style/html/sec_4/4-1-3.html)

Packages
One of the biggest advantages of Ada over most other programming languages is its well
defined system of modularization and separate compilation. Even though Ada allows
separate compilation, it maintains the strong type checking among the various compilations
by enforcing rules of compilation order and compatibility checking. Ada uses separate
compilation (like Modula-2, Java and C#), and not independent compilation (as C/C++ does),
in which the various parts are compiled with no knowledge of the other compilation units
with which they will be combined.

A note to C/C++ users: Yes, you can use the preprocessor to emulate separate compilation --
but it is only an emulation and the smallest mistake leads to very hard to find bugs. It is
telling that all C/C++ successor languages including D have turned away from the
independent compilation and the use of the preprocessor.

So it's good to know that Ada has separate compilation ever since Ada-83 and is probably the
most sophisticated implementation around.

Parts of a package

62 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

This section is a stub. You can help Wikibooks by expanding it

(http://en.wikibooks.org/w/index.php?title=Ada_Programming/All_Chapters&action=edit) .

A package consists of 3 parts but only the specification is mandatory: you leave out the body
and the private part if you don't need them - you can have package specification without
package body and the private package specification is optional.

The public package specification

The package specification of an Ada package describes all the subprogram specifications,
variables, types, constants etc that are visible to anyone who wishes to use the package.

package Public_Only_Package is

type Range_10 is range 1 .. 10;

end Public_Only_Package;

The private package specification

package Package_With_Private is

type Private_Type is private;

private
type Private_Type is array (1 .. 10) of Integer;

end Package_With_Private;

The package body

package Package_With_Body is

type Basic_Record is private;

procedure Set_A (This : in out Basic_Record;

An_A : in Integer);

function Get_A (This : Basic_Record) return Integer;

private

type Basic_Record is
record
A : Integer;
end record ;

pragma Pure_Function (Get_A);

pragma Inline (Get_A);
pragma Inline (Set_A);

end Package_With_Body;

63 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

package body Package_With_Body is

procedure Set_A (This : in out Basic_Record;

An_A : in Integer)
is
begin
This.A := An_A;
end Set_A;

function Get_A (This : Basic_Record) return Integer is

begin
return This.A;
end Get_A;

end Package_With_Body;

pragma Pure_Function
Only available when using GNAT.

Using packages
This section is a stub. You can help Wikibooks by expanding it

(http://en.wikibooks.org/w/index.php?title=Ada_Programming/All_Chapters&action=edit) .

To utilize a package it's needed to name it in a with clause, whereas to have direct visibility
of that package it's needed to name it in a use clause.

For C++ programmers, Ada's with clause is analogous to the C++ preprocessor's #include
and Ada's use is similar to the using namespace statement in C++. In particular, use leads
to the same namespace pollution problems as using namespace and thus should be used
sparingly. Renaming can shorten long compound names to a manageable length, while the
use type clause makes a type's operators visible. These features reduce the need for plain
use.

Standard with
Private with
This language feature will be made available in the forthcoming Ada 2005 standard.

64 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

private with Ada.Strings.Unbounded;

package Private_With is
-- The package Ada.String.Unbounded is not visible at this point

type Basic_Record is private;

procedure Set_A (This : in out Basic_Record;

An_A : in String);

function Get_A (This : Basic_Record) return String;

private
-- The visibility of package Ada.String.Unbounded starts here
package Unbounded renames Ada.Strings.Unbounded;

type Basic_Record is
record
A : Unbounded.Unbounded_String;
end record;

pragma Pure_Function (Get_A);

pragma Inline (Get_A);
pragma Inline (Set_A);

end Private_With;

package body Private_With is

-- The private withed package is visible in the body too

procedure Set_A (This : in out Basic_Record;
An_A : in String)
is
begin
This.A := Unbounded.To_Unbounded_String (An_A);
end Set_A;
function Get_A (This : Basic_Record) return String is
begin
return Unbounded.To_String (This.A);
end Get_A;

end Private_With;

Limited with
This language feature will be made available in the forthcoming Ada 2005 standard.

limited with Departments;

package Employees is
type Employee is tagged private;
procedure Assign_Employee
(E : in out Employee;
D : access Departments.Department'Class);
type Dept_Ptr is access all Departments.Department'Class;

function Current_Department(E : in Employee) return Dept_Ptr;

...
end Employees;

limited with Employees;

package Departments is

type Department is tagged private;

procedure Choose_Manager
(Dept : in out Department;
Manager : access Employees.Employee'Class);
...
end Departments;

With type

65 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Package organisation
This section is a stub. You can help Wikibooks by expanding it

(http://en.wikibooks.org/w/index.php?title=Ada_Programming/All_Chapters&action=edit) .

Child packages
Ada allows one to extend the functionality of a unit (package) with children. These children
can inherit, with certain exceptions, all the functionality of the parent, and only allow
visibility as desired. Example:

package body OS_I is

package Byte_IO is new Ada.Text_IO.Integer_IO(Byte);
package Put_Trace renames Trace;
-- this rename reduces confusion with a Trace declared at another level.

package body Environment is

... some procedures...
end Environment;
end OS_I;

to make a procedure in a child package one merely 'withs' the child as :

with OS_I.Put_Trace;

It is possible to prevent visibility merely by placing the package statement, and the package
body statement in the body of the parent. A with of a child also 'withs in' the parent

Nested packages
A nested package is a package declared inside a package:

Subunits

See also
Wikibook
Ada Programming

Wikipedia
Module

Ada 95 Reference Manual

Section 7: Packages (http://www.adaic.com/standards/95lrm/html/RM-7.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-7.html) )

Ada 2005 Reference Manual

Section 7: Packages (http://www.adaic.com/standards/rm-amend/html/RM-7.html)
(Annotated (http://www.adaic.com/standards/rm-amend/html/AA-7.html) )

66 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Input Output
Ada has 5 independent libraries for input/output operations. So the most important lesson to
learn is choosing the right one.

Text I/O
Text I/O is probably the most used Input/Output package. All data inside the file are
represented by human readable text. Text I/O provides support for line and page layout but
the standard is free form text.

Direct I/O
Direct I/O is used for random access files which contain only elements of one specific type.
With Direct_IO you can position the file pointer to any element of that type (random access),
however you can't freely choose the element type, the element type needs to be a definite
subtype.

Sequential I/O
Sequential I/O is used for sequential access files which contain only elements of one specific
type. With Sequential_IO it is the other way round: you can choose between definite and
indefinite element types but you have to read and write the elements one after the other.

Storage I/O
Storage I/O allows you to store one element inside a memory buffer. The element needs to be
a definite subtype. Storage I/O is useful in Concurrent programming where it can be used to
move elements from one task to another.

Stream I/O
Stream I/O is the most powerful input/output package which Ada provides. Stream I/O allows
you to mix objects from different element types in one sequential file. In order to read/write
from/to a stream each type provides a 'Read and 'Write attribute as well as an 'Input and
'Output attribute. These attributes are automatically generated for each type you declare.

The 'Read and 'Write attributes treat the elements as raw data. They are suitable for low
level input/output as well as interfacing with other programming languages.

The 'Input and 'Output attribute add additional control informations to the file, like for
example the 'First and 'Last attributes from an array.

In object orientated programming you can also use the 'Class'Input and 'Class'Output
attributes - they will store and recover the actual object type as well.

Stream I/O is also the most flexible input/output package. All I/O attributes can be replaced
with user defined functions or procedures using representation clauses and you can provide
your own Stream I/O types using flexible object oriented techniques.

See also

67 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Wikibook
Ada Programming
Ada Programming/Libraries/Ada.Direct_IO
Ada Programming/Libraries/Ada.Sequential_IO
Ada Programming/Libraries/Ada.Storage_IO
Ada Programming/Libraries/Ada.Streams
Ada Programming/Libraries/Ada.Streams.Stream_IO
Ada Programming/Libraries/Ada.Text_IO
Ada Programming/Libraries/Ada.Text_IO.Complex_IO (nested package)
Ada Programming/Libraries/Ada.Text_IO.Decimal_IO (nested package)
Ada Programming/Libraries/Ada.Text_IO.Enumeration_IO (nested package)
Ada Programming/Libraries/Ada.Text_IO.Fixed_IO (nested package)
Ada Programming/Libraries/Ada.Text_IO.Float_IO (nested package)
Ada Programming/Libraries/Ada.Text_IO.Integer_IO (nested package)
Ada Programming/Libraries/Ada.Text_IO.Modular_IO (nested package)
Ada Programming/Libraries/Ada.Text_IO.Editing
Ada Programming/Libraries/Ada.Float_Text_IO
Ada Programming/Libraries/Ada.Integer_Text_IO

Ada 95 Reference Manual

13.13 Streams (http://www.adaic.com/standards/95lrm/html/RM-13-13.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-13-13.html) )
A.8.1 The Generic Package Sequential_IO
(http://www.adaic.com/standards/95lrm/html/RM-A-8-1.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-A-8-1.html) )
A.8.4 The Generic Package Direct_IO
(http://www.adaic.com/standards/95lrm/html/RM-A-8-4.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-A-8-4.html) )
A.10.1 The Package Text_IO
(http://www.adaic.com/standards/95lrm/html/RM-A-10-1.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-A-10-1.html) )
A.12.1 The Package Streams.Stream_IO
(http://www.adaic.com/standards/95lrm/html/RM-A-12-1.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-A-12-1.html) )

Ada 2005 Reference Manual

13.13 Streams (http://www.adaic.com/standards/rm-amend/html/RM-13-13.html)
(Annotated (http://www.adaic.com/standards/rm-amend/html/AA-13-13.html) )
A.8.1 The Generic Package Sequential_IO
(http://www.adaic.com/standards/rm-amend/html/RM-A-8-1.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-A-8-1.html) )
A.8.4 The Generic Package Direct_IO
(http://www.adaic.com/standards/rm-amend/html/RM-A-8-4.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-A-8-4.html) )
A.10.1 The Package Text_IO
(http://www.adaic.com/standards/rm-amend/html/RM-A-10-1.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-A-10-1.html) )
A.12.1 The Package Streams.Stream_IO
(http://www.adaic.com/standards/rm-amend/html/RM-A-12-1.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-A-12-1.html) )

Ada Quality and Style Guide

7.7 Input/Output (http://www.adaic.org/docs/95style/html/sec_7/7-7.html)
7.7.1 Name and Form Parameters
(http://www.adaic.org/docs/95style/html/sec_7/7-7-1.html)
7.7.2 File Closing (http://www.adaic.org/docs/95style/html/sec_7/7-7-2.html)
7.7.3 Input/Output on Access Types
(http://www.adaic.org/docs/95style/html/sec_7/7-7-3.html)
7.7.4 Package Ada.Streams.Stream_IO
(http://www.adaic.org/docs/95style/html/sec_7/7-7-4.html)
7.7.5 Current Error Files (http://www.adaic.org/docs/95style/html/sec_7/7-7-5.html)

68 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Exceptions

Robustness
Robustness is the ability of a system or system component to behave “reasonably” when it
detects an anomaly, e.g.:

It receives invalid inputs.

Another system component (hardware or software) malfunctions.

Take as example a telephone exchange control program. What should the control program do
when a line fails? It is unacceptable simply to halt — all calls will then fail. Better would be to
abandon the current call (only), record that the line is out of service, and continue. Better
still would be to try to reuse the line — the fault might be transient. Robustness is desirable
in all systems, but It is essential in systems on which human safety or welfare depends, e.g.,
hospital patient monitoring, aircraft fly-by-wire, nuclear power station control, etc.

Modules, preconditions and postconditions

A module may be specified in terms of its preconditions and postconditions. A precondition is
a condition that the module’s inputs are supposed to satisfy. A postcondition is a condition
that the module’s outputs are required to satisfy, provided that the precondition is satisfied.
What should a module do if its precondition is not satisfied?

Halt? Even with diagnostic information, this is generally unacceptable.

Use a global result code? The result code can be set to indicate an anomaly.
Subsequently it may be tested by a module that can effect error recovery. Problem: this
induces tight coupling among the modules concerned.
Each module has its own result code? This is a parameter (or function result) that may be
set to indicate an anomaly, and is tested by calling modules. Problems: (1) setting and
testing result codes tends to swamp the normal-case logic and (2) the result codes are
normally ignored.
Exception handling — Ada’s solution. A module detecting an anomaly raises an exception.
The same, or another, module may handle that exception.

The exception mechanism permits clean, modular handling of anomalous situations:

A unit (e.g., block or subprogram body) may raise an exception, to signal that an anomaly
has been detected. The computation that raised the exception is abandoned (and can
never be resumed, although it can be restarted).
A unit may propagate an exception that has been raised by itself (or propagated out of
another unit it has called).
A unit may alternatively handle such an exception, allowing programmer-defined
recovery from an anomalous situation. Exception handlers are segregated from
normal-case code.

Predefined exceptions
The predefined exceptions are those defined in package Standard. Every language-defined
run-time error causes a predefined exception to be raised. Some examples are:

Constraint_Error, raised when a subtype’s constraint is not satisfied

Program_Error, a protected operation is called inside a protected object
Storage_Error, raised by running out of storage
Tasking_Error, a task cannot be activated because the operating system has not enough
resources

Ex.1

69 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Name : String (1 .. 10);

...
Name := "Hamlet"; -- Raises Constraint_Error,
-- because the "Hamlet" has bounds (1 .. 6).

Ex.2

loop
P := new Int_Node'(0, P);
end loop; -- Soon raises Storage_Error,
-- because of the extreme memory leak.

Ex.3 Compare the following approaches:

procedure Compute_Sqrt (X : in Float;

Sqrt : out Float;
OK : out Boolean)
is
begin
if X >= 0 then
OK := True;
-- compute √X
...
else
OK := False;
end if;
end Compute_Sqrt;
...
procedure Triangle (A, B, C : in Float;
Area, Perimeter : out Float;
Exists : out Boolean)
is
S : Float := 0.5 * (A + B + C);
OK : Boolean;
begin
Compute_Sqrt (S * (S-A) * (S-B) * (S-C), Area, OK);
Perimeter := 2.0 * S;
Exists := OK;
end Triangle;

A negative argument to Compute_Sqrt causes OK to be set to False. Triangle uses it to

determine its own status parameter value, and so on up the calling tree, ad nauseam.

versus

function Sqrt (X : Float) return Float is

begin
if X < 0.0 then
raise Constraint_Error;
end if;
-- compute √X
...
end Sqrt;

...

procedure Triangle (A, B, C : in Float;

Area, Perimeter : out Float)
is
S : Float := 0.5 * (A + B + C);
OK : Boolean;
begin
Area := Sqrt (S * (S-A) * (S-B) * (S-C));
Perimeter := 2.0 * S;
end Triangle;

A negative argument to Sqrt causes Constraint_Error to be explicitly raised inside Sqrt, and
propagated out. Triangle simply propagates the exception (by not handling it).

Alternatively, we can catch the error by using the type system:

70 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

subtype Pos_Float is Float range 0.0 .. Float'Last;

function Sqrt (X : Pos_Float) return Pos_Float is

begin
-- compute √X
...
end Sqrt;

A negative argument to Sqrt now raises Constraint_Error at the point of call. Sqrt is never
even entered.

Input-output exceptions
Some examples of exceptions raised by subprograms of the predefined package
Ada.Text_IO are:

End_Error, raised by Get, Skip_Line, etc., if end-of-file already reached.

Data_Error, raised by Get in Integer_IO, etc., if the input is not a literal of the expected
type.
Mode_Error, raised by trying to read from an output file, or write to an input file, etc
Layout_Error, raised by specifying an invalid data format in a text I/O operation

Ex. 1

declare
A : Matrix (1 .. M, 1 .. N);
begin
for I in 1 .. M loop
for J in 1 .. N loop
begin
Get (A(I,J));
exception
when Data_Error =>
Put ("Ill-formed matrix element");
A(I,J) := 0.0;
end;
end loop;
end loop;
exception
when End_Error =>
Put ("Matrix element(s) missing");
end;

Exception declarations
Exceptions are declared rather like objects, but they are not objects. For example, recursive
re-entry to a scope where an exception is declared does not create a new exception of the
same name; instead the exception declared in the outer invocation is reused.

Ex.1

Line_Failed : exception;

Ex.2

package Directory_Enquiries is

procedure Insert (New_Name : in Name;

New_Number : in Number);

procedure Lookup (Given_Name : in Name;

Corr_Number : out Number);

Name_Duplicated : exception;
Name_Absent : exception;
Directory_Full : exception;

end Directory_Enquiries;

71 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Raising exceptions
The raise statement explicitly raises a specified exception.

Ex. 1

package body Directory_Enquiries is

procedure Insert (New_Name : in Name;

New_Number : in Number)
is
…
begin
…
if New_Name = Old_Entry.A_Name then
raise Name_Duplicated;
end if;
…
New_Entry := new Dir_Node'(New_Name, New_Number,…);
…
exception
when Storage_Error => raise Directory_Full;
end Insert;
procedure Lookup (Given_Name : in Name;
Corr_Number : out Number)
is
…
begin
…
if not Found then
raise Name_Absent;
end if;
…
end Lookup;
end Directory_Enquiries;

Exception handling and propagation

Exception handlers may be grouped at the end of a block, subprogram body, etc. A handler is
any sequence of statements that may end:

by completing;
by executing a return statement;
by raising a different exception (raise e;);
by re-raising the same exception (raise;).

Suppose that an exception e is raised in a sequence of statements U (a block, subprogram

body, etc.).

If U contains a handler for e: that handler is executed, then control leaves U.

If U contains no handler for e: e is propagated out of U; in effect, e is raised at the "point
of call” of U.

So the raising of an exception causes the sequence of statements responsible to be

abandoned at the point of occurrence of the exception. It is not, and cannot be, resumed.

Ex. 1

...
exception
when Line_Failed =>
begin -- attempt recovery
Log_Error;
Retransmit (Current_Packet);
exception
when Line_Failed =>
Notify_Engineer; -- recovery failed!
Abandon_Call;
end;
...

Information about an exception occurrence

72 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Ada provides information about an exception in an object of type Exception_Occurrence,

defined in Ada.Exceptions along with subprograms taking this type as parameter:

Exception_Name: return the full exception name using the dot notation and in uppercase
letters. For example, Queue.Overflow.
Exception_Message: return the exception message associated with the occurrence.
Exception_Information: return a string including the exception name and the associated
exception message.

For getting an exception occurrence object the following syntax is used:

with Ada.Exceptions; use Ada.Exceptions;

...
exception
when Error: High_Pressure | High_Temperature =>
Put ("Exception: ");
Put_Line (Exception_Name (Error));
Put (Exception_Message (Error));
when Error: others =>
Put ("Unexpected exception: ");
Put_Line (Exception_Information(Event));
end;

The exception message content is implementation defined when it is not set by the user who
raises the exception. It usually contains a reason for the exception and the raising location.

The user can specify a message using the procedure Raise_Exception.

declare
Valve_Failure : exception;
begin
...
Raise_Exception (Valve_Failure'Identity, "Failure while opening");
...
Raise_Exception (Valve_Failure'Identity, "Failure while closing");
...
exception
when Fail: Valve_Failure =>
Put (Exceptions_Message (Fail));
end;

The package also provides subprograms for saving exception occurrences and reraising
them.

See also
Wikibook
Ada Programming

Ada 95 Reference Manual

Section 11: Exceptions (http://www.adaic.com/standards/95lrm/html/RM-11.html)
(Annotated (http://www.adaic.com/standards/95aarm/html/AA-11.html) )
11.4.1 The Package Exceptions
(http://www.adaic.com/standards/95lrm/html/RM-11-4-1.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-11-4-1.html) )

Ada 2005 Reference Manual

Section 11: Exceptions (http://www.adaic.com/standards/rm-amend/html/RM-11.html)
(Annotated (http://www.adaic.com/standards/rm-amend/html/AA-11.html) )
11.4.1 The Package Exceptions
(http://www.adaic.com/standards/rm-amend/html/RM-11-4-1.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-11-4-1.html) )

Ada Quality and Style Guide

73 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Chapter 4: Program Structure

4.3 Exceptions (http://www.adaic.org/docs/95style/html/sec_4/4-3.html)
4.3.1 Using Exceptions to Help Define an Abstraction
(http://www.adaic.org/docs/95style/html/sec_4/4-3-1.html)
Chapter 5: Programming Practices
5.8 Using Exceptions (http://www.adaic.org/docs/95style/html/sec_5/5-8.html)
5.8.1 Handling Versus Avoiding Exceptions
(http://www.adaic.org/docs/95style/html/sec_5/5-8-1.html)
5.8.2 Handling for Others
(http://www.adaic.org/docs/95style/html/sec_5/5-8-2.html)
5.8.3 Propagation (http://www.adaic.org/docs/95style/html/sec_5/5-8-3.html)
5.8.4 Localizing the Cause of an Exception
(http://www.adaic.org/docs/95style/html/sec_5/5-8-4.html)
Chapter 7: Portability
7.5 Exceptions (http://www.adaic.org/docs/95style/html/sec_7/7-5.html)
7.5.1 Predefined and User-Defined Exceptions
(http://www.adaic.org/docs/95style/html/sec_7/7-5-1.html)
7.5.2 Implementation-Specific Exceptions
(http://www.adaic.org/docs/95style/html/sec_7/7-5-2.html)

Generics

Parametric polymorphism (generic units)

The idea of code reusability arises because of the necessity to construct programs on the
basis of well established building blocks that can be combined to form an ampler and
complex system. The reusability of code improves the productivity and the quality of
software. One of the ways in which the Ada language supports this characteristic is by means
of generic units. A generic unit is a unit that defines algorithms in terms of types and other
operations that are not defined until the user instantiates them. Generic units can be
subprograms and packages.

Note to C++ programmers: generic units are similar to C++ templates.

For example, to define a procedure for swaping variables of any (non-limited) type:

generic
type Element_T is private; -- Generic formal type parameter
procedure Swap (X, Y : in out Element_T);

procedure Swap (X, Y : in out Element_T) is

Temporal : constant Element_T := X;
begin
X := Y;
Y := Temporal;
end Swap;

The Swap subprogram is said to be generic. The subprogram specification is preceded by the
generic formal part consisting of the reserved word generic followed by a list of generic
formal parameters which may be empty. The entities declared as generic are not directly
usable, it is necessary to instantiate them.

To be able to use Swap, it is necessary to create an instance for the wanted type. For
example:

74 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

procedure Swap_Integers is new Swap (Integer);

Now the Swap_Integers procedure can be used for variables of type Integer.

The generic procedure can be instantiated for all the needed types. It can be instantiated
with different names or, if the same identifier is used in the instantiation, each declaration
overloads the procedure:

procedure Instance_Swap is new Swap (Float);

procedure Instance_Swap is new Swap (Day_T);
procedure Instance_Swap is new Swap (Element_T => Stack_T);

Similarly, generic packages can be used, for example, to implement a stack of any kind of
elements:

generic
Max: Positive;
type Element_T is private;
package Generic_Stack is
procedure Push (E: Element_T);
function Pop return Element_T;
end Generic_Stack;

package body Generic_Stack is

Stack : array (1 .. Max) of Element_T;
Top : Integer range 0 .. Max;
-- ...
end Generic_Stack;

A stack of a given size and type could be defined in this way:

declare
package Float_100_Stack is new Generic_Stack (100, Float);
use Float_100_Stack;
begin
Push (45.8);
-- ...
end;

Formal parameters are of mode in by default and can be in out, but never out. In case it is in,
the parameter will behave as a constant whose value is provided by the corresponding actual
parameter. Of course, an in generic parameter cannot be of a limited type, because the copy
is not allowed and the formal parameter takes its value by means of copying. In case the
generic parameter is of mode in out, it behaves as a variable that renames the corresponding
actual parameter; in this case, the actual parameter must be a variable and its determination
is made in the moment of the unit instantiation.

In addition to generic type and object parameters, formal subprograms or package

parameters can be used, for example:

generic
type Element_T is private;
with function "*" (X, Y: Element_T) return Element_T;
function Square (X : Element_T) return Element_T;

function Square (X: Element_T) return Element_T is

begin
return X * X; -- The formal operator "*".
end Square;

This generic function could be used, for example, with matrices, having defined the matrix
product.

75 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

with Square;
with Matrices;
procedure Matrix_Example is
function Square_Matrix is new Square
(Element_T => Matrices.Matrix_T, "*" => Matrices.Product);
A: Matrix_T := Matrix_T.Identity;
begin
A := Square_Matrix (A);
end Matrix_Example;

See also
Wikibook
Ada Programming
Ada Programming/Object Orientation: tagged types provides other mean of
polymorphism in Ada.

Wikipedia
Generic programming

Ada Reference Manual

Section 12: Generic Units (http://www.adaic.com/standards/95lrm/html/RM-12.html)
(Annotated (http://www.adaic.com/standards/95aarm/html/AA-12.html) )

Tasking

Tasks
A task unit is a program unit that is obeyed concurrently with the rest of an Ada program.
The corresponding activity, a new locus of control, is called a task in Ada terminology, and is
similar to a thread, for example in Java Threads. The execution of the main program is also a
task, the anonymous environment task. A task unit has both a declaration and a body, which
is mandatory. A task body may be compiled separately as a subunit, but a task may not be a
library unit, nor may it be generic. Every task depends on a master, which is the immediately
surrounding declarative region - a block, a subprogram, another task, or a package. The
execution of a master does not complete until all its dependant tasks have terminated. The
environment task is the master of all other tasks; it terminates only when all other tasks have
terminated.

Task units are similar to packages in that a task declaration defines entities exported from
the task, whereas its body contains local declarations and statements of the task.

A single task is declared as follows:

task Single is
declarations of exported identifiers
end Single;
...
task body Single is
local declarations and statements
end Single;

A task declaration can be simplified, if nothing is exported, thus:

76 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

task No_Exports;

Ex. 1

procedure Housekeeping is

task Check_CPU;
task Backup_Disk;

task body Check_CPU is

...
end Check_CPU;
task body Backup_Disk is
...
end Backup_Disk;
-- the two tasks are automatically created and begin execution
begin -- Housekeeping
null;
-- Housekeeping waits here for them to terminate
end Housekeeping;

It is possible to declare task types, thus allowing task units to be created dynamically, and
incorporated in data structures:

task type T is
...
end T;
...
Task_1, Task_2 : T;
...
task body T is
...
end T;

Task types are limited, i.e. they are restricted in the same way as limited private types, so
assignment and comparison are not allowed.

Rendezvous
The only entities that a task may export are entries. An entry looks much like a procedure. It
has an identifier and may have in, out or in out parameters. Ada supports communication
from task to task by means of the entry call. Information passes between tasks through the
actual parameters of the entry call. We can encapsulate data structures within tasks and
operate on them by means of entry calls, in a way analogous to the use of packages for
encapsulating variables. The main difference is that an entry is executed by the called task,
not the calling task, which is suspended until the call completes. If the called task is not
ready to service a call on an entry, the calling task waits in a (FIFO) queue associated with
the entry. This interaction between calling task and called task is known as a rendezvous.
The calling task requests rendezvous with a specific named task by calling one of its entries.
A task accepts rendezvous with any caller of a specific entry by executing an accept
statement for the entry. If no caller is waiting, it is held up. Thus entry call and accept
statement behave symmetrically. (To be honest, optimized object code may reduce the
number of context switches below the number implied by this naive description.)

Ex. 2 The following task type implements a single-slot buffer, i.e. an encapsulated variable
that can have values inserted and removed in strict alternation. Note that the buffer task has
no need of state variables to implement the buffer protocol: the alternation of insertion and
removal operations is directly enforced by the control structure in the body of
Encapsulated_Buffer_Task_Type.

77 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

task type Encapsulated_Buffer_Task_Type is

entry Insert (An_Item : in Item);
entry Remove (An_Item : out Item);
end Encapsulated_Buffer_Task_Type;
...
Buffer_Pool : array (0 .. 15) of Encapsulated_Buffer_Task_Type;
This_Item : Item;
...
task body Encapsulated_Buffer_Task_Type is
Datum : Item;
begin
loop
accept Insert (An_Item : in Item) do
Datum := An_Item;
end Insert;
accept Remove (An_Item : out Item) do
An_Item := Datum;
end Remove;
end loop;
end Encapsulated_Buffer_Task_Type;
...
Buffer_Pool(1).Remove (This_Item);
Buffer_Pool(2).Insert (This_Item);

Selective Wait
To avoid being held up when it could be doing productive work, a server task often needs the
freedom to accept a call on any one of a number of alternative entries. It does this by means
of the selective wait statement, which allows a task to wait for a call on any of two or more
entries.

If only one of the alternatives in a selective wait statement has a pending entry call, then that
one is accepted. If two or more alternatives have calls pending, the implementation is free to
accept any one of them. For example, it could choose one at random. This introduces
bounded non-determinism into the program. A sound Ada program should not depend on a
particular method being used to choose between pending entry calls. (However, there are
facilities to influence the method used, when that is necessary.)

Ex. 3

task type Encapsulated_Variable_Task_Type is

entry Store (An_Item : in Item);
entry Fetch (An_Item : out Item);
end Encapsulated_Variable_Task_Type;
...
task body Encapsulated_Variable_Task_Type is
Datum : Item;
begin
accept Store (An_Item : in Item) do
Datum := An_Item;
end Store;
loop
select
accept Store (An_Item : in Item) do
Datum := An_Item;
end Store;
or
accept Fetch (An_Item : out Item) do
An_Item := Datum;
end Fetch;
end select;
end loop;
end Encapsulated_Variable_Task_Type;

x, y : Encapsulated_Variable_Task_Type;

creates two variables of type Encapsulated_Variable_Task_Type. They can be used thus:

it : Item;
...
x.Store(Some_Expression);
...
x.Fetch (it);
y.Store (it);

78 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Again, note that the control structure of the body ensures that an
Encapsulated_Variable_Task_Type must be given an initial value by a first Store operation
before any Fetch operation can be accepted.

Guards
Depending on circumstances, a server task may not be able to accept calls for some of the
entries that have accept alternatives in a selective wait statement. The acceptance of any
alternative can be made conditional by using a guard, which is Boolean precondition for
acceptance. This makes it easy to write monitor-like server tasks, with no need for an explicit
signaling mechanism, nor for mutual exclusion. An alternative with a True guard is said to be
open. It is an error if no alternative is open when the selective wait statement is executed,
and this raises the Program_Error exception.

Ex. 4

task Cyclic_Buffer_Task_Type is
entry Insert (An_Item : in Item);
entry Remove (An_Item : out Item);
end Cyclic_Buffer_Task_Type;
...
task body Cyclic_Buffer_Task_Type is
Q_Size : constant := 100;
subtype Q_Range is Positive range 1 .. Q_Size;
Length : Natural range 0 .. Q_Size := 0;
Head, Tail : Q_Range := 1;
Data : array (Q_Range) of Item;
begin
loop
select
when Length < Q_Size =>
accept Insert (An_Item : in Item) do
Data(Tail) := An_Item;
end Insert;
Tail := Tail mod Q_Size + 1;
Length := Length + 1;
or
when Length > 0 =>
accept Remove (An_Item : out Item) do
An_Item := Data(Head);
end Remove;
Head := Head mod Q_Size + 1;
Length := Length - 1;
end select;
end loop;
end Cyclic_Buffer_Task_Type;

Protected types
Tasks allow for encapsulation and safe usage of variable data without the need for any
explicit mutual exclusion and signaling mechanisms. Ex. 4 shows how easy it is to write
server tasks that safely manage locally-declared data on behalf of multiple clients. There is
no need for mutual exclusion of access to the managed data, because it is never accessed
concurrently. However, the overhead of creating a task merely to serve up some data may be
excessive. For such applications, Ada 95 provides protected modules. A protected module
encapsulates a data structure and exports subprograms that operate on it under automatic
mutual exclusion. It also provides automatic, implicit signaling of conditions between client
tasks. Again, a protected module can be either a single protected object or a protected type,
allowing many protected objects to be created.

A protected module can export only procedures, functions and entries, and its body may
contain only the bodies of procedures, functions and entries. The protected data is declared
after private in its specification, but is accessible only within the protected module's body.
Protected procedures and entries may read and/or write its encapsulated data, and
automatically exclude each other. Protected functions may only read the encapsulated data,
so that multiple protected function calls can with complete safety be concurrently executed
in the same protected object; but protected procedure calls and entry calls exclude protected
function calls, and vice versa. Exported entries and subprograms of a protected object are

79 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

executed by its calling task, as a protected object has no independent locus of control. (To be
honest, optimized object code may reduce the number of context switches below the number
implied by this naive description.)

Like a task entry, a protected entry can employ a guard to control admission. This provides
automatic signaling, and ensures that when a protected entry call is accepted, its guard
condition is True, so that a guard provides a reliable precondition for the entry body.

Ex. 5 The following is a simple protected type analogous to the Encapsulated_Buffer task in
Ex. 2.

protected type Protected_Buffer_Type is

entry Insert (An_Item : in Item);
entry Remove (An_Item : out Item);
private
Buffer : Item;
Empty : Boolean := True;
end Protected_Buffer_Type;
...
protected body Protected_Buffer_Type is
entry Insert (An_Item : in Item)
when Empty is
begin
Buffer := An_Item;
Empty := False;
end Insert;
entry Remove (An_Item : out Item)
when not Empty is
begin
An_Item := Buffer;
Empty := True;
end Remove;
end Protected_Buffer_Type;

Note how the guards, using the state variable Empty, ensure that messages are alternately
inserted and removed, and that no attempt can be made to take data from an empty buffer.
All this is achieved without explicit signaling or mutual exclusion constructs, whether in the
calling task or in the protected type itself.

The notation for calling a protected entry or procedure is exactly the same as that for calling
a task entry. This makes it easy to replace one implementation of the abstract type by the
other, the calling code being unaffected.

Ex. 6 The following task type implements Dijkstra's semaphore ADT, with FIFO scheduling of
resumed processes. The algorithm will accept calls to both Wait and Signal, so long as the
semaphore invariant would not be violated. When that circumstance approaches, calls to
Wait are ignored for the time being.

task type Semaphore_Task_Type is

entry Initialize (N : in Natural);
entry Wait;
entry Signal;
end Semaphore_Task_Type;
...
task body Semaphore_Task_Type is
Count : Natural;
begin
accept Initialize (N : in Natural) do
Count := N;
end Initialize;
loop
select
when Count > 0 =>
accept Wait do
Count := Count - 1;
end Wait;
or
accept Signal;
Count := Count + 1;
end select;
end loop;
end Semaphore_Task_Type;

This task could be used as follows:

80 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

nr_Full, nr_Free : Semaphore_Task_Type;

...
nr_Full.Initialize (0); nr_Free.Initialize (nr_Slots);
...
nr_Free.Wait; nr_Full.Signal;

Alternatively, semaphore functionality can be provided by a protected object, with major

efficiency gains.

Ex. 7 The Initialize and Signal operations of this protected type are unconditional, so they
are implemented as protected procedures, but the Wait operation must be guarded and is
therefore implemented as an entry.

protected type Semaphore_Protected_Type is

procedure Initialize (N : in Natural);
entry Wait;
procedure Signal;
private
Count : Natural := 0;
end Semaphore_Protected_Type;
...
protected body Semaphore_Protected_Type is
procedure Initialize (N : in Natural) is
begin
Count := N;
end Initialize;
entry Wait
when Count > 0 is
begin
Count := Count - 1;
end Wait;
procedure Signal is
begin
Count := Count + 1;
end Signal;
end Semaphore_Protected_Type;

Unlike the task type above, this does not ensure that Initialize is called before Wait or Signal,
and Count is given a default initial value instead. Restoring this defensive feature of the task
version is left as an exercise for the reader.

Entry families
Sometimes we need a group of related entries. Entry families, indexed by a discrete type,
meet this need.

Ex. 8 This task provides a pool of several buffers.

81 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

type Buffer_Id is Integer range 1 .. nr_Bufs;

...
task Buffer_Pool_Task is
entry Insert (Buffer_Id) (An_Item : in Item);
entry Remove (Buffer_Id) (An_Item : out Item);
end Buffer_Pool_Task;
...
task body Buffer_Pool_Task is
Data : array (Buffer_Id) of Item;
Filled : array (Buffer_Id) of Boolean := (others => False);
begin
loop
for I in Data'Range loop
select
when not Filled(I) =>
accept Insert (I) (An_Item : in Item) do
Data(I) := An_Item;
end Insert;
Filled(I) := True;
or
when Filled(I) =>
accept Remove (I) (An_Item : out Item) do
An_Item := Data(I);
end Insert;
Filled(I) := False;
else
null; -- N.B. "polling" or "busy waiting"
end select;
end loop;
end loop;
end Buffer_Pool_Task;
...
Buffer_Pool_Task.Remove(K)(This_Item);

Note that the busy wait else null is necessary here to prevent the task from being
suspended on some buffer I when there was no call pending for it, because such suspension
would delay serving requests for all the other buffers (perhaps indefinitely).

Termination
Server tasks often contain infinite loops to allow them to service an arbitrary number of calls
in succession. But control cannot leave a task's master until the task terminates, so we need
a way for a server to know when it should terminate. This is done by a terminate alternative
in a selective wait.

Ex. 9

task type Terminating_Buffer_Task_Type is

entry Insert (An_Item : in Item);
entry Remove (An_Item : out Item);
end Terminating_Buffer_Task_Type;
...
task body Terminating_Buffer_Task_Type is
Datum : Item;
begin
loop
select
accept Insert (An_Item : in Item) do
Datum := An_Item;
end Insert;
or
terminate;
end select;
select
accept Remove (An_Item : out Item) do
An_Item := Datum;
end Remove;
or
terminate;
end loop;
end Terminating_Buffer_Task_Type;

The task terminates when:

1. at least one terminate alternative is open, and

2. there are no pending calls to its entries, and
3. all other tasks of the same master are in the same state (or already terminated), and
4. the task's master has completed (i.e. has run out of statements to execute).

82 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Conditions (1) and (2) ensure that the task is in a fit state to stop. Conditions (3) and (4)
ensure that stopping cannot have an adverse effect on the rest of the program, because no
further calls that might change its state are possible.

Timeout
A task may need to avoid being held up by calling to a slow server. A timed entry call lets a
client specify a maximum delay before achieving rendezvous, failing which the attempted
entry call is withdrawn and an alternative sequence of statements is executed.

Ex. 10

task Password_Server is
entry Check (User, Pass : in String; Valid : out Boolean);
entry Set (User, Pass : in String);
end Password_Server;
...
User_Name, Password : String (1 .. 8);
...
Put ("Please give your new password:");
Get_Line (Password);
select
Password_Server.Set (User_Name, Password);
Put_Line ("Done");
or
delay 10.0;
Put_Line ("The system is busy now, please try again later.");
end select;

To time out the functionality provided by a task, two distinct entries are needed: one to pass
in arguments, and one to collect the result. Timing out on rendezvous with the latter
achieves the desired effect.

Ex. 11

task Process_Data is
entry Input (D : in Datum);
entry Output (D : out Datum);
end Process_Data;
Input_Data, Output_Data : Datum;

loop
collect Input_Data from sensors;
Process_Data.Input (Input_Data);
select
Process_Data.Output (Output_Data);
pass Output_Data to display task;
or
delay 0.1;
Log_Error ("Processing did not complete quickly enough.");
end select;
end loop;

Symmetrically, a delay alternative in a selective wait statement allows a server task to

withdraw an offer to accept calls after a maximum delay in achieving rendezvous with any
client.

Ex. 12

83 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

task Resource_Lender is
entry Get_Loan (Period : in Duration);
entry Give_Back;
end Resource_Lender;
...
task body Resource_Lender is
Period_Of_Loan : Duration;
begin
loop
select
accept Get_Loan (Period : in Duration) do
Period_Of_Loan := Period;
end Get_Loan;
select
accept Give_Back;
or
delay Period_Of_Loan;
Log_Error ("Borrower did not give up loan soon enough.");
end select;
or
terminate;
end select;
end loop;
end Resource_Lender;

Conditional entry calls

An entry call can be made conditional, so that it is withdrawn if rendezvous is not
immediately achieved. This uses the select statement notation with an else part. The
constructs:

select
...
else
...
end select;

and

select
...
or
delay 0.0
...
end select;

are equivalent.

Requeue statements
A requeue statement allows an accept statement or entry body to be completed while
redirecting to a different or the same entry queue. The called entry has to share the same
parameter list or be parameter-less.

Scheduling
FIFO, priority, priority inversion avoidance, ... to be completed

Interfaces
This language feature will be made available in the forthcoming Ada 2005 standard.

Task and Protected types can also implement interfaces.

84 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

type Printable is task interface;

procedure Input (D : in Printable);

task Process_Data is new Printable with

entry Input (D : in Datum);
entry Output (D : out Datum);
end Process_Data;

See also
Wikibook
Ada Programming

Ada Reference Manual

Ada 95

Section 9: Tasks and Synchronization

(http://www.adaic.com/standards/95lrm/html/RM-9.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-9.html) )

Ada 2005

3.9.4 Interface Types (http://www.adaic.com/standards/rm-amend/html/RM-3-9-4.html)

(Annotated (http://www.adaic.com/standards/rm-amend/html/AA-3-9-4.html) )
Section 9: Tasks and Synchronization
(http://www.adaic.com/standards/rm-amend/html/RM-9.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-9.html) )

Ada Quality and Style Guide

Chapter 4: Program Structure
4.1.9 Tasks (http://www.adaic.org/docs/95style/html/sec_4/4-1-9.html)
4.1.10 Protected Types (http://www.adaic.org/docs/95style/html/sec_4/4-1-10.html)
Chapter 6: Concurrency (http://www.adaic.org/docs/95style/html/sec_6/toc.html)

Object Orientation

Object-orientation on Ada
An Ada class consists of three building blocks:

a package
a record (data storage)
primitive operations (methods).

This is different from C++ which has no concept of a package.

Note: Rigorously the meaning of the term class is different in Ada than in C++, Java and
others. In Ada, a class is a special type whose values are those of the union of all the types
derived from a given tagged type, called the class-wide type. In C++, the term class is a bit
polysemic, it does mean the former concept, and it is a concrete type with operations
associated, and finally a construct to define them.

85 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

The package
Every class has to be defined inside a package. One package may contain more than one
class. You might be surprised about that requirement but you should remember that every
class needs some housekeeping information which has to be kept somewhere; in Ada this
housekeeping information is part of the package.

A little note for C++ programmers

If you have ever, when linking a C++ program, got an error message telling you that the
virtual function table for class X was not found then you might appreciate this restriction. In
Ada you never get this error message - the Ada equivalent of the virtual function table is part
of the package. The same goes for the Ada equivalent of a virtual inline function, another
cause of trouble when linking C++ programs - and they too work flawlessly in Ada.

The tagged record

A tagged type provides support for dynamic polymorphism and type extension in Ada. A
tagged type bears a hidden tag that identifies the type and its position in the inheritance tree
at run-time. It also provides the means of storing instance data.

package Person is
type Object is tagged
record
Name : String (1 .. 10);
Gender : Gender_Type;
end record;
end Person;

with Person;
package Programmer is

type Object is new Person.Object with

record
Skilled_In : Language_List;
end record;
end Programmer;

The class-wide type

Whenever you declare a tagged type, the compiler will also provide a Class type for you. This
type is called a class-wide type. Beginners often consider the class-wide type as some
abstract concept. But this is not true! The Class type is a real data type. You can declare
variables of the class-wide type, assign values to them, use the class-wide type as a
parameter to functions and procedures and so forth.

The interesting part is that the class-wide type can hold values of any child class of the
declared base type; in fact, there are no objects of this class-wide type - an object always is
of a specific child type. This means that, unlike with most other object-oriented programming
languages, you do not need to resort to the use of heap memory for storing arbitrary
members of a class family but you can use the Class type instead.

Since the size of the child class is not known at compile time, any class-wide type is an
indefinite subtype.

Primitive operations
The primitive operations of a given tagged type are those having a parameter or return value
of this type and are declared immediately in the same package as the type.

86 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Primitive operations are inherited and can be overridden for derived types.

Examples:

package X is
type Object is tagged null record;

procedure Class_Member_1 (This : in Object);

procedure Class_Member_2 (This : out Object);
procedure Class_Member_3 (This : in out Object);
procedure Class_Member_4 (This : access Object);
function Class_Member_5 return Object;

end X;

A note for C++ programers: Class types are "by reference types" - they are always passed to
a subprogram by using a pointer and never use "call by value" - using an access explicitly is
therefore seldom needed.

Please note that neither named access types nor class-wide types qualify as class members.
Procedures and functions having those as a parameter are just normal subprograms sharing
the same package without belonging to the class.

Examples:

package X is

type Object is tagged null record;

type Object_Access is access Object;
type Object_Class_Access is access Object'Class;
procedure No_Class_Member_1 (This : in Object'Class);
procedure No_Class_Member_2 (This : in out Object_Access);
procedure No_Class_Member_2 (This : out Object_Class_Access);
function No_Class_Member_4 return Object'Class;

package Inner is

procedure No_Class_Member_5 (This : in Object);

end Inner;

end X;

Note for C++ programmers: Procedures and functions like these can serve the same purpose
as "non virtual" and "static" methods have in C++.

This language feature will be made available in the forthcoming Ada 2005 standard.

The keyword overriding can be used to indicate whether an operation is overriding an

inherited subprogram. For example:

87 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

package X is

type Object is tagged null record;

procedure Class_Member_1 (This : in Object);
procedure Class_Member_2 (This : in out Object);
function Class_Member_3 return Object;

type Derived_Object is new Object with null record;

overriding
procedure Class_Member_1 (This : in Derived_Object);
-- 'Class_Member_2' is not overridden

overriding
function Class_Member_3 return Derived_Object;

not overriding
function New_Class_Member_1 return Derived_Object;

end X;

The compiler will check the desired behaviour.

This is a good programming practice because it avoids some nasty bugs like not overriding
an inherited subprogram because the programmer spelt the identifier incorrectly, or because
a new parameter is added later in the parent type.

It can also be used with abstract operations, with renamings, or when instantiating a generic
subprogram:

not overriding
procedure Class_Member_1 (This : in Object) is abstract;
overriding
function Class_Member_2 return Object renames Old_Class_Member;

not overriding
procedure Class_Member_3 (This : out Object)
is new Generic_Procedure (Element => Integer);

Interfaces
This language feature will be made available in the forthcoming Ada 2005 standard.

Interfaces allow for a limited form of multiple inheritance. On a sematic level they are similar
to an "abstract tagged null record" as they may have primitive operations but cannot hold
any data. These operations cannot have a body, so they are either declared abstract or null.
Abstract means the operation has to be overridden, null means the default implementation is
a null body, i.e. one that does nothing.

An interface is declared with:

package Printable is

type Object is interface;

procedure Class_Member_1 (This : in Object) is abstract;
procedure Class_Member_2 (This : out Object) is null;
end Printable;

You implement an interface by adding it to a concrete class:

88 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

with Person;

package Programmer is
type Object is new Person.Object
and Printable.Object
with
record
Skilled_In : Language_List;
end record;

overriding
procedure Class_Member_1 (This : in Object);

not overriding
procedure New_Class_Member (This : Object; That : String);

end Programmer;

As usual, all inherited abstract operations must be overriden altough null subprograms ones
need not.

Class names
Both the class package and the class record need a name. In theory they may have the same
name, but in practice this leads to nasty (because of unintutive error messages) name clashes when
you use the use clause. So over time three de facto naming standards have been commonly
used.

Classes/Class
The package is named by a plural noun and the record is named by the corresponding
singular form.

package Persons is
type Person is tagged
record
Name : String (1 .. 10);
Gender : Gender_Type;
end record;
end Persons;

This convention is the usually used in Ada's built-in libraries.

Disadvantage: Some "multiples" are tricky to spell, especially for those of us who aren't
native English speakers.

Class/Object
The package is named after the class, the record is just named Object.

package Person is
type Object is tagged
record
Name : String (1 .. 10);
Gender : Gender_Type;
end record;
end Person;

Most UML and IDL code generators use this technique.

Disadvantage: You can't use the use clause on more than one such class packages at any one
time. However you can always use the "type" instead of the package.

Class/Class_Type

89 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

The package is named after the class, the record is postfixed with _Type.

package Person is
type Person_Type is tagged
record
Name : String (1 .. 10);
Gender : Gender_Type;
end record;
end Person;

Disadvantage: lots of ugly "_Type" postfixes.

See also
Wikibook
Ada Programming
Ada Programming/Types/record
record
interface
tagged

Wikipedia
Object-oriented programming

Ada Reference Manual

Ada 95

3.8 Record Types (http://www.adaic.com/standards/95lrm/html/RM-3-8.html) (Annotated

(http://www.adaic.com/standards/95aarm/html/AA-3-8.html) )
3.9 Tagged Types and Type Extensions
(http://www.adaic.com/standards/95lrm/html/RM-3-9.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-3-9.html) )
3.9.1 Type Extensions (http://www.adaic.com/standards/95lrm/html/RM-3-9-1.html)
(Annotated (http://www.adaic.com/standards/95aarm/html/AA-3-9-1.html) )
3.9.2 Dispatching Operations of Tagged Types
(http://www.adaic.com/standards/95lrm/html/RM-3-9-2.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-3-9-2.html) )
3.9.3 Abstract Types and Subprograms
(http://www.adaic.com/standards/95lrm/html/RM-3-9-3.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-3-9-3.html) )
3.10 Access Types (http://www.adaic.com/standards/95lrm/html/RM-3-10.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-3-10.html) )

Ada 2005

3.8 Record Types (http://www.adaic.com/standards/rm-amend/html/RM-3-8.html)

(Annotated (http://www.adaic.com/standards/rm-amend/html/AA-3-8.html) )
3.9 Tagged Types and Type Extensions
(http://www.adaic.com/standards/rm-amend/html/RM-3-9.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-3-9.html) )
3.9.1 Type Extensions (http://www.adaic.com/standards/rm-amend/html/RM-3-9-1.html)
(Annotated (http://www.adaic.com/standards/rm-amend/html/AA-3-9-1.html) )
3.9.2 Dispatching Operations of Tagged Types
(http://www.adaic.com/standards/rm-amend/html/RM-3-9-2.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-3-9-2.html) )
3.9.3 Abstract Types and Subprograms
(http://www.adaic.com/standards/rm-amend/html/RM-3-9-3.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-3-9-3.html) )
3.9.4 Interface Types (http://www.adaic.com/standards/rm-amend/html/RM-3-9-4.html)
(Annotated (http://www.adaic.com/standards/rm-amend/html/AA-3-9-4.html) )
3.10 Access Types (http://www.adaic.com/standards/rm-amend/html/RM-3-10.html)

90 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

(Annotated (http://www.adaic.com/standards/rm-amend/html/AA-3-10.html) )

Ada Quality and Style Guide

Chapter 9: Object-Oriented Features (http://www.adaic.org/docs/95style/html/sec_9/)

Ada 2005
This is an overview of the major features that will be available in the upcoming Ada 2005
(sometimes refered as Ada 200Y or Ada 2006). For the rationale and a more detailed (and
very technical) description, see the draft of the Amendment
(http://www.ada-auth.org/AI-XREF.HTML#Amend_Doc) to the Ada Reference Manual
following the links to the last version of every Ada Issue document (AI).

Although the standard is not published yet, it is possible to test some of its new features
right now. Many of these additions are totally implemented by the following Free Software
compilers:

GNAT GPL Edition (http://libre.adacore.com/)

GCC 4.0 (http://gcc.gnu.org/)

After downloading and installing any of them, remember to use the -gnat05 switch when
compiling Ada 2005 code.

Language features
Character set
Not only does Ada 2005 now support a new 32-bit character type — called
Wide_Wide_Character — but the source code itself may be of this extended character set as
well. Thus Russians and Indians, for example, will be able to use their native language in
identifiers and comments. And mathematicians will rejoice: The whole Greek and fractur
character sets are available for identifiers. For example, Ada.Numerics will be extended with
a new constant:

π : constant := Pi;

This is not a new idea – GNAT always had the -gnatic compiler option to specify the
character set [1] (http://gcc.gnu.org/onlinedocs/gnat_ugn_unw/Character-Set-Control.html) .
But now this idea will become standard, so all Ada compilers will need to support Unicode
4.0 for identifiers —as the new standard requires.

See also:

AI-00285 Support for 16-bit and 32-bit characters

(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00285.TXT)
AI-00388 Add Greek pi to Ada.Numerics
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00388.TXT)

Interfaces
Interfaces allow for a limited form of multiple inheritance similar to Java and C#.

You find a full description here: Ada Programming/OO.

See also:

91 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

AI-00251 Abstract Interfaces to provide multiple inheritance

(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00251.TXT)
AI-00345 Protected and task interfaces
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00345.TXT)

Union
In addition to Ada's safe variant record an unchecked C style union is now available.

You can find a full description here: Ada Programming/Types/record#Union.

See also:

AI-00216 Unchecked unions -- variant records with no run-time discriminant

(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00216.TXT)
Annex B.3.3 Pragma Unchecked_Union
(http://www.adaic.com/standards/rm-amend/html/RM-B-3-3.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-B-3-3.html) )

With
The with statement got a massive upgrade. First there is the new limited with which allows
two packages to with each other. Then there is private with to make a package only visible
inside the private part of the specification. The latter also allows to make child units visible.

See also:

AI-50217 Limited With Clauses

(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-50217.TXT)
AI-00262 Access to private units in the private part
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00262.TXT)

Access types
Not null access

An access type definition can specify that the access type can never be null.

See Ada Programming/Types/access#Not null access.

See also: AI-00231 Access-to-constant parameters and null-excluding access subtypes

(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00231.TXT)

Anonymous access

The possible uses of anonymous access types are extended. They are allowed virtually in
every type or object definition, including access to subprogram parameters. Anonymous
access types may point to constant objects as well. Also, they could be declared to be not
null.

With the addition of the following operations in package Standard, it is possible to test the
equality of anonymous access types.

function "=" (Left, Right : universal_access) return Boolean;

function "/="(Left, Right : universal_access) return Boolean;

See Ada Programming/Types/access#Anonymous access.

See also:

AI-00230 Generalized use of anonymous access types

(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00230.TXT)

92 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

AI-00385 Stand-alone objects of anonymous access types

(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00385.TXT)
AI-10318 Limited and anonymous access return types
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-10318.TXT)

Language library
Container
The main addition to the language library is the generic packages for containers. If you are
familiar with the C++ STL, you will likely feel very much at home using Ada.Containers.

The AI text is AI-20302 Container library

(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-20302.TXT) .

If you know how to write Ada programs, and have a need for vectors, sets, or maps (tables),
please have a look at the AI-20302 AI Text
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-20302.TXT) mentioned above. There is an
!examples section in the text explaining the use of the containers in some detail. Matthew
Heaney provides a number of demonstration programs with his reference implementation of
AI-302 (Ada.Containers) which you can find at tigris (http://charles.tigris.org) .

In Ada Programming/Containers you will find a demo using containers.

Scan Filesystem Directories and Environment Variables

See also:

AI-00248 Directory Operations

(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00248.TXT)
AI-00370 Environment variables
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00370.TXT)

Numerics
Besides the new constant of package Ada.Numerics (see Character Set above), the most
important addition are the packages to operate with vectors and matrices.

See also:

AI-00388 Add Greek pi to Ada.Numerics

(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00388.TXT)
AI-00296 Vector and matrix operations
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00296.TXT)

Real-Time and High Integrity Systems

See also:

AI-00297 Timing events (http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00297.TXT)

AI-00307 Execution-Time Clocks
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00307.TXT)
AI-00354 Group execution-time budgets
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00354.TXT)
AI-10266 Task termination procedure
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-10266.TXT)
AI-00386 Further functions returning Time_Span values
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00386.TXT)

Ravenscar profile
See also:

93 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

AI-00249 Ravenscar profile for high-integrity systems

(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00249.TXT)
AI-00305 New pragma and additional restriction identifiers for real-time systems
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00305.TXT)
AI-00347 Title of Annex H
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00347.TXT)
AI-00265 Partition Elaboration Policy for High-Integrity Systems
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00265.TXT)

New scheduling policies

See also:

AI-00355 Priority Specific Dispatching including Round Robin

(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00355.TXT)
AI-00357 Support for Deadlines and Earliest Deadline First Scheduling
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00357.TXT)
AI-00298 Non-Preemptive Dispatching
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00298.TXT)

Dynamic priorities for protected objects

See also: AI-00327 Dynamic ceiling priorities
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00327.TXT)

Summary of what's new

New keywords
interface
overriding
synchronized

New pragmas
pragma Assert
pragma Assertion_Policy
pragma Detect_Blocking
pragma No_Return
pragma Partition_Elaboration_Policy
pragma Preelaborable_Initialization
pragma Priority_Specific_Dispatching
pragma Profile
pragma Unsuppress
pragma Unchecked_Union

New attributes
Machine_Rounding
Mod
Priority
Wide_Wide_Image
Wide_Wide_Value
Wide_Wide_Width

New packages
Assertions:
Ada.Assertions
Container library:
Ada.Containers
Ada.Containers.Vectors
Ada.Containers.Doubly_Linked_Lists
Ada.Containers.Generic_Array_Sort (generic procedure)

94 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Ada.Containers.Generic_Constrained_Array_Sort (generic procedure)

Ada.Containers.Hashed_Maps
Ada.Containers.Ordered_Maps
Ada.Containers.Hashed_Sets
Ada.Containers.Ordered_Sets
Ada.Containers.Indefinite_Vectors
Ada.Containers.Indefinite_Doubly_Linked_Lists
Ada.Containers.Indefinite_Hashed_Maps
Ada.Containers.Indefinite_Ordered_Maps
Ada.Containers.Indefinite_Hashed_Sets
Ada.Containers.Indefinite_Ordered_Sets
Vector and matrix manipulation:
Ada.Numerics.Real_Arrays
Ada.Numerics.Complex_Arrays
Ada.Numerics.Generic_Real_Arrays
Ada.Numerics.Generic_Complex_Arrays

General OS facilities:
Ada.Directories
Ada.Directories.Information
Ada.Environment_Variables

String hashing:
Ada.Strings.Hash (generic function)
Ada.Strings.Fixed.Hash (generic function)
Ada.Strings.Bounded.Hash (generic function)
Ada.Strings.Unbounded.Hash (generic function)
Ada.Strings.Wide_Hash (generic function)
Ada.Strings.Wide_Fixed.Wide_Hash (generic function)
Ada.Strings.Wide_Bounded.Wide_Hash (generic function)
Ada.Strings.Wide_Unbounded.Wide_Hash (generic function)
Ada.Strings.Wide_Wide_Hash (generic function)
Ada.Strings.Wide_Wide_Fixed.Wide_Wide_Hash (generic function)
Ada.Strings.Wide_Wide_Bounded.Wide_Wide_Hash (generic function)
Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Hash (generic function)
Time operations:
Ada.Calendar.Time_Zones
Ada.Calendar.Arithmetic
Ada.Calendar.Formatting
Tagged types:
Ada.Tags.Generic_Dispatching_Constructor (generic function)

Text packages:
Ada.Complex_Text_IO
Ada.Text_IO.Bounded_IO
Ada.Text_IO.Unbounded_IO
Ada.Wide_Text_IO.Bounded_IO
Ada.Wide_Text_IO.Unbounded_IO
Ada.Wide_Characters
Ada.Wide_Wide_Characters
Wide_Wide_Character packages:
Ada.Strings.Wide_Wide_Bounded
Ada.Strings.Wide_Wide_Fixed
Ada.Strings.Wide_Wide_Maps
Ada.Strings.Wide_Wide_Maps.Wide_Wide_Constants
Ada.Strings.Wide_Wide_Unbounded
Ada.Wide_Wide_Text_IO
Ada.Wide_Wide_Text_IO.Complex_IO
Ada.Wide_Wide_Text_IO.Editing
Ada.Wide_Wide_Text_IO.Text_Streams
Ada.Wide_Wide_Text_IO.Unbounded_IO
Execution-time clocks:
Ada.Execution_Time
Ada.Execution_Time.Timers

95 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Ada.Execution_Time.Group_Budgets
Dispatching:
Ada.Dispatching
Ada.Dispatching.EDF
Ada.Dispatching.Round_Robin
Timing events:
Ada.Real_Time.Timing_Events
Task termination procedures:
Ada.Task_Termination

See also
Wikibook
Ada Programming/Object Orientation
Ada Programming/Types/access
Ada Programming/Keywords
Ada Programming/Keywords/and
Ada Programming/Keywords/interface
Ada Programming/Attributes
Ada Programming/Pragmas
Ada Programming/Pragmas/Restrictions
Ada Programming/Libraries/Ada.Containers
Ada Programming/Libraries/Ada.Directories

Pages in the category Ada 2005

Category:Ada Programming/Ada 2005 feature

External links
Papers and presentations
Ada 2005: Putting it all together
(http://www.sigada.org/conf/sigada2004/SIGAda2004-CDROM/SIGAda2004-Proceedings/Ada200
(SIGAda 2004 presentation)
GNAT: The road to Ada 2005
(http://www.adacore.com/multimedia/pdfs/Ada2005_AdaSpain05.pdf) (Ada-Spain 2005
presentation)
GNAT and Ada 2005 (http://www.adacore.com/multimedia/pdfs/GNAT_and_Ada2005.pdf)
, and the presentation of this paper
(http://www.adacore.com/multimedia/pdfs/Ada2005_SIGAda.pdf) at SIGAda 2004
An invitation to Ada 2005
(http://sigada.org/ada_letters/sept2003/Invitation_to_Ada_2005.pdf) , and the
presentation of this paper
(http://www.cs.kuleuven.ac.be/~dirk/ada-belgium/events/04/040616-aec-ada2005.pdf) at
Ada-Europe 2004

Rationale
Rationale for Ada 2005 by John Barnes:

Introduction (http://www.adacore.com/multimedia/pdfs/Ada05_rational_00.pdf)
Object Oriented Model (http://www.adacore.com/multimedia/pdfs/Ada05_rational_01.pdf)
Access Types (http://www.adacore.com/multimedia/pdfs/Ada05_rational_02.pdf)
Structure and Visibility
(http://www.adacore.com/multimedia/pdfs/Ada05_rational_03.pdf)
Tasking and Real-Time (http://www.adacore.com/multimedia/pdfs/Ada05_rational_04.pdf)
Exceptions, Generics, Etc.
(http://www.adacore.com/multimedia/pdfs/Ada05_rational_05.pdf)

Language Requirements

96 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Instructions to the Ada Rapporteur Group from SC22/WG9 for Preparation of the
Amendment to ISO/IEC 8652 (http://www.open-std.org/jtc1/sc22/WG9/n412.pdf) (10
October 2002), and a presentation of this document
(http://std.dkuug.dk/JTC1/sc22/wg9/n423.pdf) at SIGAda 2002

Ada Reference Manual

Ada Reference Manual, ISO/IEC 8652:1995(E) with COR.1:2001 and AMD.1:200y
(http://www.adaic.com/standards/05rm/html/RM-TTL.html) (Draft)
Annotated Ada Reference Manual, ISO/IEC 8652:1995(E) with COR.1:2001 and
AMD.1:200y (http://www.adaic.com/standards/05aarm/html/AA-TTL.html) (Draft with
colored diffs)
List of Ada Amendment drafts (http://www.ada-auth.org/amendment.html)

Ada Issues
Amendment 200Y (http://www.ada-auth.org/AI-XREF.HTML#Amend_Doc)
AI-00387 Introduction to Amendment
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00387.TXT)
AI-10284 New reserved words
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-10284.TXT)
AI-00252 Object.Operation notation
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00252.TXT)
AI-20218 Accidental overloading when overriding
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-20218.TXT)
AI-00348 Null procedures
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00348.TXT)
AI-00287 Limited aggregates allowed
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00287.TXT)
AI-00326 Incomplete types
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00326.TXT)
AI-00317 Partial parameter lists for formal packages
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00317.TXT)
AI-00376 Interfaces.C works for C++ as well
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00376.TXT)
AI-00368 Restrictions for obsolescent features
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00368.TXT)
AI-00381 New Restrictions identifier No_Dependence
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00381.TXT)
AI-00224 pragma Unsuppress
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00224.TXT)
AI-00161 Default-initialized objects
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00161.TXT)
AI-00361 Raise with message
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00361.TXT)
AI-00286 Assert pragma
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00286.TXT)
AI-00328 Preinstantiations of Complex_IO
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00328.TXT)
AI-00301 Operations on language-defined string types
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00301.TXT)
AI-00340 Mod attribute
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00340.TXT)
AI-00364 Fixed-point multiply/divide
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00364.TXT)
AI-00267 Fast float-to-integer conversions
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00267.TXT)
AI-00321 Definition of dispatching policies
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00321.TXT)
AI-00329 pragma No_Return -- procedures that never return
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00329.TXT)
AI-00362 Some predefined packages should be recategorized
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00362.TXT)
AI-00351 Time operations
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00351.TXT)
AI-00427 Default parameters and Calendar operations
(http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00427.TXT)

97 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Tips

Full declaration of a type can be deferred to the unit's

body
Often, you'll want to make changes to the internals of a private type. This, in turn, will
require the algorithms that act on it to be modified. If the type is completed in the unit
specification, it is a pain to edit and recompile both files, even with an IDE, but it's
something some programmers learn to live with.

It turns out you don't have to. Nonchalantly mentioned in the ARM
(http://www.adaic.org/standards/95lrm/html/RM-TTL.html) , and generally skipped over in
tutorials, (at least, the ones that I've read) is the fact that private types can be completed in
the unit's body itself, making them much closer to the relevant code, and saving a recompile
of the specification, as well as every unit depending on it. This may seem like a small thing,
and, for small projects, it is. However, if you have one of those uncooperative types that
requires dozens of tweaks, or if your dependence graph has much depth, the time and
annoyance saved add up quickly.

Also, this construction is very useful when coding a shared library, because it permits change
the implementation of the type while still providing a compatible ABI.

Code sample:

package Private_And_Body is
type Private_Type is limited private;

-- Operations...
private
type Body_Type; -- Defined in the body
type Private_Type is access Body_Type;
end Private_And_Body;

The type in the public part is an access to the hidden type. This has the drawback that
memory management has to be provided by the package implementation. That is the reason
why Private_Type is a limited type, the client will not be allowed to copy the access values,
in order to prevent dangling references.

These types are sometimes called "Taft types" --named after Tucker Taft, the main designer
of Ada 95-- because were introduced in the so-called Taft Amendment to Ada 83. In other
programming languages, this construction is called opaque pointers".

Lambda calculus through generics

Suppose you've decided to roll your own set type. You can add things to it, remove things
from it, and you want to let a user apply some arbitrary function to all of its members. But
the scoping rules seem to conspire against you, forcing nearly everything to be global.

The mental stumbling block is that most examples given of generics are packages, and the
Set package is already generic. In this case, the solution is to make the Apply_To_All
procedure generic as well; that is, to nest the generics. Generic procedures inside packages
exist in a strange scoping limbo, where anything in scope at the instantiation can be used by
the instantiation, and anything normally in scope at the formal can be accessed by the
formal. The end result is that the relevant scoping roadblocks no longer apply. It isn't the full

98 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

lambda calculus, just one of the most useful parts.

generic
type Element is private;
package Sets is
type Set is private;
[..]
generic
with procedure Apply_To_One (The_Element : in out Element);
procedure Apply_To_All (The_Set : in out Set);
end Sets;

See also
Wikibook
Ada Programming

Ada Reference Manual

3.10.1 Incomplete Type Declarations
(http://www.adaic.com/standards/95lrm/html/RM-3-10-1.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-3-10-1.html) )

Algorithms

Introduction
Welcome to the Ada implementations of the Computer Science:Algorithms. For those who
are new to Ada Programming a few notes:

All examples are fully functional with all the needed input and output operations.
However, only the code needed to outline the algorithms at hand is copied into the text -
the full samples are available via the download links. (Note: It can take up to 48 hours until the
cvs is updated).
We seldom use predefined types in the sample code but define special types suitable for
the algorithms at hand.
Ada allows for default function parameters; however, we always fill in and name all
parameters, so the reader can see which options are available.
We seldom use shortcuts - like using the attributes Image or Value for String <=>
Integer conversions.

All these rules make the code more elaborate then perhaps needed. However, we also hope it
makes the code easier to understand

Chapter 1: Introduction
The following codes are implementations of the Inventing an Algorithm examples.

To Lower
The Ada example code does not append to the array as the algorithms. Instead we create an
empy arrays of the desired lenght and then replace the characters inside.

99 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

File: to_lower_1.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/to_lower_1.adb?only_with_tag=HEAD&view=markup
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/to_lower_1.adb) , download
page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

function To_Lower (C : Character) return Character renames

Ada.Characters.Handling.To_Lower;
-- tolower - translates all alphabetic, uppercase characters
-- in str to lowercase
function To_Lower (Str : String) return String is
Result : String (Str'Range) := (others => ' ');
begin
for C in Str'Range loop
Result (C) := To_Lower (Str (C));
end loop;
return Result;
end To_Lower;

Would the append appoach be impossible with Ada. No - but it would be significantly more
complex and slower.

Equal Ignore Case

File: to_lower_2.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/to_lower_2.adb?only_with_tag=HEAD&view=markup
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/to_lower_2.adb) , download
page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

-- equal-ignore-case -- returns true if s or t are equal,

-- ignoring case
function Equal_Ignore_Case
(S : String;
T : String)
return Boolean
is
O : constant Integer := S'First - T'First;
begin
if T'Length /= S'Length then
return False; -- if they aren't the same length, they
-- aren't equal
else
for I in S'Range loop
if To_Lower (S (I)) /=
To_Lower (T (I + O))
then
return False;
end if;
end loop;
end if;
return True;
end Equal_Ignore_Case;

Chapter 6: Dynamic Programming

Fibonacci numbers
The following codes are implementations of the Fibonacci-Numbers examples.

Simple Implementation

File: fibonacci_1.adb (view as markup

100 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/fibonacci_1.adb?only_with_tag=HEAD&view=marku
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/fibonacci_1.adb) , download
page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

...

To calculate Fibonacci numbers negative values are not needed so we define an integer type
which starts at 0. With the integer type defined you can calculate up until Fib (87). Fib
(88) will result in an Constraint_Error.

type Integer_Type is range 0 .. 999_999_999_999_999_999;

You might notice that there is not equivalence for the assert (n >= 0) from the original
exapmle. Ada will test the correctness of the parameter before the function is called.

function Fib (n : Integer_Type) return Integer_Type is

begin
if n = 0 then
return 0;
elsif n = 1 then
return 1;
else
return Fib (n - 1) + Fib (n - 2);
end if;
end Fib;
...

Cached Implementation

File: fibonacci_2.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/fibonacci_2.adb?only_with_tag=HEAD&view=marku
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/fibonacci_2.adb) , download
page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

...

For this implementation we need a special cash type can also store a -1 as "not calculated"
marker

type Cache_Type is range -1 .. 999_999_999_999_999_999;

The actual type for calculating the fibonacci numbers continues to start at 0. As it is a
subtype of the cache type Ada will automaticly convert between the two. (the convertion is - of
course - checked for validity)

subtype Integer_Type is Cache_Type range

0 .. Cache_Type'Last;

In order to know how large the cache need to be we first read the actual value from the
command line.

Value : constant Integer_Type :=

Integer_Type'Value (Ada.Command_Line.Argument (1));

The Cache array starts with element 2 since Fib (0) and Fib (1) are constants and ends with
the value we want to calculate.

101 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

type Cache_Array is
array (Integer_Type range 2 .. Value) of Cache_Type;

The Cache is initialized to the first valid value of the cache type - this is -1.

F : Cache_Array := (others => Cache_Type'First);

What follows is the actual algorithm.

function Fib (N : Integer_Type) return Integer_Type is

begin
if N = 0 or else N = 1 then
return N;
elsif F (N) /= Cache_Type'First then
return F (N);
else
F (N) := Fib (N - 1) + Fib (N - 2);
return F (N);
end if;
end Fib;

...

This implementation is faithful to the original from the Computer Science:Algorithms book.
However, in Ada you would normaly do it a little different:

File: fibonacci_3.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/fibonacci_3.adb?only_with_tag=HEAD&view=marku
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/fibonacci_3.adb) , download
page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

when you use a slightly larger array which also stores the elements 0 and 1 and initializes
then to the correct values

type Cache_Array is
array (Integer_Type range 0 .. Value) of Cache_Type;

F : Cache_Array :=
(0 => 0,
1 => 1,
others => Cache_Type'First);

and then you can remove the first if path.

if N = 0 or else N = 1 then
return N;
elsif F (N) /= Cache_Type'First then

This will save about 45% of the execution-time (measured on Linux i686) while needing only two
more elements in the cache array.

Memory Optimized Implementation

This version looks just like the original in WikiCode.

File: fibonacci_4.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/fibonacci_4.adb?only_with_tag=HEAD&view=marku
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/fibonacci_4.adb) , download
page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

102 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

type Integer_Type is range 0 .. 999_999_999_999_999_999;

function Fib (N : Integer_Type) return Integer_Type is

U : Integer_Type := 0;
V : Integer_Type := 1;
begin
for I in 2 .. N loop
Calculate_Next : declare
T : constant Integer_Type := U + V;
begin
U := V;
V := T;
end Calculate_Next;
end loop;
return V;
end Fib;

No 64 bit integers

Your Ada compiler does not support 64 bit integer numbers? Then you could try to use
decimal numbers instead. Using decimal numbers results in a slower program (takes about
three times as long) but the result will be the same.

The following example shows you how to define a suitable decimal type. Do experiment with
the digits and range parameters until you get the optimum out of your Ada.

File: fibonacci_5.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/fibonacci_5.adb?only_with_tag=HEAD&view=marku
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/fibonacci_5.adb) , download
page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

type Integer_Type is delta 1.0 digits 18 range

0.0 .. 999_999_999_999_999_999.0;

You should know that floating point numbers are unsuitable for the calculation of fibonacci
numbers. They will not report an error condition when the number calculated becomes too
large - instead they will lose in precision which makes the result meaningless.

Function overloading
Description
Function overloading (also polymorphism or method overloading) is a programming
concept that allows programmers to define two or more functions with the same name.

Each function has a unique signature (or header), which is derived from:

1. function/procedure name
2. number of arguments
3. arguments' type
4. arguments' order
5. arguments' name
6. return type

Please note: Not all above signature options are available in all programming languages.

103 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Available functions overloadings

Language 1 2 3 4 5 6
Ada yes yes yes yes yes yes
C++ yes yes yes yes no no
Java yes yes yes yes no no

Warning: Function overloading is often confused with function overriding. In Function

overloading, a function with a different signature is created, adding to the pool of available
functions. In function overriding, however, a function with the same signature is declared,
replacing the old function in the context of the new function.

Demonstration
Since functions' names are in this case the same, we must preserve uniqueness of
signatures, by changing something from the parameter list (last three alienees).

If the functions' signatures are sufficiently different, the compiler can distinguish which
function was intended to be used at each occurence. This process of searching for the
appropriate function is called function resolution and can be quite an intensive one,
especially if there are a lot of equally named functions.

Programming languages supporting implicid type convertions usually use promotion of

arguments (ie.: type casting of integer to floating-point) when there is no exact function
match. The demotion of arguments is rarely used.

When two or more functions match the criteria in function resolution process, an ambiguity
error is reported by compiler. Adding more information to compiler by editing the source
code (using for example type casting), can address such doubts.

The example code shows how function overloading can be used. As functions do practically
the same thing, it makes sense to use function overloading.

File: function_overloading.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/function_overloading.adb?only_with_tag=HEAD&vie
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/function_overloading.adb) ,
download page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

function Generate_Number (MaxValue : Integer) return Integer is

subtype Random_Type is Integer range 0 .. MaxValue;
package Random_Pack is new Ada.Numerics.Discrete_Random (Random_Type);

G : Random_Pack.Generator;
begin
Random_Pack.Reset (G);
return Random_Pack.Random (G);
end Generate_Number;

function Generate_Number (MinValue : Integer;

MaxValue : Integer) return Integer
is
subtype Random_Type is Integer range MinValue .. MaxValue;
package Random_Pack is new Ada.Numerics.Discrete_Random (Random_Type);

G : Random_Pack.Generator;
begin
Random_Pack.Reset (G);
return Random_Pack.Random (G);
end Generate_Number;

calling the first function

The first code block will generate numbers from 0 up to specified parameter MaxValue. The
appropriate function call is:

104 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Number_1 : Integer := Generate_Number (10);

calling the second function

The second requires another parameter MinValue. Function will return numbers above or
equals MinValue and lower than MaxValue.

Number_2 : Integer := Generate_Number (6, 10);

Function overloading in Ada

Ada supports all six signature options but if you use the arguments' name as option you will
allways have to name the parameter when calling the function. i.e.:

Number_2 : Integer := Generate_Number (MinValue => 6,

MaxValue => 10);

Note that you can not overload a generic procedure or generic function within the same
package. The following example will fail to compile:

package myPackage
generic
type Value_Type is (<>);
-- The first declaration of a generic subprogram
-- with the name "Generic_Subprogram"
procedure Generic_Subprogram (Value : in out Value_Type);
...
generic
type Value_Type is (<>);
-- This subprogram has the same name, but no
-- input or output parameters. A non-generic
-- procedure would be overloaded here.
-- Since this procedure is generic, overloading
-- is not allowed and this package will not compile.
procedure Generic_Subprogram;
...
generic
type Value_Type is (<>);
-- The same situation.
-- Even though this is a function and not
-- a procedure, generic overloading of
-- the name "Generic_Subprogram" is not allowed.
function Generic_Subprogram (Value : Value_Type) return Value_Type;
end myPackage;

See also
Wikibook
Ada Programming
Ada Programming/Subprograms

Ada 95 Reference Manual

6.6 Overloading of Operators (http://www.adaic.com/standards/95lrm/html/RM-6-6.html)
(Annotated (http://www.adaic.com/standards/95aarm/html/AA-6-6.html) )
8.6 The Context of Overload Resolution
(http://www.adaic.com/standards/95lrm/html/RM-8-6.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-8-6.html) )

Ada 2005 Reference Manual

6.6 Overloading of Operators

105 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

(http://www.adaic.com/standards/rm-amend/html/RM-6-6.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-6-6.html) )
8.6 The Context of Overload Resolution
(http://www.adaic.com/standards/rm-amend/html/RM-8-6.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-8-6.html) )

Mathematical calculations
Ada is very well suited for all kind of calculations. You can define you own fixed point and
floting point types and - with the aid of generic packages call all the mathematical functions
you need. I that respect Ada is on par with Fortran. This module will show you how to use
them and while we progress we create a simple RPN calculator.

Simple calculations
Addition
Additions can be done using the predefined operator +. The operator is predefined for all
numeric types and the following, working code, demonstrates its use:

File: numeric_1.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/numeric_1.adb?only_with_tag=HEAD&view=markup
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/numeric_1.adb) , download
page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

-- The Package Text_IO (http://www.adaic.org/standards/95lrm/html/RM-A-10-1.html)

with Ada.Text_IO;
procedure Numeric_1 is
type Value_Type is digits 12
range -999_999_999_999.0e999 .. 999_999_999_999.0e999;
package T_IO renames Ada.Text_IO;
package F_IO is new Ada.Text_IO.Float_IO (Value_Type);

Value_1 : Value_Type;
Value_2 : Value_Type;

begin
T_IO.Put ("First Value : ");
F_IO.Get (Value_1);
T_IO.Put ("Second Value : ");
F_IO.Get (Value_2);

F_IO.Put (Value_1);
T_IO.Put (" + ");
F_IO.Put (Value_2);
T_IO.Put (" = ");
F_IO.Put (Value_1 + Value_2);
end Numeric_1;

Subtraction
Subtractions can be done using the predefined operator -. The following extended demo
shows the use of + and - operator together:

File: numeric_2.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/numeric_2.adb?only_with_tag=HEAD&view=markup
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/numeric_2.adb) , download
page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

106 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

-- The Package Text_IO (http://www.adaic.org/standards/95lrm/html/RM-A-10-1.html)

with Ada.Text_IO;

procedure Numeric_2
is
type Value_Type
is digits
12
range
-999_999_999_999.0e999 .. 999_999_999_999.0e999;

package T_IO renames Ada.Text_IO;

package F_IO is new Ada.Text_IO.Float_IO (Value_Type);

Value_1 : Value_Type;
Value_2 : Value_Type;
Result : Value_Type;
Operation : Character;
begin
T_IO.Put ("First Value : ");
F_IO.Get (Value_1);
T_IO.Put ("Second Value : ");
F_IO.Get (Value_2);
T_IO.Put ("Operation : ");
T_IO.Get (Operation);

case Operation is
when '+' =>
Result := Value_1 + Value_2;
when '-' =>
Result := Value_1 - Value_2;
when others =>
T_IO.Put_Line ("Illegal Operation.");
goto Exit_Numeric_2;
end case;
F_IO.Put (Value_1);
T_IO.Put (" ");
T_IO.Put (Operation);
T_IO.Put (" ");
F_IO.Put (Value_2);
T_IO.Put (" = ");
F_IO.Put (Result);

<<Exit_Numeric_2>>
return;

end Numeric_2;

Purists might be surprised about the use of goto - but some people prefer the use of goto
over the use of multiple return statements if inside functions - given that, the opinions on this
topic vary strongly. See the isn't goto evil article.

Multiplication
Multiplicationcan be done using the predefined operator *. For a demo see the next chapter
about Division.

Division
Divisions can be done using the predefined operators /, mod, rem. The operator / performes a
normal division, mod returns a modulus division and rem returns the remainder of the
modulus division.

The following extended demo shows the use of the +, -, * and / operators together as well as
the use of an four number wide stack to store intermediate results:

The operators mod and rem are not part of the demonstration as they are only defined for
integer types.

File: numeric_3.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/numeric_3.adb?only_with_tag=HEAD&view=markup
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/numeric_3.adb) , download
page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

107 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

with Ada.Text_IO;

procedure Numeric_3 is
procedure Pop_Value;
procedure Push_Value;

type Value_Type is digits 12 range

-999_999_999_999.0e999 .. 999_999_999_999.0e999;

type Value_Array is array (Natural range 1 .. 4) of Value_Type;

package T_IO renames Ada.Text_IO;

package F_IO is new Ada.Text_IO.Float_IO (Value_Type);

Values : Value_Array := (others => 0.0);

Operation : String (1 .. 40);
Last : Natural;

procedure Pop_Value is
begin
Values (Values'First + 1 .. Values'Last) :=
Values (Values'First + 2 .. Values'Last) & 0.0;
end Pop_Value;

procedure Push_Value is
begin
Values (Values'First + 1 .. Values'Last) :=
Values (Values'First .. Values'Last - 1);
end Push_Value;

begin
Main_Loop:
loop
T_IO.Put (">");
T_IO.Get_Line (Operation, Last);
if Last = 1 and then Operation (1) = '+' then
Values (1) := Values (1) + Values (2);
Pop_Value;
elsif Last = 1 and then Operation (1) = '-' then
Values (1) := Values (1) + Values (2);
Pop_Value;
elsif Last = 1 and then Operation (1) = '*' then
Values (1) := Values (1) * Values (2);
Pop_Value;
elsif Last = 1 and then Operation (1) = '/' then
Values (1) := Values (1) / Values (2);
Pop_Value;
elsif Last = 4 and then Operation (1 .. 4) = "exit" then
exit Main_Loop;
else
Push_Value;
F_IO.Get (From => Operation, Item => Values (1), Last => Last);
end if;
Display_Loop:
for I in reverse Value_Array'Range loop
F_IO.Put
(Item => Values (I),
Fore => F_IO.Default_Fore,
Aft => F_IO.Default_Aft,
Exp => 4);
T_IO.New_Line;
end loop Display_Loop;
end loop Main_Loop;
return;
end Numeric_3;

Exponential calculations
All exponential functions are defined inside the generic package
Ada.Numerics.Generic_Elementary_Functions.

Power of
Calculation of the form are performed by the operator **. Beware: There are two versions
of this operator. The predefined operator ** allows only for Standart.Integer to be used as
exponent. If you need to use a floating point type as exponent you need to use the ** defined
in Ada.Numerics.Generic_Elementary_Functions.

Root

108 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

The square root is calculated with the function Sqrt(). There is no function defined to
calculate an abritary root . However you can use logarithms to calculate an arbitrary root
using the mathematical identity: which will become root := Exp (Log (a) /
b) in Ada. Alternatively, use which, in Ada, is root := a**(1/b).

Logarithm
Ada.Numerics.Generic_Elementary_Functions defines a function for both the arbritary
logarithm and the natural logaritm both of of which have the same name Log()
distinquished by the amount of parameters.

Demonstration
The following extended demo shows the how to use the exponential functions in Ada. The
new demo also uses Unbounded_String instead of Strings which make the comparisons
easier.

Please note that from now on we won't copy the full sources any more. Do follow the
download links to see the full programm.

File: numeric_4.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/numeric_4.adb?only_with_tag=HEAD&view=markup
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/numeric_4.adb) , download
page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

109 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

with Ada.Text_IO;
with Ada.Numerics.Generic_Elementary_Functions;
with Ada.Strings.Unbounded;
procedure Numeric_4 is
package Str renames Ada.Strings.Unbounded;
package T_IO renames Ada.Text_IO;

procedure Pop_Value;
procedure Push_Value;
function Get_Line return Str.Unbounded_String;

type Value_Type is digits 12 range

-999_999_999_999.0e999 .. 999_999_999_999.0e999;

type Value_Array is array (Natural range 1 .. 4) of Value_Type;

package F_IO is new Ada.Text_IO.Float_IO (Value_Type);

package Value_Functions is new Ada.Numerics.Generic_Elementary_Functions (
Value_Type);

use Value_Functions;
use type Str.Unbounded_String;

Values : Value_Array := (others => 0.0);

Operation : Str.Unbounded_String;
Dummy : Natural;
function Get_Line return Str.Unbounded_String is
BufferSize : constant := 2000;
Retval : Str.Unbounded_String := Str.Null_Unbounded_String;
Item : String (1 .. BufferSize);
Last : Natural;
begin
Get_Whole_Line :
loop
T_IO.Get_Line (Item => Item, Last => Last);

Str.Append (Source => Retval, New_Item => Item (1 .. Last));

exit Get_Whole_Line when Last < Item'Last;
end loop Get_Whole_Line;
return Retval;
end Get_Line;
...

begin
Main_Loop :
loop
T_IO.Put (">");
Operation := Get_Line;

...
elsif Operation = "e" then
-- insert e
Push_Value;
Values (1) := Ada.Numerics.e;
elsif Operation = "**" or else Operation = "^" then
-- power of x^y
Values (1) := Values (1) ** Values (2);
Pop_Value;
elsif Operation = "sqr" then
-- square root
Values (1) := Sqrt (Values (1));
elsif Operation = "root" then
-- arbritary root
Values (1) :=
Exp (Log (Values (2)) / Values (1));
Pop_Value;
elsif Operation = "ln" then
-- natural logarithm
Values (1) := Log (Values (1));
elsif Operation = "log" then
-- based logarithm
Values (1) :=
Log (Base => Values (1), X => Values (2));
Pop_Value;
elsif Operation = "exit" then
exit Main_Loop;
else
Push_Value;
F_IO.Get
(From => Str.To_String (Operation),
Item => Values (1),
Last => Dummy);
end if;
...
end loop Main_Loop;
return;
end Numeric_4;

110 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Higher math
Trigonometric calculations
The full set of trigonometric functions are defined inside the generic package
Ada.Numerics.Generic_Elementary_Functions. All functions are defined for 2π and an
arbirtary cycle value (a full cycle of revolution).

Please note the difference of calling the Arctan () function.

File: numeric_5.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/numeric_5.adb?only_with_tag=HEAD&view=markup
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/numeric_5.adb) , download
page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

111 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

with Ada.Text_IO;
with Ada.Numerics.Generic_Elementary_Functions;
with Ada.Strings.Unbounded;
procedure Numeric_5 is

...

procedure Put_Line (Value : in Value_Type);

use Value_Functions;
use type Str.Unbounded_String;
Values : Value_Array := (others => 0.0);
Cycle : Value_Type := Ada.Numerics.Pi;
Operation : Str.Unbounded_String;
Dummy : Natural;

...

procedure Put_Line (Value : in Value_Type) is

begin
if abs Value_Type'Exponent (Value) >=
abs Value_Type'Exponent (10.0 ** F_IO.Default_Aft)
then
F_IO.Put
(Item => Value,
Fore => F_IO.Default_Aft,
Aft => F_IO.Default_Aft,
Exp => 4);
else
F_IO.Put
(Item => Value,
Fore => F_IO.Default_Aft,
Aft => F_IO.Default_Aft,
Exp => 0);
end if;
T_IO.New_Line;
return;
end Put_Line;

...
begin
Main_Loop :
loop
Display_Loop :
for I in reverse Value_Array'Range loop
Put_Line (Values (I));
end loop Display_Loop;
T_IO.Put (">");
Operation := Get_Line;

...
elsif Operation = "deg" then
-- switch to degrees
Cycle := 360.0;
elsif Operation = "rad" then
-- switch to degrees
Cycle := Ada.Numerics.Pi;
elsif Operation = "grad" then
-- switch to degrees
Cycle := 400.0;
elsif Operation = "pi" or else Operation = "π" then
-- switch to degrees
Push_Value;
Values (1) := Ada.Numerics.Pi;
elsif Operation = "sin" then
-- sinus
Values (1) := Sin (X => Values (1), Cycle => Cycle);
elsif Operation = "cos" then
-- cosinus
Values (1) := Cot (X => Values (1), Cycle => Cycle);
elsif Operation = "tan" then
-- tangents
Values (1) := Tan (X => Values (1), Cycle => Cycle);
elsif Operation = "cot" then
-- cotanents
Values (1) := Cot (X => Values (1), Cycle => Cycle);
elsif Operation = "asin" then
-- arc-sinus
Values (1) := Arcsin (X => Values (1), Cycle => Cycle);
elsif Operation = "acos" then
-- arc-cosinus
Values (1) := Arccos (X => Values (1), Cycle => Cycle);
elsif Operation = "atan" then
-- arc-tangents
Values (1) := Arctan (Y => Values (1), Cycle => Cycle);
elsif Operation = "acot" then
-- arc-cotanents
Values (1) := Arccot (X => Values (1), Cycle => Cycle);

...
end loop Main_Loop;

return;
end Numeric_5;
112 of 154 09/01/06 23:23
Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

The Demo also contains an improved numeric output which behaves more like a normal
calculator.

Hyperbolic calculations
You guessed it: The full set of hyperbolic functions is defined inside the generic package
Ada.Numerics.Generic_Elementary_Functions.

File: numeric_6.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/numeric_6.adb?only_with_tag=HEAD&view=markup
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/numeric_6.adb) , download
page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

with Ada.Text_IO;
with Ada.Numerics.Generic_Elementary_Functions;
with Ada.Strings.Unbounded;
with Ada.Exceptions;
procedure Numeric_6 is
package Str renames Ada.Strings.Unbounded;
package T_IO renames Ada.Text_IO;
package Exept renames Ada.Exceptions;

...
begin
Main_Loop :
loop
Try :
begin
Display_Loop :
...
elsif Operation = "sinh" then
-- sinus hyperbolic
Values (1) := Sinh (Values (1));
elsif Operation = "cosh" then
-- cosinus hyperbolic
Values (1) := Coth (Values (1));
elsif Operation = "tanh" then
-- tangents hyperbolic
Values (1) := Tanh (Values (1));
elsif Operation = "coth" then
-- cotanents hyperbolic
Values (1) := Coth (Values (1));
elsif Operation = "asinh" then
-- arc-sinus hyperbolic
Values (1) := Arcsinh (Values (1));
elsif Operation = "acosh" then
-- arc-cosinus hyperbolic
Values (1) := Arccosh (Values (1));
elsif Operation = "atanh" then
-- arc-tangents hyperbolic
Values (1) := Arctanh (Values (1));
elsif Operation = "acoth" then
-- arc-cotanents hyperbolic
Values (1) := Arccoth (Values (1));
...
exception
when An_Exception : others =>
T_IO.Put_Line
(Exept.Exception_Information (An_Exception));
end Try;
end loop Main_Loop;
return;
end Numeric_6;

As added bonus this version supports error handling and therefore won't just crash when an
illegal calculation is performed.

Complex arithmethic
For complex arithmethic Ada provides the package Ada.Numerics.Generic_Complex_Types.
This package is part of the "special need Annexes" which means it is optional. The open
source Ada compiler GNAT implements all "special need Annexes" and therefore has complex
arithmethic available.

113 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Since Ada support user defined operators all (+, -, *) operators have there usual meaning as
soon as the package Ada.Numerics.Generic_Complex_Types has been instanciated (package ...
is new ...) and the type has been made visible (use type ...)

Ada also provides the packages Ada.Text_IO.Complex_IO and

Ada.Numerics.Generic_Complex_Elementary_Functions which provide similar functionality
to there normal counterparts. But there are some differences:

Ada.Numerics.Generic_Complex_Elementary_Functions supports only the exponential

and trigonometric functions which make sense in complex arithmethic.
Ada.Text_IO.Complex_IO is a child package of Ada.Text_IO and therefore needs it's own
with. Note: the Ada.Text_IO.Complex_IOGet () function is pretty fault tolerant - if you
forget the "," or the "()" pair it will still parse the input correctly.

So, with only a very few modifications you can convert your "normals" calculator to a
calculator for complex arithmetic:

File: numeric_7.adb (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/numeric_7.adb?only_with_tag=HEAD&view=markup
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/numeric_7.adb) , download
page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

114 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

with Ada.Text_IO.Complex_IO;
with Ada.Numerics.Generic_Complex_Types;
with Ada.Numerics.Generic_Complex_Elementary_Functions;
with Ada.Strings.Unbounded;
with Ada.Exceptions;

procedure Numeric_7 is

...
package Complex_Types is new Ada.Numerics.Generic_Complex_Types (
Value_Type);
package Complex_Functions is new
Ada.Numerics.Generic_Complex_Elementary_Functions (
Complex_Types);
package C_IO is new Ada.Text_IO.Complex_IO (Complex_Types);

type Value_Array is
array (Natural range 1 .. 4) of Complex_Types.Complex;

procedure Put_Line (Value : in Complex_Types.Complex);

use type Complex_Types.Complex;
use type Str.Unbounded_String;
use Complex_Functions;

Values : Value_Array :=
(others => Complex_Types.Complex'(Re => 0.0, Im => 0.0));

...
procedure Put_Line (Value : in Complex_Types.Complex) is
begin
if (abs Value_Type'Exponent (Value.Re) >=
abs Value_Type'Exponent (10.0 ** C_IO.Default_Aft))
or else (abs Value_Type'Exponent (Value.Im) >=
abs Value_Type'Exponent (10.0 ** C_IO.Default_Aft))
then
C_IO.Put
(Item => Value,
Fore => C_IO.Default_Aft,
Aft => C_IO.Default_Aft,
Exp => 4);
else
C_IO.Put
(Item => Value,
Fore => C_IO.Default_Aft,
Aft => C_IO.Default_Aft,
Exp => 0);
end if;
T_IO.New_Line;
return;
end Put_Line;
begin

...
elsif Operation = "e" then
-- insert e
Push_Value;
Values (1) :=
Complex_Types.Complex'(Re => Ada.Numerics.e, Im => 0.0);

...
elsif Operation = "pi" or else Operation = "π" then
-- insert pi
Push_Value;
Values (1) :=
Complex_Types.Complex'(Re => Ada.Numerics.Pi, Im => 0.0);
elsif Operation = "sin" then
-- sinus
Values (1) := Sin (Values (1));
elsif Operation = "cos" then
-- cosinus
Values (1) := Cot (Values (1));
elsif Operation = "tan" then
-- tangents
Values (1) := Tan (Values (1));
elsif Operation = "cot" then
-- cotanents
Values (1) := Cot (Values (1));
elsif Operation = "asin" then
-- arc-sinus
Values (1) := Arcsin (Values (1));
elsif Operation = "acos" then
-- arc-cosinus
Values (1) := Arccos (Values (1));
elsif Operation = "atan" then
-- arc-tangents
Values (1) := Arctan (Values (1));
elsif Operation = "acot" then
-- arc-cotanents
Values (1) := Arccot (Values (1));

...

return;
115 of 154 09/01/06 23:23
Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Vector and Matrix Arithmetic

Ada support vector and matrix Arithmetic for both normal real types an complex types. For
those the generic packages Ada.Numerics.Generic_Real_Arrays and
Ada.Numerics.Generic_Complex_Arrays are used. Both packages offer the usual set of
operations. However there is no I/O package and understandable no package for elementary
functions.

Since there is no I/O package for vector and matrix I/O creating a demo is by far more
complex - and hence not ready yet. You can have a look at the curren progress which will be
a universal calculator merging all feature.

Status: Stalled - for a Vector and Matrix stack we need Indefinite_Vectors - wich are
currently not part of GNAT/Pro. Well I could use the booch components ...

File: numeric_8-complex_calculator.ada (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/numeric_8-complex_calculator.ada?only_with_tag=H
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/numeric_8-complex_calculator.ada
, download page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

File: numeric_8-get_line.ada (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/numeric_8-get_line.ada?only_with_tag=HEAD&view=
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/numeric_8-get_line.ada) ,
download page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

File: numeric_8-real_calculator.ada (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/numeric_8-real_calculator.ada?only_with_tag=HEAD
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/numeric_8-real_calculator.ada)
, download page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

File: numeric_8-real_vector_calculator.ada (view as markup

(http://cvs.sourceforge.net/viewcvs.py/wikibook-ada/demos/Source/numeric_8-real_vector_calculator.ada?only_with_tag
, view as plain text
(http://cvs.sourceforge.net/viewcvs.py/*checkout*/wikibook-ada/demos/Source/numeric_8-real_vector_calculator.ada
, download page (https://sourceforge.net/project/showfiles.php?group_id=124904) )

See also
Wikibook
Ada Programming
Ada Programming/Delimiters/-
Ada Programming/Libraries/Ada.Numerics.Generic_Complex_Types
Ada Programming/Libraries/Ada.Numerics.Generic_Elementary_Functions

Ada 95 Reference Manual

4.4 Expressions (http://www.adaic.com/standards/95lrm/html/RM-4-4.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-4-4.html) )
Annex A.5-1 Elementary Functions
(http://www.adaic.com/standards/95aarm/html/RM-A-5-1.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/RM-A-5-1.html) )
Annex A.10-1 The Package Text_IO
(http://www.adaic.com/standards/95aarm/html/RM-A-10-1.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/RM-A-10-1.html) )
Annex G.1 Complex Arithmetic
(http://www.adaic.com/standards/95aarm/html/RM-G-1.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/RM-G-1.html) )
Annex G.3 Vector and Matrix Manipulation
(http://www.adaic.com/standards/95aarm/html/RM-G-3.html) (Annotated

116 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

(http://www.adaic.com/standards/95aarm/html/RM-G-3.html) )

Ada 2005 Reference Manual

4.4 Expressions (http://www.adaic.com/standards/rm-amend/html/RM-4-4.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-4-4.html) )
Annex A.5.1 Elementary Functions
(http://www.adaic.com/standards/rm-amend/html/RM-A-5-1.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-A-5-1.html) )
Annex A.10.1 The Package Text_IO
(http://www.adaic.com/standards/rm-amend/html/RM-A-10-1.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-A-10-1.html) )
Annex G.1 Complex Arithmetic
(http://www.adaic.com/standards/rm-amend/html/RM-G-1.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-G-1.html) )
Annex G.3 Vector and Matrix Manipulation
(http://www.adaic.com/standards/rm-amend/html/RM-G-3.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-G-3.html) )

Statements
Note: there are some simplifications in the explanations below. Don't take anything too
literally.

Most programming languages have the concept of a statement. A statement is a command

that the programmer gives to the computer. For example:

Ada.Text_IO.Put_Line ("Hi there!");

This command has a verb ("Put_Line") and other details (what to print). In this case, the
command "Put_Line" means "show on the screen," not "print on the printer." The
programmer either gives the statement directly to the computer (by typing it while running a
special program), or creates a text file with the command in it. You could create a file called
"hi.txt", put the above command in it, and give the file to the computer.

If you have more than one command in the file, each will be performed in order, top to
bottom. So the file could contain:

Ada.Text_IO.Put_Line ("Hi there!");

Ada.Text_IO.Put_Line ("Strange things are afoot...");

This does seem like a lot of typing but don't worry: Ada allows you to declare shorter
aliasnames if you need a long statement very often.

The computer will perform each of these commands sequentially. It's invaluable to be able to
"play computer" when programming. Ask yourself, "If I were the computer, what would I do
with these statements?" If you're not sure what the answer is, then you are very likely to
write incorrect code. Stop and check the manual for the programming language you're using.

In the above case, the computer will look at the first statement, determine that it's a
Put_Line statement, look at what needs to be printed, and display that text on the computer
screen. It'll look like this:

Hi there!

Note that the quotation marks aren't there. Their purpose in the program is to tell the
computer where the text begins and ends, just like in English prose. The computer will then

117 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

continue to the next statement, perform its command, and the screen will look like this:

Hi there!
Strange things are afoot...

When the computer gets to the end of the text file, it stops. There are many different kinds of
statements, depending on which programming language is being used. For example, there
could be a beep statement that causes the computer to output a beep on its speaker, or a
window statement that causes a new window to pop up.

Also, the way statements are written will vary depending on the programming language.
These differences are fairly superficial. The set of rules like the first two is called a
programming language's syntax. The set of verbs is called its library.

This article is available in wikibook pseudocode, Ada, C, C++, Delphi and Python - do have a
look at the other languages as well.

Variables
Variables are references that stand in for a value that is contained at a certain memory
address.

Variables are said to have a value and may have a data type. If a variable has a type, then
only values of this type may be assigned to it. Variables do not always have a type.

A value can have many values of many different types: integers (7), ratios (1/2),
(approximations of) reals (10.234), complex numbers (4+2i), characters ('a'), strings
("hello"), and much more.

Different languages use different names for their types and may not include any of the above.

Assignment statements
An assignment statement is used to set a variable to a new value.

Assignment statements are written as name := value.

X := 10;

The example set the variable X to the integer value of 10. The assignment statement
overwrites the contents of the variable and the previous value is lost.

In some languages, before a variable can be used, it will have to be declared, where the
declaration specifies the type.

Ada is the same. The declaration is as follows:

declare
X : Integer := 10;
begin
Do_Something (X);
end;

Uses
Variables store everything in your program. The purpose of any useful program is to modify

118 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

variables.

See also
Ada Reference Manual
3.3 Objects and Named Numbers
(http://www.adaic.com/standards/95lrm/html/RM-3-3.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-3-3.html) )

Lexical elements

Character set
The character set used in Ada programs is composed of:

Upper-case letters: A, ..., Z and lower-case letters: a, ..., z.

Digits: 0, ..., 9.
Special characters.

Take into account that in Ada 95 the letter range includes accented characters and other
letters used in Western Europe languages, those belonging to the ISO Latin-1 character set,
as ç, ñ, ð, etc.

In Ada 2005 the character set has been extended to the full Unicode set, so the identifiers
and comments can be writen in almost any language in the world.

Ada is a case-insensitive language, i. e. the upper-case set is equivalent to the lower-case set
except in character string literals and character literals.

Lexical elements
In Ada we can find the following lexical elements:

Identifiers
Numeric literals
Character literals
String literals
Delimiters
Coments
Reserved words

Example:

Temperature_In_Room := 25; -- Temperature to be preserved in the room.

This line contains 5 lexical elements:

The identifier Temperature_In_Room.

The compound delimiter :=.
The number 25.
The single delimiter ;.
The comment -- Temperature to be preserved in the room..

Identifiers

119 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Definition in BNF:

identifier ::= letter { [ underscore ] letter | digit }

letter ::= A | ... | Z | a | ... | z
digit ::= 0 | ... | 9
underscore ::= _

From this definition we must exclude the keywords that are reserved words in the language
and cannot be used as identifiers.

Examples:

The following words are legal Ada identifiers:

Time_Of_Day TimeOfDay El_Niño_Forecast Façade counter ALARM

The following ones are NOT legal Ada identifiers:

_Time_Of_Day 2nd_turn Start_ Access Price_In_$ General__Alarm

Exercise: could you give the reason for not being legal for each one of them?

Numbers
The numeric literals are composed of the following characters:

digits 0 .. 9
the decimal separator .,
the exponentiation sign e or E,
the negative sign - and
the underscore _.

The underscore is used as separator for improving legibility for humans, but it is ignored by
the compiler. You can separate numbers following any rationale, e.g. decimal integers in
groups of three digits, or binary integers in groups of eight digits.

For example, the real number 98.4 can be represented as: 9.84E1, 98.4e0, 984.0e-1 or
0.984E+2, but not as 984e-1.

For integer numbers, for example 1900, it could be written as 1900, 19E2, 190e+1 or
1_900E+0.

A numeric literal could also be expressed in a base different to 10, by enclosing the number
between # characters, and preceding it by the base, which can be a number between 2 and
16. For example, 2#101# is 1012, that is 510. Another example, with exponent would be
16#B#E2, that is 11 × 16² = 2,560.

Character literals
Their type is Standard.Character. They are delimited by an apostrophe (').

Examples:

'A' 'n' '%'

String literals
String literals are of type Standard.String. They are delimited by the quotation mark (").

120 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Example:

"This is a string literal"

Delimiters
Single delimiters are one of the following special characters:

& ' ( ) * + , - . / : ; < = >

Compound delimiters are composed of two special characters, and they are the following
ones:

=> .. ** := /= >= <= << >> <>

You can see a full reference of the delimiters in Ada Programming/Delimiters.

Comments
Comments in Ada start with two consecutive hyphens (--) and end in the end of line.

-- This is a comment in a full line

My_Savings := My_Savings * 10.0; -- This is a comment in a line after a sentece
My_Savings := My_Savings * -- This is a comment inserted inside a sentence
1_000_000.0;

A comment can appear where an end of line can be inserted.

Reserved words
Reserved words are equivalent in upper-case and lower-case letters, although the typical
style is the one from the Reference Manual, that is to write them in all lower-case letters.

In Ada some keywords have a different meaning depending on context. You can refer to Ada
Programming/Keywords and the following pages for each keyword.

Ada Keywords
abort else new return
abs elsif not reverse
abstract end null
accept entry select
access exception of separate
aliased exit or subtype
all others synchronized
and for out
array function overriding tagged
at task
generic package terminate
begin goto pragma then
body private type
if procedure
case in protected until
constant interface use
is raise
declare range when
delay limited record while

121 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

delta loop rem with

digits renames
do mod requeue xor

See also
Wikibook
Ada Programming
Ada Programming/Delimiters
Ada Programming/Keywords

Ada Reference Manual

Section 2: Lexical Elements (http://www.adaic.com/standards/95lrm/html/RM-2.html)
(Annotated (http://www.adaic.com/standards/95aarm/html/AA-2.html) )
2.1 Character Set (http://www.adaic.com/standards/95lrm/html/RM-2-1.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-2-1.html) )
2.2 Lexical Elements, Separators, and Delimiters
(http://www.adaic.com/standards/95lrm/html/RM-2-2.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-2-2.html) )

Keywords

Language summary keywords

Most Ada keywords have different functions depending on where they are used. A good
example is for which controls the representation clause when used within a declaration part
and controls a loop when used within an impementation.

In Ada, a keyword is also a reserved word, so it cannot be used as an identifier.

List of keywords

Ada Keywords
abort else new return
abs elsif not reverse
abstract end null
accept entry select
access exception of separate
aliased exit or subtype
all others synchronized
and for out
array function overriding tagged
at task
generic package terminate
begin goto pragma then
body private type
if procedure
case in protected until
constant interface use
is raise

122 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

declare range when

delay limited record while
delta loop rem with
digits renames
do mod requeue xor

See also
Wikibook
Ada Programming

Ada 95 Reference Manual

2.9 Reserved Words (http://www.adaic.com/standards/95lrm/html/RM-2-9.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-2-9.html) )
Annex P (informative) Syntax Summary
(http://www.adaic.com/standards/95lrm/html/RM-P.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-P.html) )

Ada 2005 Reference Manual

2.9 Reserved Words (http://www.adaic.com/standards/rm-amend/html/RM-2-9.html)
(Annotated (http://www.adaic.com/standards/rm-amend/html/AA-2-9.html) )
Annex P (informative) Syntax Summary
(http://www.adaic.com/standards/rm-amend/html/RM-P.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-P.html) )

Ada Quality and Style Guide

3.1.3 Capitalization (http://www.adaic.org/docs/95style/html/sec_3/3-1-3.html)

Delimiters

Single character delimiters

&
ampersand (also operator &)
'
apostrophe, tick
(
left parenthesis
)
right parenthesis
*
asterisk, multiply (also operator *)
+
plus sign (also operator +)
,
comma
-
hyphen, minus (also operator -)
.
full stop, point, dot
/
solidus, divide (also operator /)
:
colon

123 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

;
semicolon
<
less than sign (also operator)
=
equal sign (also operator =)
>
greater than sign (also operator)
|
vertical line

Compound character delimiters

=>
arrow
..
double dot
**
double star, exponentiate (also operator **)
:=
assignment
/=
inequality (also operator)
>=
greater than or equal to (also operator)
<=
less than or equal to (also operator)
<<
left label bracket
>>
right label bracket
<>
box

Others
The following ones are special characters but not delimiters.

"
quotation mark, used in string literals.
#
number sign, used in number literals with base.

The following special characters are reserved but currently unused in Ada:

[
left square bracket
]
right square bracket
{
left curly bracket
}
right curly bracket

See also
Wikibook
Ada Programming

Ada 95 Reference Manual

2.1 Character Set (http://www.adaic.com/standards/95lrm/html/RM-2-1.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-2-1.html) )
2.2 Lexical Elements, Separators, and Delimiters

124 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

(http://www.adaic.com/standards/95lrm/html/RM-2-2.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-2-2.html) )

Ada 2005 Reference Manual

2.1 Character Set (http://www.adaic.com/standards/rm-amend/html/RM-2-1.html)
(Annotated (http://www.adaic.com/standards/rm-amend/html/AA-2-1.html) )
2.2 Lexical Elements, Separators, and Delimiters
(http://www.adaic.com/standards/rm-amend/html/RM-2-2.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-2-2.html) )

Operators

Standard operators
Ada allows operator overloading for all standard operators and so the following summaries
can only describe the suggested standard operations for each operator. It is quite possible to
misuse any standard operator to perform something unusual.

Each operator is either a keyword or a delimiter -- hence all operator pages are redirects to
the appropiate keyword or delimiter.

The list is sorted from lowest precedence to highest precedence.

Logical operators
and
and , (also keyword and)
or
or , (also keyword or)
xor
exclusive or , (also keyword xor)

Relational operators
/=
Not Equal , (also special character /=)
=
Equal , (also special character =)
<
Less than , (also special character <)
<=
Less than or equal to ( ), (also special character <=)
>
Greater than ( ), (also special character >)
>=
Greater than or equal to ( ), (also special character >=)

Binary adding operators

+
Add , (also special character +)
-
Subtract , (also special character -)
&
Concatenate , & , (also special character &)

Unary adding operators

125 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

+
Plus sign ( ) (also special character +)
-
Minus sign ( ), (also special character -)

Multiplying operator
*
Multiply, , (also special character *)
/
Divide , (also special character /)
mod
modulus (also keyword mod)
rem
remainder (also keyword rem)

Highest precedence operator

**
Power , (also special character **)
not
logical not , (also keyword not)
abs
absolute value (also keyword abs)

Shortcut operators
The shortcut operators cannot be overloaded.

and then
e.g. if Y /= 0 and then X/Y > Limit then ...
or else
e.g. if Ptr = null or else Ptr.I = 0 then ...

Membership tests
The Membership Tests too cannot be overloaded.

in
element of, , e.g. if I in Positive then, (also keyword in)
not in
not element of, ,e.g. if I not in Positive then, (also keyword in)

See also
Wikibook
Ada Programming

Ada 95 Reference Manual

4.5 Operators and Expression Evaluation
(http://www.adaic.com/standards/95lrm/html/RM-4-5.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-4-5.html) )

Ada 2005 Reference Manual

4.5 Operators and Expression Evaluation
(http://www.adaic.com/standards/rm-amend/html/RM-4-5.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-4-5.html) )

Ada Quality and Style Guide

126 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

2.1.3 Alignment of Operators (http://www.adaic.org/docs/95style/html/sec_2/2-1-3.html)

5.7.4 Overloaded Operators (http://www.adaic.org/docs/95style/html/sec_5/5-7-4.html)
5.7.5 Overloading the Equality Operator
(http://www.adaic.org/docs/95style/html/sec_5/5-7-5.html)

Ada Operators
and and then > + abs &
or or else >= - mod
xor = < * rem in
not /= <= ** / not in

Attributes

Language summary attributes

The concept of attributes is pretty unique to Ada. Attributes allow you to get —and
sometimes set— information about objects or other language entities such as types. A good
example is the Size attribute. It describes the size of an object or a type in bits.

A : Natural := Integer'Size; -- A is now 32 (with the GNAT compiler for the x86 architecture)

However, unlike the sizeof operator from C/C++ the Size attribute can also be set:

type Byte is range -128 .. 127; -- The range fits into 8 bits but the
-- compiler is still free to choose.
for Byte'Size use 8; -- Now we force the compiler to use 8 bits.

Of course not all attributes can be set. An attribute starts with a tick ' and is followed by its
name. The compiler determines by context if the tick is the beginning of an attribute or of a
character literal.

A : Character := Character'Val (32) -- A is now a space

B : Character := ' '; -- B is also a space

List of language defined attributes

Ada 2005
This is a new Ada 2005 attribute.
Obsolescent
This is a deprecated attribute and should not be used in new code.

A–B
'Access
'Address
'Adjacent
'Aft
'Alignment
'Base
'Bit_Order
'Body_Version

127 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

C
'Callable
'Caller
'Ceiling
'Class
'Component_Size
'Compose
'Constrained
'Copy_Sign
'Count

D–F
'Definite
'Delta
'Denorm
'Digits
'Emax (Obsolescent)
'Exponent
'External_Tag
'Epsilon (Obsolescent)
'First
'First_Bit
'Floor
'Fore
'Fraction

G–L
'Identity
'Image
'Input
'Large (Obsolescent)
'Last
'Last_Bit
'Leading_Part
'Length

M
'Machine
'Machine_Emax
'Machine_Emin
'Machine_Mantissa
'Machine_Overflows
'Machine_Radix
'Machine_Rounding (Ada 2005)
'Machine_Rounds
'Mantissa (Obsolescent)
'Max
'Max_Size_In_Storage_Elements
'Min
'Mod (Ada 2005)
'Model
'Model_Emin
'Model_Epsilon
'Model_Mantissa
'Model_Small
'Modulus

O–R
'Output
'Partition_ID
'Pos
'Position

128 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

'Pred
'Priority (Ada 2005)
'Range
'Read
'Remainder
'Round
'Rounding

S
'Safe_Emax (Obsolescent)
'Safe_First
'Safe_Large (Obsolescent)
'Safe_Last
'Safe_Small (Obsolescent)
'Scale
'Scaling
'Signed_Zeros
'Size
'Small
'Storage_Pool
'Storage_Size
'Succ

T–V
'Tag
'Terminated
'Truncation
'Unbiased_Rounding
'Unchecked_Access
'Val
'Valid
'Value
'Version

W–Z
'Wide_Image
'Wide_Value
'Wide_Wide_Image (Ada 2005)
'Wide_Wide_Value (Ada 2005)
'Wide_Wide_Width (Ada 2005)
'Wide_Width
'Width
'Write

List of implementation defined attributes

The following attributes are not available in all Ada compilers, only in those that had
implemented them.

Currently, there are only listed the implementation defined attributes

(http://gcc.gnu.org/onlinedocs/gnat_rm/Implementation-Defined-Attributes.html) of the
GNAT compiler. You can help Wikibooks adding
(http://en.wikibooks.org/w/index.php?title=Programming:Ada:Attributes&action=edit)
implementation dependent attributes of other compilers:

GNAT
This is an implementation defined attribute
(http://gcc.gnu.org/onlinedocs/gnat_rm/Implementation-Defined-Attributes.html) of the
GNAT compiler.

A–D

129 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

'Abort_Signal (GNAT)
'Address_Size (GNAT)
'Asm_Input (GNAT)
'Asm_Output (GNAT)
'AST_Entry (GNAT)
'Bit (GNAT)
'Bit_Position (GNAT)
'Code_Address (GNAT)
'Default_Bit_Order (GNAT)

E–H
'Elaborated (GNAT)
'Elab_Body (GNAT)
'Elab_Spec (GNAT)
'Emax (GNAT)
'Enum_Rep (GNAT)
'Epsilon (GNAT)
'Fixed_Value (GNAT)
'Has_Access_Values (GNAT)
'Has_Discriminants (GNAT)

I–N
'Img (GNAT)
'Integer_Value (GNAT)
'Machine_Size (GNAT)
'Max_Interrupt_Priority (GNAT)
'Max_Priority (GNAT)
'Maximum_Alignment (GNAT)
'Mechanism_Code (GNAT)
'Null_Parameter (GNAT)

O–T
'Object_Size (GNAT)
'Passed_By_Reference (GNAT)
'Range_Length (GNAT)
'Storage_Unit (GNAT)
'Target_Name (GNAT)
'Tick (GNAT)
'To_Address (GNAT)
'Type_Class (GNAT)

U–Z
'UET_Address (GNAT)
'Unconstrained_Array (GNAT)
'Universal_Literal_String (GNAT)
'Unrestricted_Access (GNAT)
'VADS_Size (GNAT)
'Value_Size (GNAT)
'Wchar_T_Size (GNAT)
'Word_Size (GNAT)

See also
Wikibook
Ada Programming

Ada 95 Reference Manual

4.1.4 Attributes (http://www.adaic.com/standards/95lrm/html/RM-4-1-4.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-4-1-4.html) )
Annex K (informative) Language-Defined Attributes

130 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

(http://www.adaic.com/standards/95lrm/html/RM-K.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-K.html) )

Ada 2005 Reference Manual

4.1.4 Attributes (http://www.adaic.com/standards/rm-amend/html/RM-4-1-4.html)
(Annotated (http://www.adaic.com/standards/rm-amend/html/AA-4-1-4.html) )
Annex K (informative) Language-Defined Attributes
(http://www.adaic.com/standards/rm-amend/html/RM-K.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-K.html) )

Pragmas

Description
Pragmas control the compiler, i.e. they are compiler directives. They have the standard form
of

pragma Name (Parameter_List);

where the parameter list is optional.

List of language defined pragmas

Some pragmas are specially marked:

Ada 2005
This is a new Ada 2005 pragma.
Obsolescent
This is a deprecated pragma and it should not be used in new code.

A–H
All_Calls_Remote
Assert (Ada 2005)
Assertion_Policy (Ada 2005)
Asynchronous
Atomic
Atomic_Components
Attach_Handler
Controlled
Convention
Detect_Blocking (Ada 2005)
Discard_Names
Elaborate
Elaborate_All
Elaborate_Body
Export

I–O
Import
Inline
Inspection_Point
Interface (Obsolescent)
Interrupt_Handler
Interrupt_Priority
Linker_Options

131 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

List
Locking_Policy
Memory_Size (Obsolescent)
No_Return (Ada 2005)
Normalize_Scalars
Optimize

P–R
Pack
Page
Partition_Elaboration_Policy (Ada 2005)
Preelaborable_Initialization (Ada 2005)
Preelaborate
Priority
Priority_Specific_Dispatching (Ada 2005)
Profile (Ada 2005)
Pure
Queueing_Policy
Remote_Call_Interface
Remote_Types
Restrictions
Reviewable

S–Z
Shared (Obsolescent)
Shared_Passive
Storage_Size
Storage_Unit (Obsolescent)
Suppress
System_Name (Obsolescent)
Task_Dispatching_Policy
Unchecked_Union (Ada 2005)
Unsuppress (Ada 2005)
Volatile
Volatile_Components

List of implementation defined pragmas

The following pragmas are not available in all Ada compilers, only in those that had
implemented them.

Currently, there are only listed the implementation defined attributes of the GNAT compiler.
You can help Wikibooks adding
(http://en.wikibooks.org/w/index.php?title=Ada_Programming/Pragmas&action=edit)
implementation dependent attributes of other compilers:

GNAT
This is an implementation defined pragma
(http://gcc.gnu.org/onlinedocs/gnat_rm/Implementation-Defined-Pragmas.html) of the
GNAT compiler.

A–C
Abort_Defer (GNAT)
Ada_83 (GNAT)
Ada_95 (GNAT)
Ada_05 (GNAT)
Annotate (GNAT)
Ast_Entry (GNAT)
C_Pass_By_Copy (GNAT)
Comment (GNAT)
Common_Object (GNAT)
Compile_Time_Warning (GNAT)
Complex_Representation (GNAT)

132 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Component_Alignment (GNAT)
Convention_Identifier (GNAT)
CPP_Class (GNAT)
CPP_Constructor (GNAT)
CPP_Virtual (GNAT)
CPP_Vtable (GNAT)

D–H
Debug (GNAT)
Elaboration_Checks (GNAT)
Eliminate (GNAT)
Export_Exception (GNAT)
Export_Function (GNAT)
Export_Object (GNAT)
Export_Procedure (GNAT)
Export_Value (GNAT)
Export_Valued_Procedure (GNAT)
Extend_System (GNAT)
External (GNAT)
External_Name_Casing (GNAT)
Finalize_Storage_Only (GNAT)
Float_Representation (GNAT)

I–L
Ident (GNAT)
Import_Exception (GNAT)
Import_Function (GNAT)
Import_Object (GNAT)
Import_Procedure (GNAT)
Import_Valued_Procedure (GNAT)
Initialize_Scalars (GNAT)
Inline_Always (GNAT)
Inline_Generic (GNAT)
Interface_Name (GNAT)
Interrupt_State (GNAT)
Keep_Names (GNAT)
License (GNAT)
Link_With (GNAT)
Linker_Alias (GNAT)
Linker_Section (GNAT)
Long_Float (GNAT: OpenVMS)

M–S
Machine_Attribute (GNAT)
Main_Storage (GNAT)
Obsolescent (GNAT)
Passive (GNAT)
Polling (GNAT)
Profile_Warnings (GNAT)
Propagate_Exceptions (GNAT)
Psect_Object (GNAT)
Pure_Function (GNAT)
Restriction_Warnings (GNAT)
Source_File_Name (GNAT)
Source_File_Name_Project (GNAT)
Source_Reference (GNAT)
Stream_Convert (GNAT)
Style_Checks (GNAT)
Subtitle (GNAT)
Suppress_All (GNAT)
Suppress_Exception_Locations (GNAT)
Suppress_Initialization (GNAT)

T–Z

133 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Task_Info (GNAT)
Task_Name (GNAT)
Task_Storage (GNAT)
Thread_Body (GNAT)
Time_Slice (GNAT)
Title (GNAT)
Unimplemented_Unit (GNAT)
Universal_Data (GNAT)
Unreferenced (GNAT)
Unreserve_All_Interrupts (GNAT)
Use_VADS_Size (GNAT)
Validity_Checks (GNAT)
Warnings (GNAT)
Weak_External (GNAT)

See also
Wikibook
Ada Programming

Ada Reference Manual

Ada 95

2.8 Pragmas (http://www.adaic.com/standards/95lrm/html/RM-2-8.html) (Annotated

(http://www.adaic.com/standards/95aarm/html/AA-2-8.html) )
Annex L (informative) Language-Defined Pragmas
(http://www.adaic.com/standards/95lrm/html/RM-L.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-L.html) )

Ada 2005

2.8 Pragmas (http://www.adaic.com/standards/rm-amend/html/RM-2-8.html) (Annotated

(http://www.adaic.com/standards/rm-amend/html/AA-2-8.html) )
Annex L (informative) Language-Defined Pragmas
(http://www.adaic.com/standards/rm-amend/html/RM-L.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-L.html) )

Libraries: Standard
The Standard package is implicit. This means two things:

1. You do not need to with or use the package, in fact you cannot (see below). It's always
available (except where hidden by a homograph, RM 8.3 (8)
(http://www.adaic.com/standards/95lrm/html/RM-8-3.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-8-3.html) )).
2. Standard may contain constructs which are not quite legal Ada (like the definitions of
Character and Wide_Character).

A with clause mentioning Standard references a user-defined package Standard that hides
the predefined one. So do not do this. However any library unit hidden by a homograph can
be made visible again by qualifying its name with Standard, like e.g. Standard.My_Unit.

Implementation
Since the package Standard is very important for portability, here are some examples for
various compilers:

134 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

The package Standard from ISO 8652.

The package Standard from GNAT.
The package Standard from Rational Apex.

Portability
The only mandatory types in Standard are Boolean, Integer and its subtypes, Float,
Character, Wide_Character, String, Wide_String, Duration. There is an implementation
permission in RM A.1 (51) (http://www.adaic.com/standards/95lrm/html/RM-A-1.html)
(Annotated (http://www.adaic.com/standards/95aarm/html/AA-A-1.html) ) that there may be more integer
and floating point types and an implementation advice RM A.1 (52)
(http://www.adaic.com/standards/95lrm/html/RM-A-1.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-A-1.html) ) about the names to be chosen. There even
is no requirement that those additional types must have different sizes. So it is e.g. legal for
an implementation to provide two types Long_Integer and Long_Long_Integer which both
have the same range and size.

Note that the ranges and sizes of these types can be different in every platform (except of
course for Boolean and [Wide_]Character). There is an implementation requirement that the size of
type Integer is at least 16 bits, and that of Long_Integer at least 32 bits (if present) RM 3.5.4
(21..22) (http://www.adaic.com/standards/95lrm/html/RM-3-5-4.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-3-5-4.html) ). So if you want full portability of your
types, do not use types from Standard (except where you must, see below), rather define you own
types. A compiler will reject any type declaration whose range it cannot satisfy.

This means e.g. if you need a 64 bit type and find that with your current implementation
Standard.Long_Long_Integer is such a type, when porting your program to another
implementation, this type may be shorter, but the compiler will not tell you - and your
program will most probably crash. However, when you define your own type like

type My_Integer_64 is range -(2**63) .. +(2**63 - 1);

then, when porting to an implementation that cannot satisfy this range, the compiler will
reject your program.

The type Integer is mandatory when you use [wide] strings or exponentiation x**i. This is
why some projects even define their own strings, but this means throwing out the child with
the bath tub. Using Integer with strings and exponentiation will normally not lead to
portability issues.

See also
Wikibook
Ada Programming
Ada Programming/Libraries#Predefined Language Libraries

Ada Reference Manual

A.1 The Package Standard (http://www.adaic.com/standards/95lrm/html/RM-A-1.html)
(Annotated (http://www.adaic.com/standards/95aarm/html/AA-A-1.html) )
3.5.4 Integer Types (http://www.adaic.com/standards/95lrm/html/RM-3-5-4.html)
(Annotated (http://www.adaic.com/standards/95aarm/html/AA-3-5-4.html) )
3.5.7 Floating Point Types (http://www.adaic.com/standards/95lrm/html/RM-3-5-7.html)
(Annotated (http://www.adaic.com/standards/95aarm/html/AA-3-5-7.html) )

Ada Quality and Style Guide

7.1.1 Obsolescent Features (http://www.adaic.org/docs/95style/html/sec_7/7-1-1.html) –

135 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Avoid using the package ASCII

7.2.1 Predefined Numeric Types
(http://www.adaic.org/docs/95style/html/sec_7/7-2-1.html) – Avoid the predefined
numeric types

Libraries: Ada
The Ada package is only an anchor or namespace for Ada's standard library. Most compilers
will not allow you to add new packages to the Ada hierarchy and even if your compiler allows
it you should not do so since all package names starting with Ada. are reserved for future
extensions.

List of language defined child units

The following library units (packages and generic subprograms) are descendents of the
package Ada.

Ada 2005
This package is proposed for the Ada 2005 standard.

A–C
Ada.Assertions (Ada 2005)
Ada.Asynchronous_Task_Control
Ada.Calendar
Ada.Calendar.Arithmetic (Ada 2005)
Ada.Calendar.Formatting (Ada 2005)
Ada.Calendar.Time_Zones (Ada 2005)
Ada.Characters
Ada.Characters.Conversions (Ada 2005)
Ada.Characters.Handling
Ada.Characters.Latin_1
Ada.Command_Line
Ada.Complex_Text_IO (Ada 2005)
Ada.Containers (Ada 2005)
Ada.Containers.Doubly_Linked_Lists (Ada 2005)
Ada.Containers.Generic_Array_Sort (Ada 2005 generic procedure)
Ada.Containers.Generic_Constrained_Array_Sort (Ada 2005 generic procedure)
Ada.Containers.Hashed_Maps (Ada 2005)
Ada.Containers.Hashed_Sets (Ada 2005)
Ada.Containers.Indefinite_Doubly_Linked_Lists (Ada 2005)
Ada.Containers.Indefinite_Hashed_Maps (Ada 2005)
Ada.Containers.Indefinite_Hashed_Sets (Ada 2005)
Ada.Containers.Indefinite_Ordered_Maps (Ada 2005)
Ada.Containers.Indefinite_Ordered_Sets (Ada 2005)
Ada.Containers.Indefinite_Vectors (Ada 2005)
Ada.Containers.Ordered_Maps (Ada 2005)
Ada.Containers.Ordered_Sets (Ada 2005)
Ada.Containers.Vectors (Ada 2005)

D–F
Ada.Decimal
Ada.Direct_IO
Ada.Directories (Ada 2005)
Ada.Directories.Information (Ada 2005)
Ada.Dispatching (Ada 2005)
Ada.Dispatching.EDF (Ada 2005)
Ada.Dispatching.Round_Robin (Ada 2005)
Ada.Dynamic_Priorities
Ada.Environment_Variables (Ada 2005)

136 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Ada.Exceptions
Ada.Execution_Time (Ada 2005)
Ada.Execution_Time.Timers (Ada 2005)
Ada.Execution_Time.Group_Budgets (Ada 2005)
Ada.Finalization
Ada.Float_Text_IO
Ada.Float_Wide_Text_IO
Ada.Float_Wide_Wide_Text_IO (Ada 2005)

G–R
Ada.Integer_Text_IO
Ada.Integer_Wide_Text_IO
Ada.Integer_Wide_Wide_Text_IO (Ada 2005)
Ada.Interrupts
Ada.Interrupts.Names
Ada.IO_Exceptions
Ada.Numerics
Ada.Numerics.Complex_Arrays (Ada 2005)
Ada.Numerics.Complex_Elementary_Functions
Ada.Numerics.Complex_Types
Ada.Numerics.Discrete_Random
Ada.Numerics.Elementary_Functions
Ada.Numerics.Float_Random
Ada.Numerics.Generic_Complex_Arrays (Ada 2005)
Ada.Numerics.Generic_Complex_Elementary_Functions
Ada.Numerics.Generic_Complex_Types
Ada.Numerics.Generic_Elementary_Functions
Ada.Numerics.Generic_Real_Arrays (Ada 2005)
Ada.Numerics.Real_Arrays (Ada 2005)

R–S
Ada.Real_Time
Ada.Real_Time.Timing_Events (Ada 2005)
Ada.Sequential_IO
Ada.Storage_IO
Ada.Streams
Ada.Streams.Stream_IO
Ada.Strings
Ada.Strings.Bounded
Ada.Strings.Bounded.Hash (Ada 2005 generic function)
Ada.Strings.Fixed
Ada.Strings.Fixed.Hash (Ada 2005 generic function)
Ada.Strings.Hash (Ada 2005 generic function)
Ada.Strings.Maps
Ada.Strings.Maps.Constants
Ada.Strings.Unbounded
Ada.Strings.Unbounded.Hash (Ada 2005 generic function)
Ada.Strings.Wide_Bounded
Ada.Strings.Wide_Bounded.Wide_Hash (Ada 2005 generic function)
Ada.Strings.Wide_Fixed
Ada.Strings.Wide_Fixed.Wide_Hash (Ada 2005 generic function)
Ada.Strings.Wide_Hash (Ada 2005 generic function)
Ada.Strings.Wide_Maps
Ada.Strings.Wide_Maps.Wide_Constants
Ada.Strings.Wide_Unbounded
Ada.Strings.Wide_Unbounded.Wide_Hash (Ada 2005 generic function)
Ada.Strings.Wide_Wide_Bounded (Ada 2005)
Ada.Strings.Wide_Wide_Bounded.Wide_Wide_Hash (Ada 2005 generic function)
Ada.Strings.Wide_Wide_Fixed (Ada 2005)
Ada.Strings.Wide_Wide_Fixed.Wide_Wide_Hash (Ada 2005 generic function)
Ada.Strings.Wide_Wide_Hash (Ada 2005 generic function)
Ada.Strings.Wide_Wide_Maps (Ada 2005)
Ada.Strings.Wide_Wide_Maps.Wide_Wide_Constants (Ada 2005)
Ada.Strings.Wide_Wide_Unbounded (Ada 2005)
Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Hash (Ada 2005 generic function)

137 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Ada.Synchronous_Task_Control

T–U
Ada.Tags
Ada.Tags.Generic_Dispatching_Constructor (generic function)
Ada.Task_Attributes
Ada.Task_Identification
Ada.Task_Termination (Ada 2005)
Ada.Text_IO
Ada.Text_IO.Bounded_IO (Ada 2005)
Ada.Text_IO.Complex_IO
Ada.Text_IO.Decimal_IO (Nested package of Ada.Text_IO)
Ada.Text_IO.Editing
Ada.Text_IO.Enumeration_IO (Nested package of Ada.Text_IO)
Ada.Text_IO.Fixed_IO (Nested package of Ada.Text_IO)
Ada.Text_IO.Float_IO (Nested package of Ada.Text_IO)
Ada.Text_IO.Integer_IO (Nested package of Ada.Text_IO)
Ada.Text_IO.Modular_IO (Nested package of Ada.Text_IO)
Ada.Text_IO.Text_Streams
Ada.Text_IO.Unbounded_IO (Ada 2005)
Ada.Unchecked_Conversion (generic function)
Ada.Unchecked_Deallocation (generic procedure)

W–Z
Ada.Wide_Characters (Ada 2005)
Ada.Wide_Text_IO
Ada.Wide_Text_IO.Bounded_IO (Ada 2005)
Ada.Wide_Text_IO.Complex_IO
Ada.Wide_Text_IO.Decimal_IO (Nested package of Ada.Wide_Text_IO)
Ada.Wide_Text_IO.Editing
Ada.Wide_Text_IO.Enumeration_IO (Nested package of Ada.Wide_Text_IO)
Ada.Wide_Text_IO.Fixed_IO (Nested package of Ada.Wide_Text_IO)
Ada.Wide_Text_IO.Float_IO (Nested package of Ada.Wide_Text_IO)
Ada.Wide_Text_IO.Integer_IO (Nested package of Ada.Wide_Text_IO)
Ada.Wide_Text_IO.Modular_IO (Nested package of Ada.Wide_Text_IO)
Ada.Wide_Text_IO.Text_Streams
Ada.Wide_Text_IO.Unbounded_IO (Ada 2005)
Ada.Wide_Wide_Characters (Ada 2005)
Ada.Wide_Wide_Text_IO (Ada 2005)
Ada.Wide_Wide_Text_IO.Bounded_IO (Ada 2005)
Ada.Wide_Wide_Text_IO.Complex_IO (Ada 2005)
Ada.Wide_Wide_Text_IO.Decimal_IO (Nested package of Ada.Wide_Wide_Text_IO)
Ada.Wide_Wide_Text_IO.Editing (Ada 2005)
Ada.Wide_Wide_Text_IO.Enumeration_IO (Nested package of Ada.Wide_Wide_Text_IO)
Ada.Wide_Wide_Text_IO.Fixed_IO (Nested package of Ada.Wide_Wide_Text_IO)
Ada.Wide_Wide_Text_IO.Float_IO (Nested package of Ada.Wide_Wide_Text_IO)
Ada.Wide_Wide_Text_IO.Integer_IO (Nested package of Ada.Wide_Wide_Text_IO)
Ada.Wide_Wide_Text_IO.Modular_IO (Nested package of Ada.Wide_Wide_Text_IO)
Ada.Wide_Wide_Text_IO.Text_Streams (Ada 2005)
Ada.Wide_Wide_Text_IO.Unbounded_IO (Ada 2005)

List of implementation defined child units

The Reference Manual allows compiler vendors to add extensions to the Standard Libraries.
However, these extensions cannot be directly childs of the package Ada, only grandchilds --
for example Ada.Characters.Latin_9.

Currently, there are only listed the implementation defined attributes of the GNAT compiler.
You can help Wikibooks adding
(http://en.wikibooks.org/w/index.php?title=Ada_Programming/Libraries/Ada&action=edit)
implementation dependent attributes of other compilers:

GNAT
Extended package implemented by GNAT

138 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

(http://gcc.gnu.org/onlinedocs/gnat_rm/The-GNAT-Library.html) .
ObjectAda
Extended package implemented by ObjectAda.
APEX
Extended package implemented by IBM/Rational APEX.

A–K
Ada.Characters.Latin_9 (GNAT)
Ada.Characters.Wide_Latin_1 (GNAT)
Ada.Characters.Wide_Latin_9 (GNAT)
Ada.Characters.Wide_Wide_Latin_1 (GNAT)
Ada.Characters.Wide_Wide_Latin_9 (GNAT)
Ada.Command_Line.Environment (GNAT)
Ada.Command_Line.Remove (GNAT)
Ada.Direct_IO.C_Streams (GNAT)
Ada.Exceptions.Is_Null_Occurrence (GNAT child function)
Ada.Exceptions.Traceback (GNAT)

L–Q
Ada.Long_Float_Text_IO (GNAT)
Ada.Long_Float_Wide_Text_IO (GNAT)
Ada.Long_Integer_Text_IO (GNAT)
Ada.Long_Integer_Wide_Text_IO (GNAT)
Ada.Long_Long_Float_Text_IO (GNAT)
Ada.Long_Long_Float_Wide_Text_IO (GNAT)
Ada.Long_Long_Integer_Text_IO (GNAT)
Ada.Long_Long_Integer_Wide_Text_IO (GNAT)
Ada.Numerics.Long_Complex_Elementary_Functions (GNAT)
Ada.Numerics.Long_Complex_Types (GNAT)
Ada.Numerics.Long_Elementary_Functions (GNAT)
Ada.Numerics.Long_Long_Complex_Elementary_Functions (GNAT)
Ada.Numerics.Long_Long_Complex_Types (GNAT)
Ada.Numerics.Long_Long_Elementary_Functions (GNAT)
Ada.Numerics.Short_Complex_Elementary_Functions (GNAT)
Ada.Numerics.Short_Complex_Types (GNAT)
Ada.Numerics.Short_Elementary_Functions (GNAT)

R–Z
Ada.Sequential_IO.C_Streams (GNAT)
Ada.Short_Float_Text_IO (GNAT)
Ada.Short_Float_Wide_Text_IO (GNAT)
Ada.Short_Integer_Text_IO (GNAT)
Ada.Short_Integer_Wide_Text_IO (GNAT)
Ada.Short_Short_Integer_Text_IO (GNAT)
Ada.Short_Short_Integer_Wide_Text_IO (GNAT)
Ada.Streams.Stream_IO.C_Streams (GNAT)
Ada.Strings.Unbounded.Text_IO (GNAT)
Ada.Strings.Wide_Unbounded.Wide_Text_IO (GNAT)
Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Text_IO (GNAT)
Ada.Text_IO.C_Streams (GNAT)
Ada.Wide_Text_IO.C_Streams (GNAT)
Ada.Wide_Wide_Text_IO.C_Streams (GNAT)

See also
Wikibook
Ada Programming
Ada Programming/Libraries
Ada Programming/Libraries/Standard
Ada Programming/Libraries/System
Ada Programming/Libraries/Interfaces

139 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Ada Reference Manual

A.2 The Package Ada (http://www.adaic.com/standards/95lrm/html/RM-A-2.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-A-2.html) )

Libraries: Interfaces
The Interfaces package helps in interfacing with other programming languages. Ada is one of
the few languages where interfacing with other languages is part of the language standard.
The language standard defines the interfaces for C, Cobol and Fortran. Of course any
implementation might define further interfaces - GNAT for example defines an interface to
C++.

Interfacing with other languages is actually provided by pragma Export, pragma Import
and pragma Convention

Child Packages
Interfaces.C
Interfaces.C.Extensions (GNAT)
Interfaces.C.Pointers
Interfaces.C.Streams (GNAT)
Interfaces.C.Strings
Interfaces.CPP (GNAT)
Interfaces.COBOL
Interfaces.Fortran
Interfaces.OS2Lib (GNAT, OS/2)
Interfaces.OS2Lib.Errors (GNAT, OS/2)
Interfaces.OS2Lib.Synchronization (GNAT, OS/2)
Interfaces.OS2Lib.Threads (GNAT, OS/2)
Interfaces.Packed_Decimal (GNAT)
Interfaces.VxWorks (GNAT, VxWorks)
Interfaces.VxWorks.IO (GNAT, VxWorks)

See also
Wikibook
Ada Programming
Ada Programming/Libraries
Ada Programming/Libraries/Standard
Ada Programming/Libraries/Ada
Ada Programming/Libraries/System

Ada Reference Manual

Ada 95

Annex B Interface to Other Languages

(http://www.adaic.com/standards/95lrm/html/RM-B.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-B.html) )
B.2 The Package Interfaces (http://www.adaic.com/standards/95lrm/html/RM-B-2.html)
(Annotated (http://www.adaic.com/standards/95aarm/html/AA-B-2.html) )

Ada 2005

Annex B Interface to Other Languages

(http://www.adaic.com/standards/rm-amend/html/RM-B.html) (Annotated

140 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

(http://www.adaic.com/standards/95aarm/html/AA-B.html) )
B.2 The Package Interfaces
(http://www.adaic.com/standards/rm-amend/html/RM-B-2.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-B-2.html) )

Libraries: System
Libraries: GNAT

Child packages
GNAT.Array_Split
GNAT.AWK
GNAT.Bounded_Buffers
GNAT.Bounded_Mailboxes
GNAT.Bubble_Sort
GNAT.Bubble_Sort_A
GNAT.Bubble_Sort_G
GNAT.Calendar
GNAT.Calendar.Time_IO
GNAT.Case_Util
GNAT.CGI
GNAT.CGI.Cookie
GNAT.CGI.Debug
GNAT.Command_Line
GNAT.Compiler_Version
GNAT.CRC32
GNAT.Ctrl_C
GNAT.Current_Exception
GNAT.Debug_Pools
GNAT.Debug_Utilities
GNAT.Directory_Operations
GNAT.Directory_Operations.Iteration
GNAT.Dynamic_HTables
GNAT.Dynamic_Tables
GNAT.Exception_Actions
GNAT.Exceptions
GNAT.Exception_Traces
GNAT.Expect
GNAT.Float_Control
GNAT.Heap_Sort
GNAT.Heap_Sort_A
GNAT.Heap_Sort_G
GNAT.HTable
GNAT.IO
GNAT.IO_Aux
GNAT.Lock_Files
GNAT.MD5
GNAT.Memory_Dump
GNAT.Most_Recent_Exception
GNAT.OS_Lib
GNAT.Perfect_Hash_Generators
GNAT.Regexp
GNAT.Registry
GNAT.Regpat
GNAT.Secondary_Stack_Info
GNAT.Semaphores
GNAT.Signals
GNAT.Sockets
GNAT.Sockets_examples
GNAT.Sockets.Constants

141 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

GNAT.Sockets.Linker_Options
GNAT.Sockets.Thin
GNAT.Source_Info
GNAT.Spelling_Checker
GNAT.Spitbol
GNAT.Spitbol.Patterns
GNAT.Spitbol.Table_Boolean new
GNAT.Spitbol.Table_Integer
GNAT.Spitbol.Table_VString new
GNAT.Strings
GNAT.String_Split
GNAT.Table
GNAT.Task_Lock
GNAT.Threads
GNAT.Traceback
GNAT.Traceback.Symbolic
GNAT.Wide_String_Split

See also
External links
The GNAT Library (http://gcc.gnu.org/onlinedocs/gnat_rm/The-GNAT-Library.html)

Wikibook
Ada Programming
Ada Programming/Libraries

Libraries

Predefined Language Libraries

The library which comes with Ada in general and GNAT in particular. Ada's built in library is
quite extensive and well structured. These chapters too are more reference like.

Standard
Ada
Interfaces
System
GNAT

Other Language Libraries

Other libraries which are not part of the standard but freely available.

Multi Purpose
Container Libraries
GUI Libraries
Distributed Objects
Database
Web Programming
Input/Output

See also
Wikibook

142 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Ada Programming

Ada Reference Manual

Annex A (normative) Predefined Language Environment
(http://www.adaic.com/standards/95lrm/html/RM-A.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-A.html) )

</noinclude> <noinclude>

Libraries: Multi-Purpose

AdaCL, Ada Class Library

Filtering of text files, String Tools, Process Controll, Command line parsing, CGI,
Garbage Collector, Components

See also
Wikibook
Ada Programming
Ada Programming/Libraries

Ada Reference Manual

-- does not apply --

Libraries: Container
The following Libraries help you in store an manage object inside container classes:

Booch Components
the most complete of all container class libraries (at least when used with AdaCL, Ada Class
Library).
AdaCL, Ada Class Library
A Booch Components extension pack for storing indefinite objects.
Charles
Build on the C++ STL and therefore very easy to learn for C++ developers.
AI302
Proof of concept for Ada.Containers
Ada.Containers
This language feature will be made available in the forthcoming Ada 2005 standard.

See also
Wikibook
Ada Programming
Ada Programming/Libraries

Ada Reference Manual

A.18.1 The Package Containers
(http://www.adaic.com/standards/rm-amend/html/RM-A-18-1.html) (Annotated
(http://www.adaic.com/standards/rm-amend/html/AA-A-18-1.html) )

143 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Libraries: GUI
The following Libraries can be used to make Graphic User Interfaces:

GtkAda
Ada version of the GTK+ libraries. Can be used on multiple platforms.

See also
Wikibook
Ada Programming
Ada Programming/Libraries

Ada Reference Manual

-- dowes not apply --

Libraries: Distributed
The following Libraries help you in Distributed programming:

GLADE
A full implementation of the Ada Annex E: Distributed Systems
(http://www.adaic.org/standards/95lrm/html/RM-E.html)
PolyORB
A CORBA and Annex E: Distributed Systems
(http://www.adaic.org/standards/95lrm/html/RM-E.html) implementation.

See also
Wikibook
Ada Programming
Ada Programming/Libraries
Programming:CORBA

Ada Reference Manual

Annex E (normative) Distributed Systems
(http://www.adaic.com/standards/95lrm/html/RM-E.html) (Annotated
(http://www.adaic.com/standards/95aarm/html/AA-E.html) )

Libraries: Database
The following Libraries help you in Database programming:

GNADE
description missing.
APQ

144 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

description missing.
GWindows
ODBC in Windows.

See also
Wikibook
Ada Programming
Ada Programming/Libraries

Ada Reference Manual

-- dowes not apply --

Libraries: Web
The following libraries help you in Internet or Web programming:

AdaCL, Ada Class Library

Powerful GCI implementation.
XML/Ada
XML and Unicode support.
AWS
A full-featured Web-Server.

See also
Wikibook
Ada Programming
Ada Programming/Libraries

Ada Reference Manual

-- does not apply --

Libraries: IO
The following libraries help you when doing input/output:

AdaCL, Ada Class Library

.
XML/Ada
XML and Unicode support.

See also
Wikibook
Ada Programming
Ada Programming/Libraries

145 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Ada Reference Manual

-- does not apply --

Platform
Ada is known to be very portable, but there is sometimes a necessity of using a specific
platform feature. For that matter, there are some non-standard libraries.

Ada Programming/Platform/Linux
Ada Programming/Platform/VM
Ada Programming/Platform/VM/Java
Ada Programming/Platform/VM/dotNET
Ada Programming/Platform/Windows
Ada Programming/Platform/Windows/win32binding

See also
Wikibook
Ada Programming

Ada Reference Manual

-- does not apply --

Ada Quality and Style Guide

Chapter 7: Portability (http://www.adaic.org/docs/95style/html/sec_7/)

Platform: Linux
The following libraries help you when you target the Linux Platform.

Florist
POSIX.5 binding. It will let you perform Linux system calls in the POSIX subset.
Ncurses
text terminal library.
Texttools
ncurses-based library for the Linux console.
GtkAda
GUI library (actually multiplatform).

See also
Wikibook
Ada Programming
Ada Programming/Libraries

Ada Reference Manual

-- does not apply --

146 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

External resources
The Big Online Book of Linux Ada Programming
(http://www.pegasoft.ca/resources/boblap/book.html)
Ada for GNU/Linux Team (ALT) (http://www.gnuada.org/alt.html) , a bit outdated.

Platform: Windows
The following Libraries and Tools help you when you target the MS-Windows Platform.

GWindows
Win32 binding
GNATCOM
COM/DCOM/ActiveX binding
GNAVI
Visual RAD (Rapid application development) Development environment
Console
Libraries for console I/O.

See also
Wikibook
Ada Programming
Ada Programming/Libraries

Ada Reference Manual

-- does not apply --

Platform: VM
The following libraries help you when you target a virtual machine.

Java
Programming Ada 95 in Java's JVM (JGnat)
.NET
Programming Ada 95 in C#'s CLI (A#)

See also
Wikibook
Ada Programming
Ada Programming/Libraries

Ada Reference Manual

-- does not apply --

Portals
147 of 154 09/01/06 23:23
Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

AdaBasis (http://www.iste.uni-stuttgart.de/ps/ada-software/ada-software.html)
AdaBasis consists of about 560 MB of public domain source code and documents, mainly
taken from the Public Ada Library (PAL). The software has been classified and is
presented in a hierarchical manner, separated in different application domains, and, for
some domains, with an additional multi-faceted searching facility.
The intent is to provide students, teachers and researchers with a large collection of
reusable Ada components and systems for use in language and software engineering
courses.
AdaBasis was set up by the Programming Languages Group of the Institut für Informatik
at the University of Stuttgart, Germany. They plan to enlarge the library in the future,
and welcome free public domain contributions. For more informations or to make
suggestions please contact adabasis@informatik.uni-stuttgart.de
(mailto:adabasis@informatik.uni-stuttgart.de)
AdaWorld (http://www.adaworld.com/)
Here you'll find all the different projects that are either hosted here or elsewhere on the
web and talked about, documented and updated here. For the sake of organization, the
projects have been grouped into five categories, which will also be broken down into sub
categories where necessary.
AdaPower
(http://www.adapower.com/index.php?Command=Packages&Title=Packages+for+Reuse)
Ada Tools and Resources.

SourceForge (https://sourceforge.net/softwaremap/trove_list.php?form_cat=163)
Currently there are 102 Ada projects hosted at SourceForge - including the example
programs for Programming:Ada (https://sourceforge.net/projects/wikibook-ada) .
The Public Ada Library (PAL)
(http://www.iste.uni-stuttgart.de/ps/AdaBasis/pal_1195/ada/pal.html)
The PAL is a library of Ada and VHDL software, information, and courseware that
contains over 1 BILLION bytes of material (mainly in compressed form). All items in the
PAL have been released to the public with unlimited distribution, and, in most cases (the
exceptions are shareware), the items are freeware.

See also
Wikibook
Ada Programming
Ada Programming/Tutorials
Ada Programming/Wikis

Ada Reference Manual

-- does not apply --

Ada Quality and Style Guide

-- does not apply --

GNU Free Documentation License

Version 1.2, November 2002

148 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Copyright (C) 2000,2001,2002 Free Software Foundation, Inc.

51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.

0. 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.

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 "Document", below, refers to any such manual
or work. Any member of the public is a licensee, and is addressed as "you". You accept the
license if you copy, modify or distribute the work in a way requiring permission under
copyright law.

A "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 "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 "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 "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 "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)

149 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

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
"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 "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.

A section "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
"Acknowledgements", "Dedications", "Endorsements", or "History".) To "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.

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.

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

150 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

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.

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:

A. 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.
B. 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.
C. State on the Title page the name of the publisher of the Modified Version, as the
publisher.
D. Preserve all the copyright notices of the Document.
E. Add an appropriate copyright notice for your modifications adjacent to the other
copyright notices.
F. 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.
G. Preserve in that license notice the full lists of Invariant Sections and required Cover
Texts given in the Document's license notice.
H. Include an unaltered copy of this License.
I. 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.
J. 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.
K. 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.
L. 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

151 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

titles.
M. Delete any section Entitled "Endorsements". Such a section may not be included in
the Modified Version.
N. Do not retitle any existing section to be Entitled "Endorsements" or to conflict in title
with any Invariant Section.
O. Preserve any Warranty Disclaimers.

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.

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."

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.

152 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

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.

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.

9. TERMINATION
You may not copy, modify, sublicense, or distribute the Document except as expressly
provided for under this License. Any other attempt to copy, modify, sublicense or distribute
the Document is void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under this License will not
have their licenses terminated so long as such parties remain in full compliance.

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
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.

External links
GNU Free Documentation License (Wikipedia article on the license)
Official GNU FDL webpage (http://www.gnu.org/copyleft/fdl.html)

153 of 154 09/01/06 23:23

Ada Programming/All Chapters - Wikibooks, collection... http://en.wikibooks.org/wiki/Ada_Programming/All_C...

Retrieved from "http://en.wikibooks.org/wiki/Ada_Programming/All_Chapters"

Categories: Books with print version | Ada Programming/Ada 2005 feature | Section stubs |
Ada Programming | Wikibooks enforced policies | Ada programming language | Programming

This page was last modified 23:07, 8 January 2006.

All text is available under the terms of the GNU Free Documentation License (see Copyrights for details).
Privacy policy
About Wikibooks
Disclaimers

154 of 154 09/01/06 23:23