Movatterモバイル変換

Intellectual Ammunition Department

Ada-95: A guide for C and C++ programmers

by Simon Johnston

Welcome

Summary

Contents

Introduction.

Document Status.

1 Ada Basics.

1.1 C/C++ types to Ada types.

1.1.1 Declaring new types and subtypes.

1.1.2 Simple types, Integers and Characters.

1.1.3 Strings.

1.1.4 Floating and Fixed point.

1.1.5 Enumerations and Ranges.

1.1.6 Arrays.

1.1.7 Records.

1.1.8 Access types (pointers).

1.1.9 Ada advanced types and tricks.

1.1.10 C Unions in Ada (food for thought).

1.2 C/C++ statements to Ada.

1.2.1 Compound Statement

1.2.2 if Statement

1.2.3 switch Statement

1.2.4 loops

1.2.4.1 loop

1.2.4.2 while loop

1.2.4.3 do loop

1.2.4.4 for loop

1.2.4.5 break and continue

1.2.5 return

1.2.6 labels and goto

1.2.7 exception handling

1.2.8 sub-programs

1.3 Ada Safety.

1.3.1 Static provability

1.3.2 Predefined exceptions and pragmas

1.3.3 Unchecked programming

2 Ada Packages.

2.1 What a package looks like

2.2 Include a package in another

2.3 Package data hiding

2.4 Hierarchical packages.

2.5 Renaming identifiers.

3 Ada-95 Object Oriented Programming.

3.1 The tagged type.

3.2 Constructors/Destructors for Ada.

3.3 Class member attributes.

3.4 Class member functions.

3.5 public/protected/private.

4 Generics

4.1 A generic procedure

4.2 Generic packages

4.3 Generic types and other parameters

5 IO

5.1 Ada.Text_IO

5.2 Ada.Sequential_IO and Ada.Direct_IO

5.3 Streams

6 Interfacing to other languages

6.1 C and C++

6.2 COBOL

6.3 Fortan

7 Concurrency

7.1 Tasks

7.1.1 Tasks as threads

7.1.2 A simple task

7.1.3 Tasks as types

7.2 Task synchronization (Rendezvous)

7.2.1 entries

7.2.2 select

7.2.3 gaurded entries

7.2.4 delays

7.2.5 select else

7.2.6 termination

7.2.7 conditional entry calls

7.3 Protected types

References

Introduction.

I will start out by describing the Ada predefined types, and the complextypes, and move onto the simple language constructs. Section 2 will startto introduce some very Ada specific topics and section 3 describes the new Ada-95 Object Oriented programming constructs. Section 5 describes theAda tools for managing concurrency, the task and protected types, these are worth investing some time getting to grips with. Section 6 is atour of the Ada IO library and covers some of the differences in concept and implementation between it and C stdio.

Please feel free to comment on errors, things you don't like and things you would like to see. If I don't get the comments then I can't take it forward,and the question you would like answered is almost certainly causing otherpeople problems too.

If you are new to Ada and do not have an Ada compiler handy then why not trythe GNAT Ada compiler. This compiler is based on the well known GCC C/C++ andObjective-C compiler and provides a high quality Ada-83 and Ada-95 compiler for many platforms. Here is theFTP site see if there is one for you.

Document Status.

Current Status

Section 2

More on 2.3 (data hiding) and 2.4 (Hierarchical packages)

Section 3

First issue of this section, 3.6, 3.7, 3.8 and 3.9 have additional workplanned. They may also require re-work pending comments.

Section 5

Section 5.3 (streams) not yet done.

Section 6

New sections to be added for each language.

Section 7

Major re-work following comments from Bill Wagner, 7.2.7 added, requiressome more words, and section 7.3 requires more justification etc.

Wish List

I would like to use a consistant example throughout, building it up as wego along. The trouble is I don't think I have space in an HTML page to do this.

1 Ada Basics.

One thing before we continue, most of the operators are similar, but you should notice these differences:

One of the biggest things to stop C/C++ programmers in their tracks is that Ada is case insensitive, sobegin BEGIN Begin are all the same.This can be a problem when porting case sensitive C code into Ada.

Another thing to watch for in Ada source is the use of ' the tick. The tickis used to access attributes for an object, for instance the following codeis used to assign to value s the size in bits of an integer.

int a = sizeof(int) * 8;a : Integer := Integer'Size;

1.1 C/C++ types to Ada types.

Note that 'objects' are defined in reverse order to C/C++, the object name isfirst, then the object type, as in C/C++ you can declare lists of objects byseperating them with commas.

int i;int a, b, c;int j = 0;int k, l = 1;i : Integer;a, b, c : Integer;j : Integer := 0;k, l : Integer := 1;

Another difference is in defining constants.

const int days_per_week = 7;days_per_week :constant Integer := 7;days_per_week :constant := 7;

1.1.1 Declaring new types and subtypes.

Ada is a strongly typed language, in fact possibly the strongest. This meansthat its type model is strict and absolutely stated. In C the use of typedefintroduces a new name which can be used as a new type, though the weak typingof C and even C++ (in comparison) means that we have only really introduceda very poor synonym. Consider:

typedef int INT;INT a;int b;a = b; // works, no problem

type INTis new Integer;a : INT;b : Integer;a := b; -- fails.

This strong typing can be a problem, and so Ada also provides you with afeature for reducing the distance between the new type and its parent, consider

subtype INTis Integer;a : INT;b : Integer;a := b; -- works.

1.1.2 Simple types, Integers and Characters.

Integer, Long_Integer etc.

Any Ada compiler must provide the Integer type, this is a signed integer,and of implementation defined size. The compiler is also at liberty to provideLong_Integer, Short_Integer, Long_Long_Integer etc as needed.

Unsigned Integers

Ada does not have a defined unsigned integer, so this can be synthesised by a range type (see section 1.1.5), and Ada-95 has a defined package,System.Unsigned_Types which provide such a set of types.

Ada-95 has added amodular type which specifies the maximum value, andalso the feature that arithmatic is cyclic, underflow/overflow cannot occur. Thismeans that if you have a modular type capable of holding values from 0 to 255, and its current value is 255, then incrementing it wraps it around to zero. Contrast this with range types (previously used to define unsigned integer types)in section1.1.5 below.Such a type is defined in the form:

type BYTEis mod 256;type BYTEis mod 2**8;

The first simply specifies the maximum value, the second specifies it in a more'precise' way, and the 2**x form is often used in system programming to specifybit mask types.Note: it is not required to use 2**x, you can use anyvalue, so 10**10 is legal also.

Character{3.5.2}

This is very similar to the C char type, and holds the ASCII character set.However it is actually defined in the packageStandard{A.1}as an enumerated type (see section 1.1.5). There is an Ada equivalent of the C set of functions inctype.h which is the packageAda.Characters.Handling.

Ada Also defines aWide_Character type for handling non ASCII character sets.

Boolean{3.5.3}

This is also defined in the packageStandard as an enumerated type (see below) as(FALSE, TRUE).

1.1.3 Strings.{3.6.3}

As in C the basis for the string is an array of characters, so you can usearray slicing (see below) to extract substrings, and define strings of setlength. What, unfortunatly, you cannot do is use strings as unbounded objects,hence the following.

type A_Recordis  record    illegal : String;    legal   : String(1 .. 20);end record;procedure check(legal :in String);

Name : String := "Simon";

For parameter types unconstrained types are allowed, similar to passingint array[] in C.

