CS 214 Lab 8: Ada

Begin by copying the program skeleton name_tester.adb from the course directory into your new directory. If you have not already done so, copy the Makefile from the course directory and take a moment to view its contents. Note that it includes ada as a target, the ada target depends on name_tester, name_tester depends on name_tester.adb, and the command following that tells make how to create name_tester from name_tester.adb. Note also that it has a clean target so that the command:

   make clean

Next, use a text editor to open the Ada file, and take a moment to study it.

From a command-terminal in your project directory, enter:

   make ada

In keeping with the (imperative) Algol/Pascal family languages, Ada's aggregate type is called the record. Unlike a class, an Ada record can store data, but not operations. Our Name type will thus be a simple "wrapper" that encapsulates three string members.

Declaring a Name Type

   ConstantDec      ::=   identifier : constant Type := Expression ;

Then use the following BNF to declare a record type named Name (following the declaration of NAME_SIZE). The general pattern for an Ada record-type declaration is

   RecordDec        ::=   type identifier is
                               record
                                  FieldList
                               end record;
   FieldList        ::=   VariableDeclaration
                          MoreFields
   MoreFields       ::=   Ø | Declaration
                              MoreFields

   StringDec        ::=   IdList : String( Range );
   IdList           ::=   identifier MoreIds
   MoreIds          ::=   , identifier MoreIds | Ø

Defining Name Operations

Initialization. When declared within a program (as opposed to a library), Ada provides no constructor mechanism to automatically initialize the fields of a record. Instead, a subprogram can be defined, and then called to explicitly perform the initialization. Such a subprogram must receive the record-object to be initialized, as well as the initialization values, and then assign the initialization values to the appropriate fields of the object. Since such a subprogram changes the value of its argument (as opposed to returning a value), it should be defined as a procedure and not a function.

Uncomment the call to Init() in the name_tester procedure. Rebuild the program. What happens? To fix the problem, we need to define an Init() subprogram.

As we have seen before, Ada subprograms can be declared in a procedure's declaration section, along with constants, types, variables, and so on:

   AdaProgram   ::=       procedure identifier is
                             DeclarationSection
                          begin
                             StatementSection
                          end identifier

   procedure Init (TheName : out Name; First, Middle, Last : in String)

   end Init;

To fill in the body of our stub, we must be able to access the fields of an aggregate type object. Like most other languages, Ada uses the dot (.) operator for this operation:

   Expression        ::=   identifier.identifier

  procedure Init(TheName: out Name;
                 First, Middle, Last : in String) is

  begin
    TheName.MyFirst := First;
    TheName.MyMiddle := Middle;
    TheName.MyLast := Last;
  end Init;

   Init(aName, "John    ", "Paul    ", "Jones   ")

Note that the size of the string literals passed as arguments must match the size of the fields to which they are assigned, or a compilation error will result, because Ada's string variables are (strongly typed) arrays.

Check what you have written, and continue when it builds and runs without any errors.

Accessors. To check that our Init() procedure is working correctly, we need to be able to access the fields of a Name aggregate. Uncomment the first pragma Assert directive in procedure name_tester; then rebuild your program. What happens?

That first pragma Assert tries to access the first-name field within a Name aggregate using a procedure called getFirst(). To "pass this test", we can write a simple function getFirst() that, given a Name object, returns its MyFirst field. Recalling that an Ada function returns a value via a return statement, such a function can be defined by:

   function getFirst(TheName : in Name) return String is
   begin
      return TheName.MyFirst;
   end getFirst;

Then uncomment the next two pragma Assert statements and add similar definitions for getMiddle() and getLast().

Note that Ada's Assert() requires two arguments:

1. The boolean expression that is expected to be true; and
2. A diagnostic string that is to be displayed if the first argument is false.

   gnatmake name_tester.adb -gnata

String Conversion. Uncomment the final pragma Assert statement, and rebuild your program. What happens?

To pass this test, we need to define a getFullName() subprogram that, given a Name object, returns a corresponding string. Because of this, it should be written as a function whose return-type is a String. Using this information, create a stub for a function named getFullName().

To fill in the body of the stub, we must concatenate together the fields of the Name parameter of the function, with intervening spaces. Recalling that Ada uses the & symbol as a concatenation operator:

   Expression          ::= StringExpr & StringExpr

Output. For debugging (and other) purposes, an output subprogram is useful. In Ada, output subprograms are usually named Put(), so uncomment the Put() statement and rebuild the program. What happens?

As indicated in this test, a Put() subprogram for our Name type must receive the Name object to be displayed from its caller, and then display each field using the Put() command for string values:

   OutputStatement ::=   Put( String );

When your program passes all of the tests and Put() correctly displays a name, use script to create an script.ada file in which you cat your source file, compile it, and run it.

That concludes the Ada portion of this lab.

Calvin > CS > 214 > Labs > 08 > Ada