1. 12/26/2013
ADA
PROGRAMMING
LANGUAGE
1

2. LIST OF CONTENTS..
12/26/2013
ADA short introduction
 Data Types
 Sub-Types
 Derived-Types
 Strongly Typed
 Dynamic Typing
 Control Structures
 Case Statements
 Loops (Conditional)

2

3. ADA
12/26/2013
Ada is a programming language which is suitable
for all development needs, named after Augusta
Ada King.
 Ada has built-in features that directly support:






Structured programming
Object-oriented programming
Generic programming
Distributed programming
Concurrent programming.
3

4. ADA FEATURES
12/26/2013
Strongly Typed
 Packages can be defined.
 Packages and types can be made generic.
 Tasks can be created and communicate.
 Predefined library
 Object-oriented programming is included.
 Interfaces to other languages are included in this
languages.

4

5. DATA TYPES
12/26/2013
A Type is given by a set of values and
their operations.
 Ada allows us to define our own data types,
including numeric data types.
 The elementary Ada types are:

Scalar Types
 Discrete Types
 Real Types
 Fixed Point Types
 Access Types

5

6. SCALAR TYPES
12/26/2013
The predefined package Standard contains
declarations for the standard types such as integer,
float, character and boolean, as well as defining the
operations available on them.
 The following operations are defined for all scalar
types.

=, /= Equality, inequality
 <, <=, >, >=
 in, not in Range membership text

6

7. INTEGER TYPES
12/26/2013
The following are examples of integer declarations.
 Here the standard predefined integer type is used.






Count : Integer;
X,Y,Z : Integer;
Amount : Integer := 0;
Unity : constant Integer := 1;
A_Month : Integer range 1..12;
7

8. INTEGER TYPES
12/26/2013

The following operators are also defined for all
integer types.





+,-,*,/
**
Mod
rem
Abs
Exponentiation (integer exponent only)
Modulus
Remainder
Absolute value
8

9. FLOATING POINT TYPES
12/26/2013
The following are examples of floating point
declarations.
 Floating point numbers have a relative error.

x
: float;
 a,b,c
: float;
 pi
: constant float := 3.14;
 Avogadro : constant := 6.027E23;

9

10. FLOATING POINT TYPES
The following operators are also defined for all float
types.
+,*,/, **
 abs
12/26/2013


Exponentiation (integer exponent only)
Absolute value
10

11. FIXED POINT TYPES

12/26/2013
Fixed point numbers have a bounded error, the
absolute value of which is called the delta of the
type.
 The following is example of fixed point declarations.

type Volt is delta 0.125 range 0.0 .. 255.0;
11

12. ENUMERATION TYPES
An enumeration type is defined by listing all the
possible values of the type.
12/26/2013

type Computer_Language is (Assembler, Cobol, Lisp,
Pascal, Ada);
 type C_Letter_Languages is (Cobol, C);


There are two predefined enumerated types in the
package STANDARD:
Type character.
 Type boolean.

12

13. TYPE CHARACTER
There are two built-in character types in Ada
Simple 8-bit ASCII Characters
 Wide_Character that support 16-bit Unicode/ISO
standard 10646.


12/26/2013

We can define our own types just like the integer
types

type LetterGrade is ( ‘A’, ‘B’, ‘C’, ‘D’, ‘F’, ‘I’, ‘W’);
13

14. TYPE BOOLEAN

The two values of boolean variables is true and false.
The following operators can be used with boolean types:











12/26/2013

and
or
not
xor
/=
=
'and then'
'or else'
Ada will not allow an unparenthesied expression to contain both
and's and or's.
This decreases the likelihood of misreading the intent
of a complicated boolean expression.
E.g.


(a < b) and (b > c) or (d < e) -- illegal
((a < b) and (b > c)) or (d < e) -- ok
14

15. SUB-TYPES