To overcome the constraint problem for strings Ada has a predefined packageAda.Strings.Unbounded which implements a variable length string type.

1.1.4 Floating{3.5.7} and Fixed{3.5.9} point.

type FloatingPoint1is new Float;type FloatingPoint2is digits 5;

The second line asks the compiler to create a new type, which is a floating point type "of some kind" with a minimum of 5 digits of precision. This is invaluable when doing numeric intensive operations and intend to port the program, you define exactly the type you need, not what you think might do today.

If we go back to the subject of the tick, you can get the number of digits which are actually used by the type by the attribute 'Digits. So having saidwe want a type with minimum of 5 digits we can verify this:

number_of_digits : Integer := FloatingPoint2'Digits;

Fixed point types are unusual, there is no predefined type 'Fixed' and suchtype must be declared in the long form:

type Fixedis delta 0.1range -1.0 .. 1.0;

There is a specific form of fixed point types (added by Ada-95) called decimal types. These add a clausedigits, and therangeclause becomes optional.

type Decimalis delta 0.01digits 10;

1.1.5 Enumerations{3.5.1} and Ranges.

type Booleanis (FALSE, TRUE);

You have already seen a range in use (for strings), it is expressed aslow .. high and can be one of the most useful ways of expressing interfaces and parameter values, for example:

type Hoursis new Integerrange 1 .. 12;type Hours24is range 0 .. 23;type Minutesis range 1 .. 60;

Now we come to the rules on subtypes for ranges, and we will define the twoHours again as follows:

type Hours24is new range 0 .. 23;subtype Hoursis Hours24range 1 .. 12;

Now we come to the combining of enumerations and ranges, so that we mighthave:

type All_Daysis (Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday);subtype Week_Daysis All_Daysrange Monday .. Friday;subtype Weekendis All_Daysrange Saturday .. Sunday;

Day : All_Days := Today;if Dayin Week_Daysthen  go_to_work;end if;

Ada provides four useful attributes for enumeration type handling, note these are used slightly differently than many other attributes as they are applied to the type, not the object.

Succ

This attribute supplies the 'successor' to the current value, so the'Succ value of an object containingMonday isTuesday.
Note: If the value of the object isSunday then an exception is raised, you cannotSucc past the end of the enumeration.

Pred

This attribute provides the 'predecessor' of a given value, so the'Pred value of an object containingTuesday isMonday.
Note: the rule above still applies'Pred ofMonday is an error.

Val

This gives you the value (as a member of the enumeration) of element n inthe enumeration. ThusVal(2) isWednesday.
Note: the rule above still applies, and note also that'Val(0) is the same as'First.

Pos

This gives you the position in the enumeration of the given element name.Thus'Pos(Wednesday) is2.
Note: the range rules still apply, also that'Last will work, and returnSunday.

All_Days'Succ(Monday) = TuesdayAll_Days'Pred(Tuesday) = MondayAll_Days'Val(0) = MondayAll_Days'First = MondayAll_Days'Val(2) = WednesdayAll_Days'Last = SundayAll_Days'Succ(All_Days'Pred(Tuesday)) = Tuesday

First

This provides the value of the first item in a range. Considering the range
0 .. 100 then'First0.

Last

This provides the value of the last item in a range, and so considering above,'Last is100.

Length

This provides the number of items in a range, so'Length isactually101.

Range

This funnily enough returns in this case the value we gave it, but you willsee when we come onto arrays how useful this feature is.

1.1.6 Arrays{3.6}.

Some example:

char name[31];int  track[3];int  dbla[3][10];int  init[3] = { 0, 1, 2 };typedef char[31] name_type;track[2] = 1;dbla[0][3] = 2;Name  :array (0 .. 30)of Character; -- ORName  : String (1 .. 30);Track :array (0 .. 2)of Integer;DblA  :array (0 .. 2)of array (0 .. 9)of Integer; -- ORDblA  :array (0 .. 2,0 .. 9)of Integer;Init  :array (0 .. 2)of Integer := (0, 1, 2);type Name_Typeis array (0 .. 30)of Character;track(2) := 1;dbla(0,3) := 2;-- Note try this in C.a, b : Name_Type;a := b; -- will copy all elements of b into a.

non-zero based ranges.

Because Ada uses ranges to specify the bounds of an array then you caneasily set the lower bound to anything you want, for example:

Example :array (-10 .. 10)of Integer;

non-integer ranges.

In the examples above we have used the common abbreviation for range specifiers. The ranges above are all integer ranges, and so we did not need touse the correct form which is:

array(typerange low .. high)

which would make Example abovearray(Integerrange -10 .. 10). Now you can see where we're going, take an enumerated type,All_Days and you can define an array:

Hours_Worked :array (All_Daysrange Monday .. Friday);

unbounded array types.

The examples above did demonstrate how to declare an array type. One ofAda's goals is reuse, and to have to define a function to deal with a 1..10array, and another for a 0..1000 array is silly. Therefore Ada allows you to define unbounded array types. An unbounded type can be used as a parametertype, but you cannot simply define a variable of such a type. Consider:

type Vectoris array (Integerrange<>)of Float;procedure sort_vector(sort_this :in out Vector);Illegal_Variable : Vector;Legal_Variable   : Vector(1..5);subtype SmallVectoris Vector(0..1);Another_Legal    : SmallVector;

This does allow us great flexibility to define functions and procedures to work on arrays regardless of their size, so a call tosort_vectorcould take theLegal_Variable object or an object of typeSmallVector, etc.Note that a variable of typeSmallvector is constrained and so can be legally created.

array range attributes.

If you are passed a type which is an unbounded array then if you want to loopthrough it then you need to know where it starts. So we can use the range attributesintroduced in1.1.5 to iterate over a given array thus:attributes for array types. Consider:

Example :array (1 .. 10)of Integer;for iin Example'First .. Example'Lastloopfor iin Example'Rangeloop

Note that if you have a multiple dimension array then the above notationimplies that the returned values are for the first dimension, use the notationArray_Name(dimension)'attribute for multi-dimensional arrays.

Initialisation by range (Aggregates{}???)

When initialising an array one can initialise a range of elements in onego:

Init :array (0 .. 3)of Integer := (0 .. 3 => 1);Init :array (0 .. 3)of Integer := (0 => 1,others => 0);

The keywordothers sets any elements not explicitly handled.

Slicing

Array slicing is something usually done with memcpy in C/C++. Take asection out of one array and assign it into another.

Large :array (0 .. 100)of Integer;Small :array (0 .. 3)of Integer;-- extract section from one array into another.Small(0 .. 3) := Large(10 .. 13);-- swap top and bottom halfs of an array.Large := Large(51 .. 100) & Large(1..50);

Note: Both sides of the assignment must be of the same type, that isthe same dimensions with each element the same. The following is illegal.

-- extract section from one array into another.Small(0 .. 3) := Large(10 .. 33);--                     ^^^^^^^^ range too big.

1.1.7 Records{3.8}.

struct _device {  int   major_number;  int   minor_number;  char  name[20];};typedef struct _device Device;type struct_deviceisrecord    major_number : Integer;    minor_number : Integer;    name         : String(1 .. 19);end record;type Deviceis new struct_device;

Ada uses the same element reference syntax as C, so to access the minor_number element of an object lp1 of type Device we writelp1.minor_number.Ada does allow, like C, the initialisation of record members at declaration.In the code below we introduce a feature of Ada, the ability to name the elements we are going to initialise. This is useful for clarity of code, but more importantly it allows us to only initialise the bits we want.

