Andy Hisgen

Studies in Ada style

to the Second Edition.- to the First Edition.- I The Impact of Abstraction Concerns on Modern Programming Languages.- 1. The Impact of Abstraction Concerns on Modern Programming Languages.- 1.1 Issues of Modern Software.- 1.2 Historical Review of Abstraction Techniques.- 1.2.1 Early Abstraction Techniques.- 1.2.2 Extensible Languages.- 1.2.3 Structured Programming.- 1.2.4 Program Verification.- 1.2.5 Abstract Data Types.- 1.2.6 Interactions Between Abstraction and Specification Techniques.- 1.3 Abstraction Facilities in Modern Programming Languages.- 1.3.1 The New Ideas.- 1.3.2 Language Support for Abstract Data Types.- 1.3.3 Generic Definitions.- 1.4 Practical Realizations.- 1.4.1 A Small Example Program.- 1.4.2 Pascal.- 1.4.3 Ada.- 1.5 Status and Potential.- 1.5.1 How New Ideas Affect Programming.- 1.5.2 Limitations of Current Abstraction Techniques.- 1.5.3 Further Reading.- II Programming In Ada: Examples.- 1. Introduction to Example Programs.- 2. An Implementation of Queues.- 2.1 Description.- 2.2 Implementation.- 2.3 Program Text.- 2.4 Discussion.- 2.4.1 Use of Limited Private Types.- 2.4.2 Initialization and Finalization.- 2.4.3 Passing Discriminants to Tasks.- 2.4.4 Remove as a Procedure.- 3. A Simple Graph Package Providing an Iterator.- 3.1 Description.- 3.2 Specifications.- 3.3 Program Text.- 3.4 Discussion.- 3.4.1 The Algorithm.- 3.4.2 Information Hiding.- 3.4.3 In/In Out Parameters.- 3.4.4 Using the Iterator.- 3.4.5 Iterators Versus Generic Procedures.- 3.4.6 Separate Compilation.- 4. A Console Driver for a PDP-11.- 4.1 Description.- 4.2 Implementation.- 4.3 Program Text.- 4.4 Discussion.- 4.4.1 Use of a Package to Surround the Task.- 4.4.2 Distinction Between Task Types and Tasks.- 4.4.3 Resetting and Terminating the Terminal Driver.- 4.4.4 Interfacing to Devices.- 5. Table Creation and Table Searching.- 5.1 Description.- 5.2 Implementation.- 5.3 Program Text.- 5.4 Discussion.- 5.4.1 Use of The Package.- 5.4.2 Use of the Search Function.- 5.4.3 Use of Packages.- 5.4.4 The Type of the Entries in the Table.- 5.4.5 Use of a Private Type for the Pointers to the Table.- 5.4.6 Nesting a Generic Package Within a Generic Package.- 5.4.7 String Comparisons.- 5.4.8 Use of Integers in Find.- 6. Solution of Laplaces Equation with Several Ada Tasks.- 6.1 Description.- 6.2 Implementation.- 6.3 Program Text.- 6.3.1 A Protected Counter Task Type.- 6.3.2 Parallel.Relaxation Procedure.- 6.4 Discussion.- 6.4.1 Use of Shared Variables.- 6.4.2 Updates of Shared Variables From Registers.- 6.4.3 Generics and Generic Instantiation.- 6.4.4 Scheduling of Ada Tasks Onto Processors.- References.

The Charrette Ada compiler

The Charrette Ada compiler is a working compiler for a substantial subset of the preliminary Ada language. The Ada source program is translated into an equivalent program in an intermediate implementation language. The result of the compilation process is machine language generated for this intermediate program.This paper provides a brief overview of the compiler with special attention given to the primary translation phase. Emphasis is placed on the transformation of Ada type and subtype information and the representation of objects. The translation of several interesting statement and expression forms is also outlined.

A language implementation design for a multiprocessor computer system

Theoretical and experimental results have indicated that automatic decompositions can discover modest amounts of parallelism. These investigations have tended to ignore the practical problems of language run-time organization, such as synchronization, communication, memory organization, resource management, and input/output. This paper describes a language implementation effort which combines the investigation of implicit and explicit parallel decomposition facilities with the practical considerations of system organization on a multiprocessor computer, Cm*.

An Ada code generator for VAX 11/780 with Unix

This paper describes the final phase of an Ada compiler which produces code for the VAX 11/780 running the Unix operating system. Problems encountered in the implementation of subprogram calls, parameter passing, function return values, and exception handling are discussed and their solutions outlined. An underlying requirement for the code generator has been speed of implementation consistent with being a test bed for an Ada implementation. To accomplish this, a common model for the target environment has been assumed. The assumptions include: the VAXis a stack machine, a single address space is used, only the general case is implemented (no optimization of special cases), the hardware does as much work as possible, run time routines for lengthy code sequences are acceptable, and the conventions given in the VAX architecture, hardware, and software manuals are used. The code generator has been running on a PDP-10 with Tops-10, producing a VAX assembly language source program as output. It has been available to local users since the beginning of 1980.

A runtime representation for Ada variables and types

The type and subtype facilities of the Ada programming language permit some subtype information to be determined dynamically. This subtype information requires a runtime representation, and its dynamic nature influences the representation of variables. In this paper, we first review Adas types and subtypes to identify some of those aspects which affect runtime representation. We then present the particular representation scheme which is used in the CHARRETTE Ada implementation. The scheme is straightforward and consistent in that a variable is represented the same way independently of where it appears, whether it is on the stack, on the heap, or a component of another variable. The design treats Adas discriminants and discriminant constraints as a form of parameterized types, where the parameterization permits different instances of a type to have different variants and different sizes for array fields. Composition of such parameterized types is supported. We explain how several Ada operations are handled by our particular representation. We briefly discuss some alternative approaches to Ada representation, comparing them to our design.

Introduction to the first Edition

The major problems of modern software involve finding effective techniques and tools for organizing and maintaining large, complex programs. The key concept in modern programming for controlling complexity is abstraction, that is, selective emphasis on detail. This monograph discusses how the Ada programming language provides ways to support and exploit such abstraction techniques.

Introduction to the Second Edition

Since the initial publication of Studies, some parts of the Ada1 language have been changed in response to the ANSI standardization process. The second edition of Studies has been updated to conform to the latest available Ada manual [Department of Defense 82].2 All of our references to the Ada manual come from this document (see page 36).

Solution of Laplace’s Equation with Several Ada Tasks

In this section we present the solution of a numerical problem using several Ada tasks. The solution is designed for a multiprocessor computer system such as C.mmp [Wulf 72] or Cm* [Swan 77] in which the processors have access to a shared memory.

Table Creation and Table Searching

In this section we present an example that uses generic packages to provide routines to search a table and to retrieve the items stored there. The table, and auxiliary data objects created to help the search, are encapsulated within a package created by instantiating a generic package. They are not accessible except by the routines exported from that package. A program may have several tables that it can search; a package must be instantiated for each table, and the routines which are exported act specifically upon the table within the corresponding package.

A Simple Graph Package Providing an Iterator

Graphs, of one form or another, are an important data structure throughout most of computer science. This example displays an implementation of a simple package providing an abstraction of directed graphs. The specification includes some type definitions, culminating in the Ob j record type, that serves to define the structure of directed graphs. The user is responsible for allocation, initialization and manipulation of the nodes that form a graph.