Meridian Ada for the Mac

By Paul Zarchan, Steve Nelson, Cambridge, MA

Background and Introduction

In 1975, in response to the perceived software crisis, the Department of Defense published a set of requirements that should be met by any programming language before it would be allowed for use. Since none of the languages at that time met the requirements a competition was announced for the design of a modern programming language. Four teams took part in a competition which was won by Honeywell Bull in Paris. After the winning proposal was selected in 1978, it was distributed to institutions throughout the world for comment, and after subsequent amendment, it was accepted as a standard in the USA. The new language was known as Ada. Ada currently receives a great deal of support from the US Department of Defense and has been accepted as an industry standard by the Commission of the European Communities.

For those readers who either want to or are forced to use Ada there is good news. Meridian Software Systems has introduced a relatively low cost (compared to other Ada compilers) Ada compiler for the Mac. Full generics, tasking and separate compilation are supported with the Meridian Ada 4.1 compiler.. The compiler comes with an interactive source level debugger, a utility library consisting of a set of Ada packages for use with the compiler, an optimizer which performs a variety of local and global optimizations and the Mac Environment Library which binds the Macintosh Toolbox and operating system. In addition, the package also contains a notebook of extensive documentation and 11 800k installation disks (including MPW 3.0). Also included are many Ada source code examples to illustrate features of the language and it’s integration with the Macintosh. Programs created with Meridian Ada 4.1 can run either as tools under MPW or as Macintosh applications. The Meridian compiler runs on Macintosh platforms ranging from an SE to an FX with at least 1 MB of RAM. We tested it on an old 16 Mhz Mac II.

Ada Installation Process

The manual describes the MPW and Ada installation process. Unfortunately the process is not completely clear and it is assumed that the user already has a knowledge of MPW. In fact, if the user does not have a knowledge of MPW, the probability of a correct installation, without help, is virtually nil. We believe that future versions of this compiler should be more user friendly and assume that the user does not know and may not even be interested in MPW. This approach was taken with Absoft’s MacFortran II.

Sample Problem

In order to test the ADA compiler a simple floating point example was chosen (not supplied by Meridian) in order to test both the language’s access to important scientific functions and executable speed. For those readers who do not yet know Ada (but may soon have to) a FORTRAN listing of the test program appears in Listing 1. We can see from the source code that we are merely looping through various transcendental functions 100,000 times.

_________________________________________________________

 ntim=long(362)
 x=1.
 do 22 i=1,100000
 y=sin(x)
 y=log(x)
 y=exp(x)
 y=sqrt(x)
 y=atan(x)
 x=x+.01
 22continue
 ztim=(long(362)-ntim)/60.
 write(9,*)y
 write(9,*)ztim
 pause
 end
_________________________________________________________
Listing 1 FORTRAN Source Code of Test Problem

When the FORTRAN test program was run with Version 2.3 of the Absoft FORTRAN compiler on a 16 MHz Mac II, the execution time for the compiled program was 13.5 sec. The sample program was rewritten in ADA and the resultant source code appears in Listing 2.

_________________________________________________________

-- Paul Zarchan’s float test procedure.

with ada_io; use ada_io;
with Mac_Types; use Mac_Types;
with math_lib; use math_lib;
with Events;
procedure pzfloat is
 x :float:=1.0;
 y :float;
 time :float;
 ticks  :longint;
begin
 ticks:=Events.TickCount;
 for i in 1..100000 loop
 y:=sin(x);
 y:=ln(x);
 y:=exp(x);
 y:=sqrt(x);
 y:=atan(x);
 x:=x+0.01;
 end loop;
 ticks:=Events.TickCount-ticks;
 time:=float(ticks)/60.0; --float(ticks) converts to float.
 put(y);
 new_line;
 put(time);
end;
__________________________________________________________
Listing 2 Ada Source Code of Test Problem

The compilation of the Ada source code can either be accomplished by using the MPW language in the Worksheet or directly from the Ada menu. For those readers who do not know MPW, the step by step menu approach for compilation of the source code follows. First we select Ada... from the Meridian Ada menu as shown in Fig. 1.

Figure 1 Step 1 In Ada Compilation Process

Next a dialog box with many Ada Options shows up as shown in Fig. 2. The user must tell the Ada compiler which source code files to use. Therefore the user clicks on the Ada Source Files... button as shown in Fig. 2. For skilled MPW users, the resultant MPW code also appears under the Command Line in the dialog box.

Figure 2 Step 2 In Ada Compilation Process

Next the user must select the source code file (using the .ada convention) to be compiled. After double clicking on the float.ada file in the scroll box, the user clicks on the Done button as shown in Fig. 3.

Figure 3 Step 3 In Ada Compilation Process

Another dialog box appears as shown in Fig. 4. This time the user clicks on the Ada button to begin the compilation process. The compilation process is much slower than other languages which are compiled under the Finder but comparable in speed to languages which are compiled in the MPW environment.

Figure 4 Step 4 In Ada Compilation Process

Finally the user goes back to the Meridian Ada menu and selects the BAMP... menu item as shown in Fig. 5.

Figure 5 Step 5 In Ada Compilation Process

Another dialog box appears as shown in Fig. 6 requesting the user to type in the Main Procedure name. After typing in pzfloat into the appropriate edit field, the user clicks on the Bamp button to complete the compilation process (i.e., code is being assembled and linked).

Figure 6 Step 6 In Ada Compilation Process