Device lp1 = {1, 2, "lp1"};lp1 : Device := (1, 2, "lp1");lp2 : Device := (major_number => 1,                 minor_number => 3,                 name         => "lp2");tmp : Device := (major_number => 255,                 name         => "tmp");

tmp : Device;-- some processingtmp := (major_number => 255, name => "tmp");

This facility improves readability and as far as most Ada programmers believemaintainability.

type struct_deviceisrecord    major_number : Integer          := 0;    minor_number : Integer          := 0;    name         : String(1 .. 19)  := "unknown";end record;

1.1.8 Access types (pointers){3.10}.

Ada access types are safer, and in some ways easier to use and understand, butthey do mean that a lot of C code which uses pointers heavily will have to bereworked to use some other means.

The most common use of access types is in dynamic programming, for example inlinked lists.

struct _device_event {  int  major_number;  int  minor_number;  int  event_ident;  struct _device_event* next;};type Device_Event;type Device_Event_Accessis access Device_Event;type Device_Eventisrecord    major_number : Integer := 0;    minor_number : Integer := 0;    event_ident  : Integer := 0;    next         : Device_Event_Access :=null;    -- Note: the assignement to null is not required,    -- Ada automatically initialises access types to    -- null if no other value is specified.end record;

When it comes to dynamically allocating a new structure the Ada allocator syntax is much closer to C++ than to C.

Event_1 :=new Device_Event;Event_1.next :=new Device_Event'(1, 2, EV_Paper_Low,null);

Ada allows you to assign between access types, and as you would expect it onlychanges what the access type points to, not the contents of what it points to.One thing to note again, Ada allows you to assign one structure to another ifthey are of the same type, and so a syntax is required to assign the contentsof an access type, its easier to read than write, so:

dev1, dev2 : Device_Event;pdv1, pdv2 : Device_Event_Access;dev1 := dev2; -- all elements copied.pdv1 := pdv2; -- pdv1 now points to contents of pdv2.pdv1.all := pdv2.all; -- !!

There is a good reason for this,Ada does not have one.

To digress for a while, Ada was designed as a language to support garbagecollection, that is the runtime would manage deallocation of no longer requireddynamic memory. However at that time garbage collection was slow, required alarge overhead in tracking dynamic memory and tended to make programs irraticin performance, slowing as the garbage collector kicks in. The language specification therefore states{13.11} "An implementation need not supportgarbage collection ...". This means that you must, as in C++ manage yourown memory deallocation.

Ada requires you to use the generic procedureUnchecked_Deallocation(see1.3.4) to deallocate a dynamic object. This procedure must be instantiated for each dynamic type and should not (ideally) be declared on a public package spec, ie provide the client with a deallocation procedure which usesUnchecked_Deallocation internally.

1.1.9 Ada advanced types and tricks.

Casting (wow)

As you might expect from what we have seen so far Ada must allow us someway to relax the strong typing it enforces. In C the cast allows us to makeanything look like something else, in Adatype coersion can allow youto convert between two similar types, ie:

type Thingis new Integer;an_Integer : Integer;a_Thing : Thing;an_Integer := a_Thing; -- illegalan_Integer := Integer(a_Thing);

This can only be done between similar types, the compiler will not allow suchcoersion between very different types, for this you need the generic procedureUnchecked_Conversion (see1.3.4) which takes as an argument one type, and returns another. The only constraint on this is that they must be the same size.

Procedure types.{}

Ada-83 did not allow the passing of procedures as subprogram parameters at execution time, or storing procedures in records etc. The rationale for this was that it broke the ability to statically prove the code. Ada-95 has introduced the ability to define types which are in effect similar to C's ability to define pointers to functions.

In C/C++ there is the most formidable syntax for defining pointers to functionsand so the Ada syntax should come as a nice surprise:

typedef int (*callback_func)(int param1, int param2);type Callback_Funcis access function(param_1 :in Integer;                                      param_2 :in Integer)return Integer;

Discriminant types{3.7}.

Discriminant types are a way of parameterising a compound type (such as arecord, tagged, task or protected type). For example:

type Event_Itemisrecord    Event_ID   : Integer;     Event_Info : String(1 .. 80);end record;type Event_Log(Max_Size : Integer)isrecord    Log_Opened : Date_Type;    Events     : array (1 .. Max_Size)of Event_Item;end record;

First we declare a type to hold our event information in. We then declare atype which is a log of such events, this log has a maximum size, and ratherthan the C answer, define an array large enough for the maximum ever, or resortto dynamic programming the Ada approach is to instantiate the record with amax value and at time of instantiation define the size of the array.

My_Event_Log : Event_Log(1000);

If it is known that nearly all event logs are going to be a thousand items insize, then you could make that a default value, so that the following code isidentical to that above.

type Event_Log(Max_Size : Integer := 1000)isrecord    Log_Opened : Date_Type    Events     : array (Integer range 1 .. Max_Size)of Event_Item;end record;My_Event_Log : Event_Log;

Again this is another way in which Ada helps, when defining an interface, to state precisely what we want to provide.

Variant records{3.8.1}.

Anyone who has worked in a Pascal language will recognise variant records,they are a bit like C/C++ unions except that the arevery different :-)

Ada variant records allow you to define a record which has 2 or more blocks ofdata of which only one is visible at any time. The visibility of the block isdetermined by a discriminant which is then 'cased'.

type Transport_Typeis (Sports, Family, Van);type Car(Type : Transport_Type)isrecord    Registration_Date : Date_Type;    Colour            : Colour_Type;case Typeiswhen Sports =>        Soft_Top      : Boolean;when Family =>        Number_Seats  : Integer;        Rear_Belts    : Boolean;when Van    =>        Cargo_Capacity: Integer;end case;end record;

So if you codeMy_Car : Car(Family); then you can ask for thenumber of seats in the car, and whether the car has seat belts in the rear, but you cannot ask if it is a soft top, or what its cargo capacity is.

I guess you've seen the difference between this and C unions. In a C unionrepresentation of the above any block is visible regardless of what typeof car it is, you can easily ask for the cargo capacity of a sports car and Cwill use the bit pattern of the boolean to provide you with the cargo capacity.Not good.

To simplify things you can subtype the variant record with types which definethe variant (note in the example the use of the designator for clarity).

subtype Sports_Caris Car(Sports);subtype Family_Caris Car(Type => Family);subtype Small_Vanis Car(Type => Van);

Exceptions{11.1}.

Exceptions are a feature which C++ is only now getting to grips with, although Ada was designed with exceptions included from the beginning. Thisdoes mean that Ada code will use exceptions more often than not, and certainlythe standard library packages will raise a number of possible exceptions.

Unlike C++ where an exception is identified by its type in Ada they are uniquely identified by name. To define an exception for use, simply

parameter_out_of_range : Exception;

These look and feel like constants, you cannot assign to them etc, you can onlyraise an exception and handle an exception.

Exceptions can be argued to be a vital part of the safety of Ada code, theycannot easily be ignored, and can halt a system quickly if something goeswrong, far faster than a returned error code which in most cases is completelyignored.

System Representation of types{13}.

As you might expect with Ada's background in embedded and systems programming there are ways in which you can force a type into specific systemrepresentations.

type BYTEis range 0 .. 255;for BYTEuse 8;

