CS 214 Lab 6: Ada

Begin by copying the program skeleton split.adb from the class directory into your new directory. Then use your favorite text editor to open the file, and take a moment to study it, to see how it implements our basic algorithm.

To write a subprogram that performs step 2 of our algorithm, we need some means for that subprogram to send back two pieces of information: the two parts of the string being split.

In Ada, a procedural subprogram is called a procedure:

   Subprogram      ::=   Function | Procedure
   Procedure       ::=   procedure identifier (ParameterDecs) is
                         Declarations
                         begin
                           Statement;
                           MoreStatements
                         end identifier;
   MoreStatements  ::=   Statement ; MoreStatements | Ø

As we have seen before, Ada parameters are defined within the subprogram's first line, between its parentheses. Ada's procedure parameters are a bit different than its function parameters:

   ParameterDecs   ::=   Ø | ParamDec MoreParamDecs | Ø
   ParamDec        ::=   idList : Mode Type
   MoreParamDecs   ::=   ; ParamDec MoreParamDecs | Ø
   idList          ::=   identifier MoreIds
   MoreIds         ::=   , identifier MoreIds | Ø
   Mode            ::=   in | out | in out | Ø
   Type            ::=   integer | natural | positive | float 
                         | character | string | ...

Recall that Ada provides the String type for storing sequences of characters (as seen in the main program). Ada actually provides three different kinds of Strings:

String designates a fixed-length string whose length is determined by its declaration.
Bounded_String designates a string whose length is bounded by a size specified at its declaration.
Unbounded_String designates a string whose length can change during program execution, using dynamic allocation.

For the sake of simplicity, use the type String to declare parameters named The_String, Part1, and Part2.

As indicated in the preceding productions, Ada procedure parameters should be declared with a mode that designates their relationship to their corresponding parameter:

The in mode is used to designate parameters whose values flow into the procedure, but not out. Put differently, this mode is for parameters whose values will be read, but not written to. Such parameters are the equivalent of value parameters in C++.
The out mode is used to designate parameters whose values flow out of the procedure, but not into it. Put differently, this mode is for parameters whose values will be written to, but not read.
The in out mode is used to designate parameters whose values flow both in and out of the procedure. Put differently, this mode is for parameters whose values will be both read and written to. Such parameters are the equivalent of reference parameters in C++.

If a parameter's mode is omitted, then the parameter's mode defaults to in. However, it is considered good style to specify the modes of all parameters in a procedure, for the sake of readability. (All parameters in an Ada function must be mode in, and so the mode is typically omitted for function parameters.)

Using this information, define a subprogram stub named split() that satisfies our problem specification.

To fill in the body of the subprogram, we must be able to select a substring of our parameter the_String. For Ada's fixed-length strings, this is accomplished using the substring operation:

   SubStringOp      ::=   identifier(Start .. Stop)
   Start            ::=   PositiveExpression
   Stop             ::=   PositiveExpression

This operation returns the substring of the string named identifier, beginning at index Start, and ending at index Stop. (In Ada terminology, this is called the slice operation.)

For fixed-length arrays, the normal Ada assignment operator (:=) can be used to copy values between two arrays provided the arrays are the same length.

Unfortunately, that is not the case here: parameter First_Part is an array whose size generally speaking different than the size of the substring we wish to assign to it. The sizes of Last_Part and the substring we wish to assign to it are similarly mismatched.

The Ada.Strings.Fixed package contains a Move() procedure that can be used to copy between fixed-length strings of different sizes. Its syntax is:

  MoveProcedure     ::=   Move(FromStr,ToStr);

where FromStr is the string we are copying from, and ToStr is the string we are copying to. This Move() procedure, in combination with the substring operation, can be used to set the values of First_Part and Last_Part.

Ada also provides some special array attributes that are useful for our situation:

By default, the index of the first value in an Ada array is 1, but a programmer is free to use differed index values. An expression like:
```
       arrayName'First
```
can be used to retrieve the index of the first character in an array, regardless of how a programmer has defined that array.
Likewise, to find the index of the last value in an Ada array, an expression like:
```
       arrayName'Last
```
can be used, regardless of how a programmer has defined that array.
To find the length of a fixed-length array in Ada, an expression like:
```
       arrayName'Length
```
can be used.

Drawing on these observations, complete the split() stub. If necessary, use one of the available Ada references to look up the syntax details. Don't forget to add Ada.Strings.Fixed to your program's with and uses directives!

Compile and test your code for correctness; then use script to create a file in which you cat your file, compile it, and show that it works correctly for the input string hello. Since our Ada strings are using default indexes (i.e., indexed relative to 1), test using the position values 1, 4 and 6. Save the resulting script file to be concatenated to your submission.

That concludes the Ada part of this lab.

Calvin > CS > 214 > Labs > 06 > Ada

This page maintained by Joel Adams.