We can restrict the range of values a variable can take
by declaring a subtype with a restricted range of values
(this corresponds to
Pascal's user defined types).
Any attempt to place an out-of-range value into a
variable of a subtype results in an exception (program
error).
In this way program errors can be discovered. The
syntax for a subtype declaration is



12/26/2013

subtype Name is Base_Type;
subtype Name is Base_Type range lowerbound . . upperbound;
Examples of declaring subtypes are given below.

type Processors is (M68000, i8086, i80386, M68030,
Pentium, PowerPC);


subtype Old_Processors is Processors range M68000..i8086;
subtype New_Processors is Processors range
Pentium..PowerPC;
15

16. DERIVED-TYPES
12/26/2013
When subtypes are created they are still compatible
with their base type. Sometimes we may wish to
create distinctly new types that are not associated
with the original type at all.
 To do this we create a derived type from a parent
type using the following syntax

type Name is new Parent_Type;
 type Name is new Parent_Type range lower bound . . upper
bound;

16

17. DERIVED-TYPES
12/26/2013
A derived type is a completely new type and is
incompatible with any other type, even those
derived from the same parent type.
 Derived types should be used when the modeling of
a particular object suggests that the parent type is
inappropriate, or you wish to partition the objects
into distinct and unmixable classes.

type Employee_No is new Integer;
 type Account_No is new Integer range 0..999_999;

17

18. Ada Type
Access
Scalar
Array
Record
Discrete
Enumeration
12/26/2013
Composite Types
Elementary Types
Protected
Task
Real
Integer
Float
Fixed
18
Signed
Modular
Decimal
Ordinary

19. STRONGLY TYPED
12/26/2013
A strongly-typed programming language is one in which
each type of data (such as integer, character,
hexadecimal, packed decimal, and so forth) is predefined
as part of the programming language and all constants or
variables defined for a given program must be described
with one of the data types.
 Ada is a strongly typed programming language.
 A large number of compile-time checks are supported to
help avoid bugs that would not be detectable until runtime in some other languages or would require explicit
checks to be added to the source code.

19

20. STRONGLY TYPED
12/26/2013
For example, the syntax requires explicitly named
closing of blocks to prevent errors due to
mismatched end tokens.
 The adherence to strong typing allows detection of
many common software errors (wrong parameters,
range violations, invalid references, mismatched
types, etc.) either during compile-time, or otherwise
during run-time.
 Compilers also commonly check for misspelled
identifiers, visibility of packages, redundant
declarations, etc. and can provide warnings and
useful suggestions on how to fix the error.

20

21. DYNAMIC TYPING
12/26/2013
Dynamic Typing is the property of a language
where type checks are performed mostly at run
time.
 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).

21

22. 
Control Structures
Conditionals
If Statements
 Case Statements


12/26/2013

Loops
22

23. CONTROL STRUCTURES
12/26/2013
The control structures of Ada are similar in style to
most conventional languages. However some
differences remain.
 As usual Ada control structures are designed for
maximum readability, all control structures are
clearly ended with an 'end something'.

23

24. IF STATEMENTS
All if statements end with an end if statement.

if condition then
12/26/2013

statement;
else
other statement;
end if;
24

25. 

if condition then
statement;
elsif condition then
other statement;
elsif condition then
other statement;
...
else condition then
another statement;
end if;
 The final else is optional in this form of the if.
12/26/2013
To prevent the common sight of if's marching across the
page there is the elsif structure. As many elsifs as
required can used. Note the spelling of elsif carefully.
25

26. CASE STATEMENTS
Often it is necessary to compare one specific variable
against several constant expressions. For this kind of
conditional expression the case statement exists. For
example:
case X is
when 1 =>
Walk_The_Dog;
when 5 =>
Launch_Nuke;
when 8 | 10 =>
Sell_All_Stock;
when others =>
Self_Destruct;
end case;
12/26/2013

26

27. LOOPS (CONDITIONAL)
Loops allow you to have a set of statements
repeated over and over again.





12/26/2013

Endless Loop
Loop with Condition at the Beginning
loop with condition at the end
loop with condition in the middle
for loop
27

28. ENDLESS LOOP
as a relative term here — if the computer is
switched off then even endless loops will end very
abruptly.

12/26/2013

Endless_Loop :
loop
Do_Something;
end loop Endless_Loop;
 The loop name (in this case, "Endless_Loop") is an
optional feature of Ada.
 Naming loops is nice forreadability but not strictly
needed.
28

29. LOOP WITH CONDITION AT THE BEGINNING

12/26/2013
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;
29

30. LOOP WITH CONDITION AT THE END

12/26/2013
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;
30

31. 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.


12/26/2013

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. We can also have more
then one exit statement.
31

32. 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.





12/26/2013

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.
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.
32

33. CONCLUSION
Ada is a huge language. It is to be remembered
that the main objective of the Ada design was to
incorporate the contemporary software engineering
knowledge. Ada is used in the areas of Air Traffic
Control Systems (in various countries), Railway
Transportation Systems (such as Paris Metro and
Hong Kong Subway) and Banking/Finance (Reuters
and others).
12/26/2013

33