This first example shows the most common form of system representation clause,the size attribute. We have asked the compiler to give us a range, from 0 to255 and the compiler is at liberty to provide the best type available to holdthe representation. We are forcing this type to be 8 bits in size.

type DEV_Activityis (READING, WRITING, IDLE);for DEV_Activityuse (READING => 1, WRITING => 2, IDLE => 3);

Again this is useful for system programming it gives us the safety of enumerationrange checking, so we can only put the correct value into a variable, but doesallow us to define what the values are if they are being used in a call whichexpects specific values.

type DEV_Availableis BYTE;for DEV_Availableuse at 16#00000340#;

This example means that all objects of typeDEV_Available are placed at memory address 340 (Hex). This placing of data items can be done ona per object basis by using:

type DEV_Availableis BYTE;Avail_Flag : DEV_Available;for Avail_Flag'Addressuse 16#00000340#;

Note the address used Ada's version of the C 0x340 notation, however the general form isbase#number# where the base can be anything, including 2, so bit masks are real easy to define, for example:

Is_Available :constant BYTE := 2#1000_0000#;Not_Available:constant BYTE := 2#0000_0000#;

Another feature of Ada is that any underscores in numeric constants are ignored,so you can break apart large numbers for readability.

type DEV_Statusis 0 .. 15;type DeviceDetailsisrecord     status : DEV_Activity;    rd_stat: DEV_Status;    wr_stat: DEV_Status;end record;for DeviceDetailsuserecord at mod 2;    statusat 0range 0 .. 7;    rd_statat 1range 0 .. 3;    wr_statat 1range 4 .. 7;end record;

This last example is the most complex, it defines a simple range type, anda structure. It then defines two things to the compiler, first the mod clause setsthe byte packing for the structure, in this case back on two-byte boundaries.The second part of this structure defines exactly the memory image of therecord and where each element occurs. The number after the 'at' is the byte offsetand the range, or size, is specified in number of bits.

>From this you can see that the whole structure is stored in two bytes wherethe first byte is stored as expected, but the second and third elements ofthe record share the second byte, low nibble and high nibble.

This form becomes very important a little later on.

1.1.10 C Unions in Ada, (food for thought).

Firstly we must look at the two ways unions are identified. Unions are used to represent the data in memory in more than one way, the programmermust know which way is relevant at any point in time. This variant identifiercan be inside the union or outside, for example:

struct _device_input {  int device_id;  union {    type_1_data from_type_1;    type_2_data from_type_2;  } device_data;};void get_data_func(_device_input* from_device);union device_data {  type_1_data from_type_1;  type_2_data from_type_2;};void get_data_func(int *device_id, device_data* from_device);

The next step is to decide whether, when converting such code to Ada, you wishto maintain simply the concept of the union, or whether you are required tomaintain the memory layout also.Note: the second choice is usually onlyif your Ada code is to pass such a structure to a C program or get one from it.

If you are simply retaining the concept of the union then you wouldnotuse the second form, use the first form and use a variant record.

type Device_IDis new Integer;type Device_Input(From_Device : Device_ID)isrecordcase From_Deviceiswhen 1 =>        From_Type_1 : Type_1_Data;when 2 =>        From_Type_2 : Type_2_Data;end case;end record;

for Device_Inputuserecord    From_Deviceat 0range 0 .. 15;    From_Type_1at 2range 0 .. 15;    From_Type_2at 2range 0 .. 31;end record;

We can also use the abilities ofUnchecked_Conversion to convert between different types (see1.3.4). This allows us towrite the following:

type Type_1_Dataisrecord    Data_1 : Integer;end record;type Type_2_Dataisrecord    Data_1 : Integer;end record;function Type_1_to_2is new Unchecked_Conversion  (Source => Type_1_data, Target => Type_2_Data);

  Type_1_Object : Type_1_Data := ReadData;  :  Type_2_Object : Type_2_Data := Type_1_to_2(Type_1_Object);

1.2 C/C++ statements to Ada.

Note: All Ada statements can be qualified by a name, this be discussedfurther in the section on Ada looping constructs, however it can be used anywhere to improve readability, for example:

begin  Init_Code:begin      Some_Code;end Init_Code;  Main_Loop:loopif Some_Valuethenexit loop Main_Loop;end if;end loop Main_Loop;  Term_Code:begin      Some_Code;end Term_Code;end A_Block;

1.2.1 Compound Statement{5.6}

{  declarations  statements}declare  declarationsbegin  statementend;

1.2.2 if Statement{5.3}

Note: Ada does not require brackets around the expressions used in if,case or loop statements.

if (expression) {  statement} else {  statement}if expressionthen   statementelsif expressionthen  statementelse  statementend if;

1.2.3 switch Statement{5.4}

switch (expression) {  case value: statement  default:    statement}case expressioniswhen value => statementwhen others => statementend case;

This leads to a slight problem, it is not uncommon to find a switch statementin C which looks like this:

switch (integer_value) {case 1:case 2:case 3:case 4:  value_ok = 1;  break;case 5:case 6:case 7:  break;}

case integer_valueiswhen 1 .. 4    => value_ok := 1;when 5 | 6 | 7 =>null;end case;

1.2.4 Ada loops{5.5}

loop  statementend loop;

1.2.4.1 while Loop

while (expression){  statement}while expressionloop  statementend loop;

1.2.4.2 do Loop

do{  statement}while (expression)-- no direct Ada equivalent.

1.2.4.3 for Loop

for (init-statement ; expression-1 ; loop-statement){  statement}for identin rangeloop  statementend loop;

Firstly, the variable ident is actually declared by its appearance in the loop, it is a new variable which exists for the scope of the loop only and takes the correct type according to the specified range.

Secondly you will have noticed that to loop for 1 to 10 you can write the following Ada code:

for iin 1 .. 10loopnull;end loop;

for iin reverse 1 .. 10loopnull;end loop;

1.2.4.5 break and continue

while (expression) {  if (expression1) {    continue;  }  if (expression2) {    break;  }}

In Ada there is no continue, and break is now exit.

while expressionloopif expression2thenexit;end if;end loop;

while expressionloopexit when expression2;end loop;

loop  statementexit when expression;end loop;

