10 An Introduction to Ada

Ada is a full-featured language with many capabilities, rules, and nuances. Although the fundamentals are easy to learn (Ada somewhat resembles BASIC), it is several times larger that C, and to truly master the language requires considerable practice. To make understanding easier, the discussion is broken up into two chapters. This chapter outlines the basics of the language, and the next chapter discusses features for team development, large projects, and other specialized tasks.

This in no way covers everything there is to know about Ada. I've chosen to cover those features that have been the most use to me over the years in my projects. For example, array slicing alone could take up several pages of discussion, but I've never had a need for it in recent years. Of course, you may be involved in a project in which array slicing is crutial. In these cases, I recommend you get a good Ada 95 reference such as Barnes' Programming in Ada 95.

Likewise this is not a complete introduction to computer programming. Some background knowledge is assumed.

Ada also has many specialized features for specific tasks such as scientific computing and real-time systems. Where I deliberately skip a subject, I usually make a note that I have done so. I've also hilighted useful information for C programmers who are learning Ada.

Now, on to main programs.

10.1 Your Main Program

A main program in Ada is a procedure with no parameters that starts your program running. This is the set of instructions that the computer begins to follow when your program is first executed.

The following program will print a message on the screen when you run it.

with Ada.Text_IO;
procedure firstProgram is
-- my first Ada program
begin
  Ada.Text_IO.Put_Line( "This is my first Ada program." );
end firstProgram;

An Ada program consists of sets of words and punctuation symbols. The words fall into two categories. First, the words in bold in bold are called keywords. These are words that have special meaning to Ada. Second, the words that aren't in bold are identifiers. These are the names of variables, procedures, packages and other items with names or titles in the language.

In this program, begin is a keyword because Ada uses the word "begin" to denote where the program is to begin executing instructions. On the other hand, "firstProgram" is an identifier because it is the name of our program.

All keywords in Ada are also reserved words: this means that the keywords cannot be used as identifiers.

The main program can have any name, as long as the name matches the filename. In gnat, the source code for a main program ends in .adb (Ada body). This program should be saved as firstprogram.adb.

If you call a program "test.adb", remember that test is a built-in shell command. To run a program named test, you'll have to type "./test" instead of "test" to avoid running the shell command by mistake.

Comments are denoted by two minus signs (--). This is a note to the reader; Ada will ignore it. Everything you type to the right of the symbol is treated as a remark to the reader.
 

10.2 Text_IO

Like many modern computer languages, Ada doesn't have any built-in methods of reading the keyboard or writing messages on the screen. It doesn't assume you're writing a program for a PC (you could be doing embedded programming, for example)--but in general, you need to interpret what people type and display the results to the screen. You have to add this functionality specifically.

The standard input/output package for Ada is Text_IO. This package prints characters and strings to the screen and reads characters and strings from the keyboard. It can also read and write simple sequential text files. (Packages will be discussed in detail starting at 11.1 in the next chapter.)

Text_IO is only useful for simple programs. It doesn't have the ability to draw buttons, windows or menus. For X Windows programming, you'll require other packages/libraries to perform input and output.

The most commonly used operations are:

• Put - write to the screen, but don't start a new line
• Put_Line - write to the screen and start a new line
• New_Line - start a new line
• Get - read a character from the keyboard
• Get_Line - read a string from the keyboard

The following program is an example of Text_IO.

with Ada.Text_IO;
use Ada.Text_IO;

procedure basicio is
-- this program demonstrates basic input/output

  c : character; -- this is a letter

begin

  Put_Line( "This program displays information on the screen" );
  Put_Line( "and reads information from the keyboard");
  New_Line;

  Put_Line( "Put_Line displays a line of text and advances to" );
  Put_Line( "the next line." );

  Put( "Put " );
  Put_Line( "displays text, but it doesn't start a new line" );

  Put_Line( "New_Line displays a blank line");
  New_Line;

  Put_Line( "Get waits for a character to be typed.");

  Put_Line( "Type a key and the Enter key to continue." );
  Get( c );
  Put_Line( "The character you typed was '" & c & "'" );

end basicio;

This program displays information on the screen
and reads information from the keyboard

Put_Line displays a line of text and advances to
the next line.
Put displays text, but it doesn't start a new line
New_Line displays a blank line

Get waits for a character to be typed.
Type a key and the Enter key to continue.
c
The character you typed was 'c'

Besides letters and numbers, there are special characters called control characters which, instead of displaying a character, change the Linux display. To print controls characters, you need to use one of Ada's built-in character sets. For example, ASCII is a predefined list of all the ASCII characters. To send an explicit form feed character, use

  Put( ASCII.FF );

Some common control characters are:

