 Previous |
 Contents |
 Next |
Previous |
Contents |
Next |
What one fool can do, another can.
— Silvanus P. Thompson, Calculus Made Easy
This is what the ‘Hello world’ program looks like in Ada:
-------------------------------------------------------------
--
-- Program: Hello
-- Purpose: Display the message "Hello world!".
-- Author: John English (je@brighton.ac.uk)
--
-------------------------------------------------------------
with Ada.Text_IO; -- 1
procedure Hello is -- 2
begin -- 3
Ada.Text_IO.Put ("Hello world!"); -- 4
Ada.Text_IO.New_Line; -- 5
end Hello; -- 6
Hello world!
The first few lines of the program are comments which are
ignored by the compiler. You can use comments to add extra
descriptive details for the benefit of human readers of the
program. A comment begins with a pair of hyphens; when the
compiler sees a pair of hyphens it simply ignores the rest of
that line. The comments at the beginning are used to explain
the purpose of the program as well as who wrote it and when.
The other program lines have comments at the end; as in this
example, I’ll occasionally use comments to number particular
lines so I can refer you to them as I explain what they mean.
Programs should always give explanations of what they do,
usually as comments; however, I don’t use many comments in
this book because the explanations are in the text.
An Ada program consists of a procedure defining a sequence of actions to be carried out. In this case there are two actions which are defined by the statements on the lines numbered 4 and 5; line 4 will display the message ‘Hello world!’ and line 5 will start a new line on the screen.
Names in Ada can be any sequence of letters and digits starting with a letter. You can also use underline characters within a name to break it up into words, as in the names Text_IO and New_Line. Anything else (such as a hyphen or a space) is illegal and the compiler will complain if you try to use anything like that in a name. Names like Ada.Text_IO might make you think that full stops are allowed as well, but this is actually the two names Ada and Text_IO joined together, and similarly Ada.Text_IO.Put is a combination of the three names Ada, Text_IO and Put. Some words like with, procedure, is, begin and end are part of the language. These are known as reserved words and can’t be used as names. The following table gives a complete listing of the reserved words in Ada:
abort else new return
abs elsif not reverse
abstract end null
accept entry select
access exception separate
aliased exit of subtype
all or
and for others tagged
array function out task
at terminate
generic package then
begin goto pragma type
body private
if procedure
case in protected until
constant is use
raise
declare range when
delay limited record while
delta loop rem with
digits renames
do mod requeue xor
The compiler doesn’t care if you write names in capitals,
lower case or a mixture of the two. As far as the compiler is
concerned, Hello and HELLO and hello and heLLO are all
just different ways of writing the same word. I’ve adopted a
standard convention in this book, which is that reserved
words are always written in lower case (like procedure and
begin) and all other names are capitalised (like Hello and
New_Line). You should use the same convention as it makes
programs easier to read. One thing you need to be careful
about is mixing letters and digits. The name HELL0 (hell-zero)
is not the same as HELLO although it looks very
similar; as far as the compiler is concerned, the letter O and
the digit 0 are completely unrelated. This is one very good
reason to avoid using capital letters throughout; it’s easy to
see that Hello and Hell0 aren’t the same, and since names
can’t start with a digit the compiler will complain if you try to
start a name with a zero instead of an O.
procedure X is
-- declarations go here
begin
-- statements go here
end X;
where X is the name of the procedure and the comments
mark the places where the declarations and statements which
make up the complete procedure should go. Declarations will
be described later. You can see this general framework on
lines 2, 3 and 6 of the ‘Hello world’ program, although there
are no declarations between is and begin in this particular
case. Lines 4 and 5 have been indented slightly to show that
they are enclosed within the begin ... end part of the
procedure definition. Although the compiler doesn’t insist on
this, consistent use of indentation improves readability. In
this book I follow a standard convention for laying out Ada
programs and you should follow this standard in your own
programs. There are also programs available called source
code reformatters or prettyprinters which will lay out the
text of a program in the standard manner. If you have
something like this to hand you should use it to ensure your
programs are laid out properly. However, you are at liberty to
rewrite the program like this:
with ada.text_io;procedure hello is begin ada.text_io.
put("Hello world!");ada.text_io.new_line;end hello;
and the compiler won’t complain (although human readers
undoubtedly will!). The compiler will, however, complain by
reporting a syntax error if the words and punctuation
making up the program are not in the correct order. Correct
spelling and punctuation are essential if you want the
compiler to be able to compile your program successfully; it
won’t compile a program containing any error, however
trivial it may be. You have to say what you mean and mean
what you say in Ada. Appendix A contains a summary of the
syntax of Ada for use as a quick reference if you have trouble
remembering any of the details.
The procedures in Text_IO are defined just like the procedure Hello which makes up the main program; they each specify a sequence of actions for the computer to perform in order to display text on the screen or start a new line on the screen. So when we run this program, line 4 is executed; this is a procedure call which causes the procedure Put from Text_IO to be executed. The statements making up the procedure Put will be executed in sequence, and when we have finished executing them we’ll go back to the main program and execute line 5. The statements making up the procedure New_Line in Text_IO get executed as a result, and we then return to line 6, which is the end of the program.
For the sake of convenience, you can add a use clause at the beginning of the program. If you insert the line:
use Ada.Text_IO;
between lines 1 and 2 (after the with clause) or between lines
2 and 3 (in the declaration section between is and begin) then
the effect is as if all the names from Ada.Text_IO have been
declared inside your procedure and you can just refer to Put
and New_Line instead of Ada.Text_IO.Put and
Ada.Text_IO.New_Line. This is what the program ends up
looking like:
with Ada.Text_IO;
use Ada.Text_IO;
procedure Hello is
begin
Put ("Hello world!");
New_Line;
end Hello;
However, if you use a name that is very similar to one of the
names in Ada.Text_IO you might end up referring to the
wrong thing as a result of a simple typing error. It also
becomes unclear where a name is defined, particularly if you
are using a lot of different packages. It is generally a good
idea to employ use clauses fairly sparingly for these reasons.
Packages are not the only things you can access using context clauses; anything in your Ada library can be accessed in exactly the same way. So, having compiled the procedure Hello, it can be used as a component of a larger program like this:
with Hello; -- refers to compiled version of Hello in library
procedure Hello_3 is
begin
Hello;
Hello;
Hello;
end Hello_3;
This calls Hello three times (hence the name Hello_3) and so
it will display ‘Hello world!’ three times on three separate
lines. The output of this program should look like this:
Hello world!
Hello world!
Hello world!
It gives the same effect as if we had written the statements
making up the procedure Hello three times over, like this:
with Ada.Text_IO;
use Ada.Text_IO;
procedure Hello_3 is
begin
Put ("Hello world!"); -- first call to Hello
New_Line;
Put ("Hello world!"); -- second call to Hello
New_Line;
Put ("Hello world!"); -- third call to Hello
New_Line;
end Hello_3;
Notice that the original version of Hello_3 only uses a with
clause to access Hello; it doesn’t need to reference
Ada.Text_IO since it doesn’t use Put or New_Line or
anything else from Text_IO. When you create a main
program from Hello_3, the linker retrieves the compiled code
for Hello. Since Hello references Ada.Text_IO, the linker
then retrieves the compiled code for Text_IO; this process
continues until everything referenced by any of the
components that the linker deals with has been added to the
final program. Also, there is no use clause for Hello, since it’s
a procedure rather than a package and so doesn’t contain any
subcomponents that we can refer to.
Put (""Hello world!"");
Put ("""Hello world!""");
The first quote marks the start of the string; the next two
translate into a quote which is a part of the string; the two
after the exclamation mark translate into yet another quote
which is part of the string, and the next one marks the end of
the string. This looks messy but it’s necessary, although
fortunately the need to do this doesn’t often occur in practice.
with Ada.Text_IO, Ada.Integer_Text_IO; -- 1
use Ada.Text_IO, Ada.Integer_Text_IO; -- 2
procedure Sum is
First, Second : Integer; -- 3
begin
Put ("Enter two integers: "); -- 4
Get (First); -- 5
Get (Second); -- 6
Put ("The sum is"); -- 7
Put (First + Second); -- 8
New_Line; -- 9
end Sum;
Lines 4 to 9 are the statements which specify what the
program will do. The program begins by displaying a prompt
(line 4) so that anyone using the program knows what they
should type in. Whenever you want the user to supply any
input you should always display a prompt. There is nothing
more frustrating than a blank screen with the cursor flashing
expectantly at you and no instructions!
The next step is to read in the values that the user types at the keyboard. We need to be able to refer to these later on in the program, so we need to save them somewhere in memory and give them names to refer to them by. Line 3 declares two variables called First and Second to store the numbers in. Variables are declared between the word is and the word begin in a procedure. All variables must be declared before they can be used. We have to tell the compiler the name of the variable so that it will recognise it when it sees it. If we don’t it will report an error when it sees the name First or Second on lines 5, 6 and 8.
We must also tell the compiler what sort of data First and Second are going to hold so that it knows how much space in memory to allocate for them and what operations we are allowed to perform on them. Ada provides a standard data type called Integer to hold integer values, so we declare First and Second to be of type Integer. Note that we don’t know what the value of First or Second will be at this point in the program; declaring a variable simply reserves some space in memory but doesn’t set it to any particular value. The value is said to be undefined meaning that the language doesn’t define what it will be. The variable may or may not hold a valid value; it needs setting to a valid value of the appropriate type before you try to access it. If you want to, you can set a variable to a specific value when you declare it:
First, Second : Integer := 123;
This reserves space for the two variables and sets each of
them to a value of 123. If you wanted different values for the
two variables, you’d have to use two declarations:
First : Integer := 123;
Second : Integer := 456;
What we want to do in this case is to read values typed in by
the user into the variables. In order to do this, we need to use
another package. There is a standard package to handle the
input and output of integers called Ada.Integer_Text_IO, so
the context clauses on lines 1 and 2 specify both Ada.Text_IO
and Ada.Integer_Text_IO (Ada.Text_IO is still required to
allow us to display strings and start new lines). The procedure
Get used on lines 5 and 6 is one of the ones provided by
Ada.Integer_Text_IO; it reads a number from the keyboard
and stores it in the variable whose name is given as its
parameter. The effect of lines 5 and 6 will be to read two
numbers typed at the keyboard and store them in the variables
First and Second. You can then get at the stored value by
referring to the variable by name. You have to separate the
two integers with one or more spaces when you type them in,
e.g. 123 456; if you just type 123456 without any separating
spaces, Get will just think it’s all one number. Alternatively
you can start a new line after typing in the first number; a line
break is just as good as a space for separating the two
integers. If you don’t type in integer values as requested, the
program will halt immediately and display an error message.
Enter two integers: 123 456
The sum is 579
Lines 7 and 9 use the version of Put defined in Ada.Text_IO
for displaying strings, while line 8 uses the version of Put
defined in Ada.Integer_Text_IO for displaying integers. The
compiler is able to distinguish between the two different
usages of the name Put simply by looking at the type of value
supplied as a parameter; if it’s a string we must be referring
to Ada.Text_IO.Put which requires a string as a parameter,
whereas if it’s an integer we must be referring to
Ada.Integer_Text_IO.Put which requires an integer as its
parameter. This is handy, since otherwise every single
procedure would have to be given a different name (e.g.
Put_String and Put_Integer) which would mean having much
more to remember.
The parameter to Put on line 8 is an integer expression, i.e. a set of values being combined in some way to produce a new value. In this case the values that were stored in the variables First and Second by the calls to the Get procedure on lines 5 and 6 are added together using ‘+’ to produce another integer value. Since the compiler has been told that First and Second are integers, it knows that ‘+’ is a legitimate operation and that the result will be another integer. This result is then passed directly to Put as the value to be displayed. A full set of arithmetic operations is provided in Ada; subtraction is symbolised by ‘?’, multiplication by ‘*’ (since ‘?’ would look like the name ‘X’) and division by ‘/’. There are also a few others which will be discussed in chapter 5.
procedure Put (Item : in String);
Note that this is only a specification of the procedure; the
implementation details between is and end have been
omitted. The implementation is kept in a separate package
body which will already have been compiled and added to
your program library, so you don’t get to see it. You don’t
need to; all you need to know is what the specification tells
you, namely that there is a procedure called Put which takes
one parameter called Item. The parameter must be a String;
the reserved word in indicates that Item is an input to Put.
The value you supply for Item will be copied into Put so that
Put can display it on the screen.
You can also use the parameter name when you call the procedure, like this:
Put (Item => "Hello world!");
This can be very useful when a procedure requires several
different parameters; it helps to make it clear what the
parameters are for.
There are actually several procedures in Text_IO called Put, but they all have different parameter specifications; the compiler can work out which one you’re referring to by looking at the type of parameter you supply in the procedure call. This is known as overloading; a procedure name is ‘overloaded’ with more than one meaning.
The specification for New_Line looks like this:
procedure New_Line (Spacing : in Positive_Count := 1);
As you can see, New_Line has a parameter called Spacing.
The parameter must be a value between 1 and some upper
limit whose exact value may vary from one system to another
(it’s implementation defined). This is specified by the type
Positive_Count, which is also defined in Text_IO. To find the
exact range of values for Positive_Count, look in the Text_IO
package provided with your compiler.
We didn’t have to supply a parameter to New_Line when we called it earlier; the ‘:= 1’ in the specification is a default value which will be used if we don’t supply a value for Spacing. We could have called New_Line like this:
New_Line (Spacing => 1);
and the effect would have been exactly the same. If we want
to start two new lines in quick succession (i.e. leave a blank
line on the screen) we could call New_Line like this:
New_Line (2); -- start a new line twice, or...
New_Line (Spacing => 2); -- ...the same thing
If you look at the specification of Ada.Text_IO you will also
discover the following procedure specification:
procedure Put_Line (Item : in String);
Put_Line is the same as Put except that it starts a new line
after displaying the string supplied as its parameter; in other
words, Put_Line is the same as Put followed by New_Line.
This means that you could rewrite the ‘Hello world’ program
like this:
with Ada.Text_IO; use Ada.Text_IO;
procedure Hello is
begin
Put_Line ("Hello world!");
end Hello;
Input and output of integers is a bit more elaborate than it is
for strings. The declaration of Put in Ada.Integer_Text_IO
looks like this:
procedure Put (Item : in Integer;
Width : in Field := Default_Width;
Base : in Number_Base := Default_Base);
What this means is that there are two extra parameters called
Width and Base which can be used when displaying integers.
Field and Number_Base are just the names of some more data
types defined in Integer_Text_IO. The Width parameter must
be a value between 0 and some maximum value which varies
from compiler to compiler (it’s also implementation defined);
it determines the number of characters which will be
displayed. The default is large enough to accommodate the
largest possible value for an Integer (typically either six or 11
characters wide); this means that small integers will be
displayed with some blank space in front. By specifying some
other value you can get exactly the width you want; if the
number is too big for the width you specify it will take up as
much space as necessary to display its value with no leading
spaces. In particular, specifying ‘Width=>1’ will always
display an integer with no extra spaces. Here are some
examples:
Put (1234); -- displays " 1234"
-- (with leading spaces)
Put (1234, Width=>1); -- displays "1234"
-- (no leading spaces)
Put (1234, Width=>5); -- displays " 1234"
-- (five characters wide)
Base is a value between 2 and 16 which specifies the number
base to use for displaying the value, so that ‘Base=>2’
specifies binary output and ‘Base=>16’ specifies
hexadecimal. The default value (called Default_Base) is
defined to be 10, i.e. values will be displayed in decimal
unless you specify otherwise.
Put (29); -- displays " 29" (decimal)
Put (29, Base=>2); -- displays " 2#11101#" (binary)
Put (29, Base=>16); -- displays " 16#1D#" (hexadecimal)
Put (29, Base=>5); -- displays " 5#104#" (base 5)
Note that non-decimal numbers are displayed as based
numbers, i.e. the base followed by the value enclosed in hash
marks (# .. #).
Here are some examples which use Width and Base together:
Put (1234, Width=>1, Base=>2); -- minimum width binary value
Put (1234, Base=>2, Width=>1); -- the same
Put (1234, 1, 2); -- the same
Note that you can specify parameters in any order if you use
their names; the compiler is smart enough to know what
order they should go in and deal with them appropriately.
You don’t have to use their names (as shown in the last
example above), but if you don’t you must specify the values
in the correct order; it’s often easier and more readable to
specify them by name.
The specification for Get in Integer_Text_IO looks like this:
procedure Get (Item : out Integer;
Width : in Field := 0);
This tells us that Get has a parameter called Item which is an
output from the procedure (as specified by out); you have to
supply an Integer variable to store the output in when you call
Get. You have to supply a variable name for an out parameter
so the procedure can store the output it produces in it. Input
parameters don’t suffer from this restriction; any value of the
correct type can be provided for an input parameter (e.g. the
value of the expression First + Second on line 8 of the Sum
program). Get also has an optional parameter called Width; a
value other than zero specifies the exact number of characters
to be read (although if there aren’t enough characters on the
line it will just read up to the end of the current line).
Procedures are covered in more detail later, but as you will have gathered by now, procedures and packages play a fairly central role in writing Ada programs. Don’t worry about the details too much for now; it helps to be able to look at procedure specifications in packages and work out how to use them, but the nitty-gritty details involved in writing this sort of thing can wait until chapter 4.
| 2.1 | Ada compilers only allow a limited range of integers; nine or ten digits is typically the most you can expect the compiler to handle. If you exceed the maximum value it can handle, the program will halt with an error message. Find out what the largest integer is that your system can handle by typing in larger and larger values for the Sum program until you get an error. |
| 2.2 | Write a program which uses Put_Line to display your
initials in giant letters on the screen using asterisks,
something like this:
*********** ********
* *
* *
* ******
* *
* * *
**** ********
|
| 2.3 | Modify the Sum program to display the difference, product and quotient of the two numbers you type in as well as the sum. Think of a sensible name for the modified program instead of Sum. |
| 2.4 | Write a program which reads in three integers representing the length, width and height of a box in centimetres and displays the volume and the surface area of the box. Be sure to check your results are correct. For example, a box whose size is 1cm x 2cm x 3cm has a volume of 6 cm3 and a surface area of 22 cm2. |
This file is part of
Ada 95: The Craft of Object-Oriented Programming
by John English.
Copyright © John
English 2000. All rights reserved.
Permission is given to redistribute this work for non-profit educational
use only, provided that all the constituent files are distributed without
change.