while ((!feof(file_handle) && (!percent_found)) {    for (char_index = 0; buffer[char_index] != '\n'; char_index++) {        if (buffer[char_index] == '%') {            percent_found = 1;            break;        }        // some other code, including get next line.    }}

Main_Loop:while not End_Of_File(File_Handle)loopfor Char_Indexin Buffer'Rangeloopexit when Buffer(Char_Index) = NEW_LINE;exit Main_Loopwhen Buffer(Char_Index) = PERCENT;end loop;end loop Main_Loop;

1.2.5 return{6.5}

return value; // C++ returnreturn value; -- Ada return

1.2.6 labels and goto{5.8}

label:  goto label;<<label>>goto label;

1.2.7 exception handling{11.2}

In C++ there is no exception type, when you raise an exception you pass outany sort of type, and selection of the exception is done on its type. In Adaas seen above there is a 'psuedo-type' for exceptions and they are then selected by name.

Firstly lets see how you catch an exception, the code below shows the basicstructure used to protect statement1, and execute statement2 on detection ofthe specified exception.

try {  statement1}catch (declaration) {  statement2}begin  statement1exceptionwhen ident => statement2when others => statement2end;

try {  function_call();} catch (const char* string_exception) {  if (!strcmp(string_exception, "the_one_we_want")) {    handle_it();  } else {    throw;  }} catch (...) {  throw;}begin  function_call;exceptionwhen the_one_we_want => handle_it;when others          =>raise;end;

You will also notice the similarity between the Ada exception catching codeand the Ada case statement, this also extends to the fact that the when statement can catch multiple exceptions. Ranges of exceptions are not possible,however you can or exceptions, to get:

begin  function_call;exceptionwhen the_one_we_want |       another_possibility => handle_it;when others              => raise;end;

throw (const char*)"the_one_we_want";raise the_one_we_want;

1.2.8 sub-programs

return_type func_name(parameters);return_type func_name(parameters){  declarations  statement}function func_name(parameters)return return_type;function func_name(parameters)return return_typeis  declarationsbegin  statementend func_name

void func_name(parameters);procedure func_name(parameters);

void func1(int  by_value);void func2(int* by_address);void func3(int& by_reference); // C++ only.

type intis new Integer;type int_staris access int;procedure func1(by_value     :in     int);procedure func2(by_address   :in out int_star);procedure func3(by_reference :in out int);

void func_name();void func_name(void);int func_name(void);procedure func_name;function func_name return Integer;

Overloading

Ada allows more than one function/procedure with the same name as long asthey can be uniquely identified by their signature (a combination of their parameter and return types).

function Dayreturn All_Days;function Day(a_date :in Date_Type)return All_Days;

The first returns you the day of week, of today, the second the day of weekfrom a given date. They are both allowed, and both visible. The compiler decideswhich one to use by looking at the types given to it when you call it.

Operator overloading{6.6}

As in C++ you can redefine the standard operators in Ada, unlike C++ youcan do this outside a class, and for any operator, with any types. The syntaxfor this is to replace the name of the function (operators are always functions)with the operator name in quotes, ie:

function "+"(Left, Right :in Integer)return Integer;

Available operators are:

=	<	<=	>	>=
+	-	&	abs	not
*	/	mod	rem	**
and	or	xor

Parameter passing modes

C++ allows three parameter passing modes, by value, by pointer and byreference (the default mode for Ada).

void func(int by_value, int* by_pointer, int& by_reference);

Ada provides two optional keywords to specify how parameters are passed,in andout. These are used like this:

procedure proc(Parameter : in     Integer);procedure proc(Parameter :    out Integer);procedure proc(Parameter : in out Integer);procedure proc(Parameter :        Integer);

If these keywords are used then the compiler can protect you even more, so ifyou have anout parameter it will warn you if you use itbefore it has been set, also it will warn you if you assign to anin parameter.

Note that you cannot mark parameters without in functionsas functions are used to return values, suchside affects are disallowed.

Default parameters{6.4.1}

Ada (and C++) allow you to declare default values for parameters, this means that when you call the function you can leave such a parameter off the callas the compiler knows what value to use.

procedure Create  (File :in out File_Type;   Mode :in     File_Mode := Inout_File;   Name :in     String    := "";   Form :in     String    := "");

This example is to be found in each of the Ada file based IO packages, it opens a file, given the file 'handle' the mode, name of the file and a systemindependant 'form' for the file. You can see that the simplest invokation ofCreate isCreate(File_Handle); which simply provides the handleand all other parameters are defaulted (In the Ada library a file name of ""implies opening a temporary file). Now suppose that we wish to provide the name of the file also, we would have to writeCreate(File_Handle, Inout_File,"text.file"); wouldn't we? The Ada answer is no. By using designators ashas been demonstrated above we could use the form:

Create(File => File_Handle,       Name => "text.file");

and we can leave the mode to pick up its default. This skipping of parametersis a uniquely Ada feature.

Nested procedures

Simple, you can define any number of procedures within the definition ofanother as long as they appear before the begin.

procedure Sort(Sort_This :in out An_Array)isprocedure Swap(Item_1, Item_2 :in out Array_Type)isbeginend Swap;beginend Sort;

procedure increment(A_Value : A_Type);procedure increment  (A_Value :in out A_Type;    By      :in     Integer := 1);

1.3 Ada Safety.

Ada is also commonly assumed to be a military language, with the US Department of Defense its prime advocate, this is not the case, a number of commercial and government developments have now been implemented in Ada. Ada is an excellent choice if you wish to spend your development time solving yourcustomers problems, not hunting bugs in C/C++ which an Ada compiler would not have allowed.

1.3.1 Static provability.

Ada-95 has introduced these new features, Object Oriented programmingthrough tagged types and procedural types which make it more difficult to statically prove an Ada-95 program, but the language designers decided that such features merited their inclusion in the language to further another goal, that of high reuse.

1.3.2 Predefined exceptions and pragmas.

Constraint_Error

This exception is raised when a constraint is exceeded, such constraintsinclude

• Numeric under/overflow.
• Range bounds exceeded.
• Reference to invalid record component.
• Dereference ofnull access type.

Program_Error

This is raised by the run-time to mark an erroneous program event, such ascalling a procedure before package initialisation, or bad instantiation of ageneric package.

Storage_Error

This exception is raised when a call tonew could notbe satisfied due to lack of memory.

Tasking_Error

This is raised when problems occur during tasking rendezvous (see section7.2).

Access_Check

RaisesConstraint_Error on dereference of anull access value.

Accessibility_Check

RaisesProgram_Error on access to inaccessible object or subprogram.

Discriminant_Check

RaisesConstraint_Error on access to incorrect component in adiscriminant record.

Division_Check

RaisesConstraint_Error on divide by zero.

Elaboration_Check

RaisesProgram_Error on unelaborated package or subprogrambody.

Index_Check

RaisesConstraint_Error on out of range array index.

Length_Check

RaisesConstraint_Error on array length violation.

Overflow_Check

RaisesConstraint_Error on overflow from numeric operation.

Range_Check

RaisesConstraint_Error on out of range scalar value.

Storage_Check

RaisesStorage_Error if not enough storage to satisfy anew call.

Tag_Check

RaisesConstraint_Error if object has an invalid tag for operation.

pragma Suppress(Access_Check);pragma Suppress(Access_Check, On => My_Type_Ptr);

The point of this section is that by defaultall of these checks areenabled, and so any such errors will be trapped.

1.3.3 Unchecked programming.

Unchecked_Conversion

This generic function is defined as:

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

and should be instantiated like the example below (taken from one of the Ada-95standard library packagesAda.Interfaces.C).

function Character_To_charis new  Unchecked_Conversion (Character, char);

and can then be used to convert and Ada character to a C char, thus

A_Char : Interfaces.C.char := Character_To_char('a');

Unchecked_Deallocation

This generic function is defined as:

generictype Object (<>)is limited private;type Nameis access Object;procedure Ada.Unchecked_Deallocation (X :in out Name);

this function, instantiated with two parameters, only requires one foroperation,

type My_Typeis new Integer;type My_Ptris access My_Type;procedure Freeis new Unchecked_Deallocation (My_Type, My_Ptr);Thing : My_Ptr :=new My_Type;Free(Thing);

2 Ada Packages.{7}

It is worth first looking at the role of header files in C/C++. Header filesare simply program text which by virtue of the preprocessor are inserted intothe compilers input stream. The#include directive knows nothingabout what it is including and can lead to all sorts of problems, such aspeople who#include "thing.c". This sharing of code by thepreprocessor lead to the#ifdef construct as you would have different interfaces for different people. The other problem is that C/C++ compilations can sometime take forever because a included b included c ... orthe near fatal a included a included a ...

Stroustrup has tried ref [9] (in vain, as far as I can see) to convince C++ programmersto remove dependance on the preprocessor but all the drawbacks are still there.

Any Ada package on the other hand consists of two parts, the specification (header) and body (code). The specification however is a completely stand aloneentity which can be compiled on its own and so must include specifications from other packages to do so. An Ada package body at compile time must refer to itspackage specification to ensure legal declarations, but in many Ada environmentsit would look up a compiled version of the specification.

The specification contains an explicit list of the visible components of a package and so there can be nointernal knowledge exploited as is oftenthe case in C code, ie module a contains a functions aa() but does not exportit through a header file, module b knows how a is coded and so uses theextern keyword to declare knowledge of it, and use it. C/C++programmers therefore have to mark private functions and data asstatic.

2.1 What a package looks like

--file example.ads, the package specification.package exampleis::end example;--file example.adb, the package body.package body exampleis::end example;

2.2 Include a package in another

Working with the example package above let us assume that we need to include another package, sayMy_Specs into this package so that it may be used. Firstly where do you insert it? Like C, package specifications can be inserted into either a specification or body depending on who is the client. Like a C header/code relationship any package included in the specification of package A is visible to the body of A, but not to clients of A. Each package is a seperate entity.

-- Specification for package examplewith Project_Specs;package exampleistype My_Typeis new Project_Spec.Their_Type;end example;-- Body for package examplewith My_Specs;package body exampleistype New_Type_1 is new My_Specs.Type_1;type New_Type_2 is new Project_Specs.Type_1;end example;

You can see here the basic visibility rules, the specification has to includeProject_Specs so that it can declareMy_Type. Thebody automatically inherits any packages included in its spec, so that youcan see that although the body does not includeProject_Specsthat package is used in the declaration ofNew_Type_1. The bodyalso includes another packageMy_Specs to declare the new typeNew_Type_2, the specification is unaware of this include and socannot useMy_Specs to declare new types. In a similar way anordinary client of the packageexample cannot use the inclusion ofProject_Specs, they would have to include it themselves.

To use an item, say a the typeType_1 you must name itMy_Specs.Type_1, in effect you have included the package name, not its contents. To get the same effect as the C#include you must also add another statement to make:

with My_Specs;use My_Specspackage body exampleis::end example;

It is usual in Ada to put the with and the use on the same line, for clarity. There is much more to be said about Ada packages, but that should be enough tostart with. There is a special form of theuse statementwhich can simply include an element (types only) from a package, consider:

use type Ada.Calendar.Time;

2.3 Package data hiding{7.3}

In C this is done by presenting the 'private type' as avoid* which means that you cannot know anything about it, but implies that no one can do any form of type checking on it. In C++ we can forward declare classes and so provide an anonymous class type.

/* C code */typedef void* list;list create(void);// C++class Our_List {public:  Our_List(void);private:  class List_Rep;  List_Rep* Representation;};

In Ada this concept is formalised into the 'private part' of a package. Thisprivate part is used to define items which are forward declared as private.

package Our_Lististype List_Repis private;function Createreturn List_Rep;privatetype List_Repisrecord       -- some dataend record;end Our_List;

You may not in the public part of the package specification declare variables of the private type as the representation is not yet known, we can declare constants of the type, but you must declare them in both places, forward reference them in the public part with no value, and then again in the privatepart to provide a value:

package Exampleistype Ais private;  B :constant A;privatetype Ais new Integer;  B :constant A := 0;end Example;

package Our_Lististype List_Accessis limited private;function Createreturn List_Access;privatetype List_Rep; -- opaque typetype List_Accessis access List_Rep;end Our_List;

2.4 Hierarchical packages.

package Outerispackage Inner_1isend Inner_1;package Inner_2isend Inner_2;privateend Outer;

package Outerispackage Inner_1isend Inner_1;end Outer;package Outer.Inner_2isend Outer.Inner_2;

2.5 Renaming identifiers.

Consider:

with Outer;with Outer.Inner_1;package New_Packageis  OI_1renames Outer.Inner_1;type New_typeis new OI_1.A_Type;end New_Package;

Similarly if you want to include 2 functions from two different package with the same name then, rather than relying on overloading, or to clarify yourcode text you could:

with Package1;function Function1return Integerrenames Package1.Function;with Package2;function Function2return Integerrenames Package2.Function;

for devicein Device_Maploop  Device_Map(device).Device_Handler.Request_Device;  Device_Map(device).Device_Handler.Process_Function(Process_This_Request);  Device_Map(device).Device_Handler.Relinquish_Device;end loop;for devicein Device_Maploopdeclare    Device_Handler : Device_Typerenames      Device_Map(device).Device_Handler;begin    Device_Handler.Request_Device;    Device_Handler.Process_Function(Process_This_Request);    Device_Handler.Relinquish_Device;end;end loop;

3 Ada-95 Object Oriented Programming.

class A_Device {public:  A_Device(char*, int, int);  char* Name(void);  int   Major(void);  int   Minor(void);protected:  char* name;  int   major;  int   minor;};

The code above also introduces a constructor, a function with the same name asthe class which is called whenever the class is created. In C++ these may beoverloaded and are called either by thenew operator, or in localvariable declarations as below.

A_Device lp1("lp1", 10, 1);A_Device* lp1;  lp1 = new A_Device("lp1", 10, 1);

Ada has also extended its equivalent of a struct, therecord butdoes not directly attach the member functions to it. First the Ada equivalentof the above class is

package Devicesistype Deviceis tagged private;type Device_Typeis access Device;function Create(Name  : String;                  Major : Integer;                  Minor : Integer)return Device_Type;function Name(this : Device_Type)return String;function Major(this : Device_Type)return Integer;function Minor(this : Device_Type)return Integer;privatetype Deviceis taggedrecord      Name  : String(1 .. 20);      Major : Integer;       Minor : Integer;end record;end Devices;

lp1 : Devices.Device_Type := Devices.Create("lp1", 10, 1);

3.1 The tagged type.

The tag can be accessed by the attribute'Tag but should onlybe used for comparison, ie

dev1, dev2 : Device;if dev1'Tag = dev2'Tagthen

Another important attribute'Class exists which is used in typedeclarations to denote theclass-wide type, the inheritence tree rootedat that type, ie

type Device_Classis Device'Class;-- or more normallytype Device_Classis access Device'Class;

3.2 Class member attributes.

3.3 Class member functions.

3.4 Virtual member functions.

A pure virtual function maps onto a virtual member function with the keywordsis abstract before the semicolon. When any pure virtualmember functions exist the tagged type they refer to must also be identifiedas abstract. Also, if an abstract tagged type has been introduced which hasno data, then the following shorthand can be used:

type Root_Typeis abstract tagged null record;

3.5 Static members.

3.6 Constructors/Destructors for Ada.

Ada does provide a library packageAda.Finalization which canprovide constructor/destructor like facilities for tagged types.
Note: See ref 6.

3.7 Inheritance, single and multiple.

For example, let us now inherit the device type above to make a tape device,firstly in C++

class A_Tape : public A_Device {public:  A_Tape(char*, int, int);  int Block_Size(void);protected:  int block_size;};

package Device.Tapesistype Tapeis new devicewith private;type Tape_Typeis access Tape;function Create(Name  : String;                  Major : Integer;                  Minor : Integer)return Tape_Type;function Block_Size(this : Tape_Type)return Integer;privatetype Tapeis new Devicewithrecord      Block_Size : Integer;end record;end Device.Tapes;

3.8 public/protected/private.

Top mimic C++ private interfaces you can choose to use the method above, whichin effect makes them protected, or you can make them really private by usingopaque types (see2.3).

3.9 A more complete example.

class base_device {public:  char*   name(void) const;  int     major(void) const;  int     minor(void) const;  enum { block, character, special } io_type;  io_type type(void) const;  char   read(void) = 0;  void   write(char) = 0;    static char* type_name(void);protected:  char*   _name;  int     _major;  int     _minor;  static const io_type _type;  base_device(void);private:  int     _device_count;};

• Some const member functions.
• Some pure virtual member functions.
• A Static member function.
• Some protected member attributes.
• A Static const member attribute.
• A protected constructor.
• A private member attribute.

package Devicesistype Deviceis abstract tagged limited private;type Device_Typeis access Device;type Device_Classis access Device'Class;type IO_Typeis (Block, Char, Special);function Name(this : in Device_Type)return String;function Major(this : in Device_Type)return Integer;function Minor(this : in Device_Type)return Integer;function IOType(this : in Device_Type)return IO_Type;function  Read(this : Device_Class)return Characteris abstract;procedure Write(this : Device_Class; Output : Character)is abstractfunction Type_Name return String;privatetype Device_Count;type Device_Privateis access Device_Count;type Deviceis abstract tagged limitedrecord      Name  : String(1 .. 20);      Major : Integer;       Minor : Integer;      Count : Device_Private;end record;  Const_IO_Type   :constant IO_Type := special;  Const_Type_Name :constant String  := "Device";end Devices;

4 Generics

4.1 A generic procedure{12.6}

void sort(int *array, int num_elements);

void sort(void *array, int element_size, int element_count,           int (*compare)(void* el1, void *el2));

Now let us consider an Ada generic version of the sort function:

generictype index_typeis (<>);type element_typeis private;type element_arrayis array (index_typerange<>)of element_type;with function "<" (el1, el2 : element_type)return Boolean;procedure Sort(the_array :in out element_array);

I think that you should be able to see the difference between the Ada code andC code as far as readability (and therefore maintainability) are concerned andwhy, therefore, Ada promotes the reuse philosophy.

Now let's use our generic to sort some ofMyTypes.

MyArray :array (Integer 0 .. 100)of MyType;function LessThan(el1, el2 : MyType)return Boolean;procedure SortMyTypeis new Sort(Integer, MyType, MyArray, LessThan);SortMyType(MyArray);

We then go on to instantiate the generic procedure and declare that we have anarray calledMyArray of typeMyType using anInteger range and we have a function to compare two elements.Now that the compiler has instantiated the generic we can simply call it usingthe new name.

Note: The Ada compiler instantiates the generic and will ensure type safetythroughout.

4.2 Generic packages{12.7}

generictype Element_Typeis private;package Ada.Direct_IOis

type My_Structisrecord    ...end record;package My_Struct_IOis new Ada.Direct_IO(My_Struct);use My_Struct_IO;Item : My_Struct;File : My_Struct_IO;...My_Struct_IO.Write(File, Item);

4.3 Generic types and other parameters{12.4}

type Xis private

We can know nothing about the type, except that we may test for equality and we may assign one to another. If we add in the keywordlimited then even these abilities are unavailable.

type X(<>)is private

Added for Ada-95, this is similar to the parameter above except that we can define data items in the body of our package of type X, this may be illegal if the type passed is unconstrained, ieString. Ada-95 does not allow the instantiation of generics with unconstrained types, unless you use this syntax in which case you cannot declare data items of this type.

type Xis (<>)

The type is a discrete type, Integer, Character, Enumeration etc.

type Xis range <>

The type indicates a range, ie0 .. 100.

type Xis mod <>

The type is a modulus type of unknown size (Added for Ada-95).

type Xis digits <>

The type is a floating point type.

type Xis delta <>

The type is a fixed point type.

type Xis tagged private

The type is a tagged type, ie an Ada-95 extensible record.

with Generic_Tree;genericwith package A_Treeis new Generic_Tree(<>);package Tree_Walkeris  -- some code.end Tree_Walker;

package ASTis new Generic_Tree(Syntax_Element);package AST_Printis new Tree_Walker(AST);

5 IO

The most common problem for C and C++ programmers is the lack of the printf family of IO functions. There is a good reason for their absence in Ada, the use in C of variable arguments, the '...' at the end of the printf function spec. Ada cannot support such a construct as the type of each parameter is unknown.

5.1 Ada.Text_IO

A simple program below usesText_IO to print a message to thescreen, including numerics! These are achieved by using the types attribute'Image which gives back a String representation of a value.

with Ada.Text_IO;use Ada.Text_IO;procedure Test_IOisbegin  Put_Line("Test Starts Here >");  Put_Line("Integer is " & Integer'Image(2));  Put_Line("Float is   " & Float'Image(2.0));  Put_Line("Test Ends Here");end Test_IO;

with Ada.Text_IO;type My_Integeris new Integer;package My_Integer_IOis new Ada.Text_IO.Integer_IO(My_Integer);use My_Integer_IO;

5.2 Ada.Sequential_IO and Ada.Direct_IO

with Ada.Direct_IO;package A_Databaseistype File_Headerisrecord      Magic_Number: Special_Stamp;      Number_Of_Records: Record_Number;      First_Deleted: Record_Number;end record;type Rowisrecord      Key: String(1 .. 80);      Data: String(1 .. 255);end record;package Header_IOis new Direct_IO (File_Header);use Header_IO;package Row_IOis new Direct_IO (Row);use Record_IO;end A_Database;

declare  Handle   : Header_IO.File_Type;  A_Header : File_Header;  A_Row    : Row;begin  Header_IO.Open(File => Handle, Name => "Test");  Header_IO.Write(Handle, A_Header);  Row_IO.Write(Handle, A_Row);  Header_IO.Close(Handle);end;

When designing a package, if you want to avoid this sort of problem (the designersof these packages did intend this restriction) then embed the generic partwithin an enclosing package, thus

package generic_IOistype File_Typeis limited private;procedure Create(File : File_Type ....procedure Close .....generic     Element_Typeis private;package Read_Writeisprocedure Read(File : File_Type;                   Element : Element_Type ...procedure Write .....end Read_Write;end generic_IO;

with generic_IO;package A_Databaseistype File_Headerisrecord      Magic_Number: Special_Stamp;      Number_Of_Records: Record_Number;      First_Deleted: Record_Number;end record;type Rowisrecord      Key: String(1 .. 80);      Data: String(1 .. 255);end record;package Header_IOis new generic_IO.Read_Write (File_Header);use Header_IO;package Row_IOis new generic_IO.Read_Write (Row);use Record_IO;end A_Database;  :  :declare  Handle   : generic_IO.File_Type;  A_Header : File_Header;  A_Row    : Row;begin  generic_IO.Open(File => Handle, Name => "Test");  Header_IO.Write(Handle, A_Header);  Row_IO.Write(Handle, A_Row);  generic_IO.Close(Handle);end;

5.3 Streams

6 Interfacing to other languages

The full set of packages defined for interfaces are show below.

Interfaces

C

Pointers

Strings

COBOL

CPP

Fortran

7 Concurrency

Unlike C/C++ Ada defines a concurrency model as part of the language itself.Some languages (Modula-3) provide a concurrency model through the use of standard library packages, and of course some operating systems provide libraries to provide concurrency. In Ada there are two base components, the task which encapsulates a concurrent process and the protected type which is a data structure which provides guarded access to its data.

7.1 Tasks

7.1.1 Tasks as threads

In a multi-threaded environment multiple concurrent processes are allowed within the same address space, that is they can share global data. Usuallythere are a set of API calls such asStartThread, StopThreadetc which manage these processes.

Note: An Ada program with no tasks is really an Ada process with a single running task, the default code.

7.1.2 A Simple task

task Xisend X;task body Xisbeginloop    -- processing.end loop;end X;

7.1.3 Task as types

task type Xisend X;Item : X;Items :array (0 .. 9)of X;

7.2 Task synchronization (Rendezvouz)

The Ada tasking model defines methods for inter-task cooperation and muchmore in a system independant way using constructs known asRendezvous.

A Rendezvouz is just what it sounds like, a meeting place where two tasksarrange to meet up, if one task reaches it first then it waits for the other to arrive. And in fact a queue is formed for each rendezvous of alltasks waiting (in FIFO order).

7.2.1 entry/accept

Consider the example below, a system of some sort has a cache of elements, it requests an element from the cache, if it is not in the cache then the cache itself reads an element from the master set. If this process of reading from the master fills the cache then it must be reordered.When the process finishes with the item it callsPutBack which updates the cache and if required updates the master.

task type Cached_Itemsisentry Request(Item :out Item_Type);entry PutBack(Item :in  Item_Type);end Cached_Items;task body Cached_Itemsis  Log_File : Ada.Text_IO.File_Type;begin  -- open the log file.loopaccept Request(Item :out Item_Type)do      -- satisfy from cache or get new.end Request;    -- if had to get new, then quickly    -- check cache for overflow.accept PutBack(Item :in  Item_Type)do      -- replace item in cache.end PutBack;    -- if item put back has changed    -- then possibly update original.end loop;end Cached_Items;-- the client code begins here:declare  Cache : Cached_Items;  Item  : Item_Type;begin  Cache.Request(Item);  -- process.  Cache.PutBack(Item);end;

If the client task callsRequest before the owner task has reached theaccept then the client task will wait for the owner task. However we would not expect the owner task to take very long to open a log file,so it is more likely that it will reach theaccept first andwait for a client task.

When both client and owner tasks are at the rendezvous then the owner task executes theaccept code while the client task waits. When the ownertask reaches the end of the rendezvous both the owner and the client are set offagain on their own way.

7.2.2 select

To get around this problem we use aselect statement which allows the task to specify a number of entry points which are valid at any time.

task body Cached_Itemsis  Log_File : Ada.Text_IO.File_Type;begin  -- open the log file.accept Request(Item : Item_Type)do  -- satisfy from cache or get new.end Request;loopselectaccept PutBack(Item : Item_Type)do        -- replace item in cache.end PutBack;      -- if item put back has changed      -- then possibly update original.oraccept Request(Item : Item_Type)do        -- satisfy from cache or get new.end Request;      -- if had to get new, then quickly      -- check cache for overflow.end select;end loop;end Cached_Items;

In effect the addition of theselect statement means thatthe owner task now waits on theselect itself until oneof the specifiedaccepts are called.

Note: possibly more important is the fact that we have not changed the specification for the task at all yet!.

7.2.3 guarded entries

task body Cached_Itemsis  Log_File : Ada.Text_IO.File_Type;  Number_Requested : Integer := 0;  Cache_Size :constant Integer := 50;begin  -- open the log file.accept Request(Item : Item_Type)do  -- satisfy from cache or get new.end Request;loopselectwhen Number_Requested > 0 =>accept PutBack(Item : Item_Type)do        -- replace item in cache.end PutBack;      -- if item put back has changed      -- then possibly update original.oraccept Request(Item : Item_Type)do        -- satisfy from cache or get new.end Request;      -- if had to get new, then quickly      -- check cache for overflow.end select;end loop;end Cached_Items;

7.2.4 delays

delay 5.0;                -- delay for 5 secondsdelay Ada.Calendar.Clock; -- delay until it is ...delay until A_Time;       -- Ada-95 equivalent of above

It is more interesting to note the effect of one of these when used in a selectstatement. For example, if anaccept is likely to take a long time you might use:

selectaccept An_Entrydoend An_Entry;ordelay 5.0;  Put("An_Entry: timeout");end select;

It is possible to protect procedural code in the same way, so we might amendour example by:

task body Cached_Itemsis  Log_File : Ada.Text_IO.File_Type;  Number_Requested : Integer := 0;  Cache_Size :constant Integer := 50;begin  -- open the log file.accept Request(Item : Item_Type)do  -- satisfy from cache or get new.end Request;loopselectwhen Number_Requested > 0 =>accept PutBack(Item : Item_Type)do        -- replace item in cache.end PutBack;select        -- if item put back has changed        -- then possibly update original.ordelay 2.0;        -- abort the cache update codeend select;oraccept Request(Item : Item_Type)do        -- satisfy from cache or get new.end Request;      -- if had to get new, then quickly      -- check cache for overflow.end select;end loop;end Cached_Items;

7.2.5 select else

Theelse clause allows us to execute a non-blockingselect statement, so we could code a polling task, suchas:

selectaccept Do_Somethingdoend DO_Something;else  -- do something else.end select;

7.2.6 termination

Theterminate alternative is used for a task to specifythat the run time environment can terminate the task if all its actions arecomplete and no clients are waiting.

loopselectaccept Do_Somethingdoend Do_Something;orterminate;end select;end loop;

if Task_In_Error(Cache)thenabort Cache;end if;

selectdelay 5.0;  Put("An_Entry: timeout");then abortaccept An_Entrydoend An_Entry;end select;

7.2.7 conditional entry calls

Timed entry call

Conditional entry call

Asynchronous select

7.3 Protected types

protected type Cached_Itemsisfunction Requestreturn Item_Type;procedure PutBack(Item :in Item_Type);private  Log_File : Ada.Text_IO.File_Type;  Number_Requested : Integer := 0;  Cache_Size :constant Integer := 50;end Cached_Items;protected body Cached_Itemsisfunction Requestreturn Item_Typeisbegin    -- initialise, if required    -- satisfy from cache or get new.    -- if had to get new, then quickly    -- check cache for overflow.end Request;procedure PutBack(Item :in Item_Type)isbegin    -- initialise, if required    -- replace item in cache.    -- if item put back has changed    -- then possibly update original.end Request;end Cached_Items;

References

1 Ada Language Reference Manual

2 Ada Rationale

3 Ada Quality and Style: Guidelines for professional programmers

4 Programming in Ada (3rd Edition), J.G.P.Barnes, Addison Wesley.

5 Ada Programmers FAQ.

6 Abstract Data Types Are Under Full Control with Ada9X (TRI-Ada '94)

7 Working With Ada9X Classes (TRI-Ada '94)

8 Lovelace on-line tutorial.

9 Design and evolution of C++, Bjarne Stroustrup, Addison Wesley.

10 The annotated C++ reference manual, Margaret Ellis and Bjarne Stroustrup, Addison Wesley.

Acknowledgements