• ASCII.NUL - C end of string character
• ASCII.CR - carriage return - move to beginning of line
• ASCII.HT - horizontal tab
• ASCII.LF - line feed - start a new line
• ASCII.FF - form feed - start a new page on a printer

Besides ASCII, Ada has a number of other character sets defined in the Ada.Characters packages.
 

The ASCII set is officially made obsolete in Ada 95 by Ada.Characters.Latin_1, but it's still often used because it's easier to type.

10.3 Fundamental Data Types

Generally speaking, programs take data, process it in different ways, and create new information. Data is categorized into different data types.

Data that is typed into a program is known as literals. Ada has several kinds of literals:

• 'c' is a character. Character literals are enclosed in single quotes.
• -5 is an integer
• 45.5 is a float or a fixed with one decimal place
• "This is a string" is a fixed string. Strings literals are enclosed in double quotes.

  "This is my string" & ASCII.NUL;

There are three kinds of real numbers. A fixed, or fixed point, number is a number that has a fixed number of decimal points. For example, U.S. dollars are often represented using fixed numbers because there are two decimal places. A float, or floating-point, number is a number that doesn't have a fixed number of decimal places. Decimal numbers are a variation of fixed numbers commonly used for currency.

Some Ada programmers recommend that floats are used whenever possible because float calculations are usually faster than fixed calculations. This is because most computers today have floating point support in their hardware.

Fixed point numbers are declared with a delta part (and optional range limit) which the compiler uses to determine the minimum number of bits needed to store the number and the fractional part. If you need a specific reason (for example, if you intend to use a for loop to step through the range of the type), chose it using a for clause.

  type aFixedNumber is delta 0.1 range 0.0 .. 1.0;
  -- represented as multiples of 0.0625 (1/128)
  type aFixedNumber2 is delta 0.1 range 0.0 .. 1.0;
  for aFixedNumber2'Small use 0.1;
  -- represented as multiples of 0.1

On Linux, decimal numbers use floating-point arithmetic.

Floating point numbers are very important for business and scientific applications. When floating point numbers are converted to integers, do the numbers round to the nearest integer or is the decimal part simply discarded? In C, this is system dependent: System V-based UNIX's usually round to the nearest integer, while some other systems discard the decimal part. (Others, like HP-UX, the number rounds towards the nearest even integer providing the floating point number is exactly half way between two integers.)

On Linux, C truncates the decimal part.

In Ada, the way numbers round are strictly defined by the language: you can be sure that, no matter what operating system you are using, floating point numbers converted to integers will always round to the nearest integer. If the floating point number is half way between two integers, it will round "up".

The following program demonstrates floating point rounding:

with ada.text_io, ada.float_text_io;
use ada.text_io, ada.float_text_io;