Finally, the user is ready to execute the program. This is accomplished by typing pzfloat into the MPW Worksheet and hitting the Enter key. We can see from the Worksheet that the execution time for this sample program is 26.4 sec on the 16 Mhz Mac II. The execution time in Meridian Ada is twice as slow as the program executed in Absoft FORTRAN on the same machine. In both the Ada and FORTRAN cases the 68881 math co-processor was addressed. On some programs (but not this one) dramatic reductions in execution time can be achieved if the option Suppress All Checks is selected (see Fig. 2 for example) which disables the Ada run-time checking.

Figure 7 Answers to Executable Ada Code

It is important to note that the answers are written in the MPW Worksheet. If one wanted to write the answers in a window, the user would have to do extra work.

We intentionally introduced errors into the source code to see how the Ada compiler would respond. Unfortunately in many cases the compiler indicated the offending line number of the source code. In other MPW compilers (Absoft’s MacFortran II for example) one selects the error message in the MPW Worksheet, hits the Enter key and the cursor automatically moves to the offending line in the source code. This feature is very useful for debugging but unfortunately does not exist at this time with the Meridian Ada compiler.

Another Example

In order to demonstrate how to use a main program to call a procedure in a separately compiled package in Ada, let us consider another simple example. Listing 3 presents a main program entitled callit.ada. This program uses a package entitled my_adder

___________________________________________________________
with my_adder;
with ada_io; use ada_io;
procedure callit is

 c :  integer;

begin
 my_adder.add_em_up(1,2,c);
 put(c);
 new_line;
 my_adder.add_em_up(2,3,c);
 put(c);
 new_line;
 my_adder.add_em_up(4,5,c);
 put(c);
 new_line;
end;
___________________________________________________________
Listing 3 Ada Main Program For Second Example

Listing 4 is the package called my_adder. It’s Macintosh file name is my_adder.ada. This package contains a procedure for adding two numbers.

___________________________________________________________
package my_adder is
 procedure add_em_up(a,b : in integer; c : out integer);
end;

package body my_adder is

 procedure add_em_up(a,b : in integer; c : out integer) is

 begin
 c:=a+b;
 end add_em_up;

end my_adder;
___________________________________________________________
Listing 4 Package For Second Example

The mechanics of operating the Ada compiler with this main program and package are quite simple. The compilation steps are identical to those of the previous section except that in Step 3 the two source files callit.ada and my_adder.ada are entered into the Ada Sources scroll field (see Fig. 3). In Step 6 the name entered in the Main Procedure edit field must be callit (see Fig. 6). When compilation is complete, the user types callit into the Worksheet in order to run the program.

For Ada Mavens

The Ada cognoscenti will find that implementation-dependent characteristics of the Meridian compiler are quite reasonable. All pre-defined pragmas (Ada compiler directives) are implemented with the exception of controlled, optimize, system_name, shared, storage_unit, and memory_size. These pragmas are accepted but ignored. The pragma interface (which is used to allow calls to routines written in other languages) supports C and Assembly; the programmer is responsible for insuring the correct calling conventions. Restrictions on representation clauses are few, and result mainly from the architecture of the Motorola 68000 family. Address clauses are supported for objects, but not for packages, subprograms, or task units. An address clause may be used with a task entry to support interrupts, but presently this is only recognized for the command-period keyboard interrupt.

Machine code insertions are supported, but only minimally. To insert machine code it is necessary to have the code already assembled into hexadecimal values. For instance, if you wish to insert the machine code corresponding to

 MOVEM.L D2-D7/A2-A4,-(A7)

you would have to insert the following lines into your procedure using machine code:

 instruction’(val => 16#48E7#);
 instruction’(val => 16#3F38#);

While this makes machine code insertions possible, it is probably easier to just use pragma interface with assembly code.

The standard packages calendar, direct_io, io_exceptions, sequential_io, standard, and text_io are all supported, as well as the generics unchecked_conversion and unchecked_deallocation. Further, Meridian has made the use of text_io easier for the Ada novice by providing the package ada_io to simplify input and output.

A few handy utility library packages come with the Ada compiler. The package arg lets you get at MPW command line arguments; bit_ops provides in-line bit operations; math_lib implements a few of the more common transcendental functions; spio flushes output text files; spy implements the byte peek and poke operations; and finally, text_handler is a text handling facility like the one described in section 7.6 of the Ada LRM (Language Reference Manual).

Meridian provides a source-level debugger with the compiler that supports all the normal debugger commands that you would expect: breakpoints, single-stepping, tracing, variable monitoring, etc. To be used, the debugger must be linked with the program to be debugged. This is somewhat intrusive, and will definitely increase the size and slow down the execution speed of any program with which it is used. Note also that any program which used the debugger would have to be recompiled and relinked after debugging to remove the debugger code. On the up side, however, a lot of power has been built into the debugger, and if the recompilation and relinking isn’t a problem, then the Meridian debugger should be a real help with finding and correcting problems.

A library has also been provided to support the interface to the Macintosh toolbox. If you are a frequent user of the the toolbox, you will probably want to install this library and make it a normal component of any Ada library you make. You should be careful about how you do this, as the instructions in the manual are not entirely clear. The use of the Macintosh environment library is mostly straightforward, but there are a few differences from the normal Pascal toolbox calls (as presented in Inside Macintosh), which are clearly explained in the manual.

Summary

Although we don’t recommend that Macintosh programmers switch to Ada in order to create their next commercial application, we do recommend that this implementation of Ada be considered for those who either like Ada or are required to use it and enjoy the Macintosh platform. Check with

Meridian Software Systems, Inc.

10 Pasteur Street

Irvine, CA 92718

Phone: 800/221-2522

for current pricing.