procedure rounding is
  -- rounding example

  procedure ShowRounding( f : float ) is
    -- show the floating point value, and show the value
    -- after it's converted to an integer
    int_value : integer;
  begin
    Put( "  Float number " );
    Put( f, fore => 5, aft => 3 );
    int_value := integer( f );
    Put_Line( " rounds to " & int_value'img );
  end ShowRounding;

begin
  Put_Line( "This is a demonstration of how Ada 95 rounds" );
  New_Line;

  ShowRounding( 253.0 );
  ShowRounding( 253.2 );
  ShowRounding( 253.5 );
  ShowRounding( 253.8 );
  ShowRounding( -253.8 );

end rounding;


This is a demonstration of how Ada 95 rounds

  Float number     2.530E+02 rounds to  253
  Float number     2.532E+02 rounds to  253
  Float number     2.535E+02 rounds to  254
  Float number     2.538E+02 rounds to  254
  Float number    -2.538E+02 rounds to -254

You can compare the results with the following C program:

#include <stdio.h>

static void show_rounding( float f ) {
   int i;

   i = f;
   printf( "  Float number %g", f );
   printf( " rounds to %d\n", i );

} /* show rounding */

int main () {

  show_rounding( 253.0 );
  show_rounding( 253.2 );
  show_rounding( 253.5 );
  show_rounding( 253.8 );
  return 0;

}

  Float number 253 rounds to 253
  Float number 253.2 rounds to 253
  Float number 253.5 rounds to 253
  Float number 253.8 rounds to 253

Rounding to integers is a common way in C business applications to round money to the nearest dollar or cent. This is accomplished by multiplying the floating point value by 100.0, adding .5, and then taking the integer value and converting it once more into a floating point value. In Ada, there's a built-in type attribute to round floating point numbers: this makes conversion to an integer unnecessary.

type int is new Integer;
type short is new Short_Integer;
type long is range -(2 ** lbits1) .. +(2 ** lbits1) - 1;
type signed_char is range SCHAR_MIN .. SCHAR_MAX;
  for signed_char'Size use CHAR_BIT;
type unsigned is mod 2 ** int'Size;
type unsigned_short is mod 2 ** short'Size;
type unsigned_long is mod 2 ** long'Size;
type unsigned_char is mod (UCHAR_MAX + 1);
for unsigned_char'Size use CHAR_BIT;

As it's name suggests, the Text_IO package only performs I/O with text, not numbers or other types of information. If you want to print, say, and integer value using Text_IO, you must first convert the integer to a string using the 'img attribute (or 'image). (Attributes are discussed in the next section.)

with Ada.Text_IO;
use Ada.Text_IO;

procedure basicio2 is
-- this program demonstrates more advanced input/output

  i : integer := 5; -- this variable contains an integer number
                    -- i initially has the value of 5
  s : string(1..20); -- this variable contains a 20 character string
  len : natural;

begin

  Put_Line( "This program displays information on the screen" );
  Put_Line( "and reads information from the keyboard");
  New_Line;

  Put_Line( "'img returns the string representation of a variable's" );
  Put_Line( "value. The value i is" & i'img);
  New_Line;

  s := "...................."; -- set s to 20 periods

  Put_Line( "The variable s is " & s);
  Put_Line( "Get_Line reads a string from the keyboard" );
  Put_Line( "Type in a message up to 20 characters and press Enter:" );
  Get_Line( s, len );

  Put_Line( "After Get_Line copies your message to s, s is now '" & s & "'" );
  Put_Line( "The message is" & len'img & " characters long." );

  Put_Line( "The characters after your message remain unchanged." );

end basicio2;

This program displays information on the screen
and reads information from the keyboard

'img returns the string representation of a variable's
value. The value i is 5

The variable s is ....................

Get_Line reads a string from the keyboard
Type in a message up to 20 characters and press Enter:
jingle bells

After Get_Line copies your message to s, s is now 'jingle bells........'
The message is 12 characters long.

The characters after your message remain unchanged.

with Ada.Text_IO;
use Ada.Text_IO;

procedure basicio3 is
  -- this program demonstrates more even advanced input/output

  i : integer := 5; -- this variable contains an integer number
                    -- i initially has the value of 5
  s : string(1..5); -- this variable contains a 5 character string

  len : natural;    -- length of string

begin

  Put_Line( "This program displays information on the screen" );
  Put_Line( "and reads information from the keyboard");
  New_Line;

  Put_Line( "The value i is" & i'img);
  New_Line;

  Put_Line( "integer'value changes a string into an integer value" );
  Put_Line( "Type in a 4 character integer characters with a leading" );
  Put_Line( "space or negative sign and press Enter:");
  Get_Line( s, len );

  i := integer'value( s );
  Put_Line( "The value of i is " & i'img);
  New_Line;

end basicio3;

This program displays information on the screen
and reads information from the keyboard

The value i is 5

integer'value changes a string into an integer value

Type in a 4 character integer characters with a leading
space or negative sign and press Enter:
2345

The value of i is 2345

Besides Text_IO, Ada provides additional "Text_IO" packages for the basic Ada data types. Using these packages, you don't need to use 'img to convert the variable to a string. For example, the package Ada.Integer_Text_IO can put and get integers, and Ada.Float_Text_IO can put and get floating point numbers. You can use these packages simultaneously with Text_IO.

These additional packages do not have Put_Line or Get_Line because these are specifically for strings. The Put command has two additional capabilities: to space information to fit into specified field widths, and to display numbers in formats other than base 10.

10.4 Type Attributes

Ada has a selection of attributes, or built-in functions, that can be applied to types and variables. Attributes are attached to the end of a type or variable name using a single quote.

The most useful attribute, the 'img attribute, returns the ASCII image of what it's attached to, which is handy for printing values on the screen using only Ada's Text_IO package. (5)'img, for example, is the string "5". false'image, the image of the boolean value false, is the string "FALSE" in capital letters. One quirk of 'img is that if the value is a positive number, 'img adds a leading blank.

'img is a GNAT shorthand for the Ada attribute 'image. 'image requires you to specify the type of the parameter. integer'image( 5 ) is the string "5". This attribute is useful on complicated expressions where 'img won't work because of the lack of parentheses.

Here's a list of Ada 95 attributes: [To Be Completed]

Access - access value for an identifier

10.5 Operations and Expressions

 

C: C boolean operators always short circuit. In Ada, there are both short circuiting operations and operations that do not short circuit.

Short circuiting operations are not considered true operators, and as such, can't be overloaded (see below).

 

Membership Tests (in and not in) are not considered true operators and can't be overloaded.

10.6 Variable Declarations

  runningTotal : integer := 0;

  sb : float renames EmployeeList( CurrentEmployee ).SalaryInfo.Bonus;

10.7 New Types