Mark Sherman

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.

A flexible semantic analyzer for Ada

A technique for writing semantic analysis phases of compilers is described. The technique uses Simula classes and virtual procedures to create a flexible and modular program. This technique is used to implement a semantic analysis phase of a compiler front end for the preliminary Ada language. Because the design is extremely flexible and modular, the front end is able to accommodate changes in the Ada language and its semantics as they are published. Several problems were encountered when implementing Adas semantics. These problems are described and their solutions presented. The front end also produces TCOLAda, the specified intermediate language for various Ada compiler contracts. This output has been used by an experimental compiler back end. [9] The front end is written as two programs which perform lexical analysis, syntactic analysis, semantic analysis, and TCOLAda generation. The front end is coded in Simula, and has been running on DEC Tops-10 and Tops-20 systems since September 1979.

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.

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.

Teaching software engineering in a workstation environment

A description is given of an undergraduate software-engineering course at Dartmouth College that uses an interactive, graphical, networked workstation environment (implemented on Apple Macintoshes). The students projects use all the features of this environment, including graphics, windows, fonts, mice, networks, and sound generators. The course covers the technical aspects of building a large system. Class topics include refining the system architecture, evaluating data structures, measuring system performance, selecting a user interface, specifying modules, and comparing programming methodologies. The environment can be implemented on almost any computer, from micros to mainframes.<<ETX>>

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.

Translating among processable multi-media document formats using ODA

Introduction listing of the document format features that we supThis paper describes our experiences in translating ported in our translations, _, processable multi-media documents among diverse systems. We performed these translations using the interThe EXPRES Project ! national standard Office Document Architecture (ODA) In June 1986, the National Science Foundation (NSF) solicited proposals for the Experimental Research in : as an intermediate representation. The next two sections provide brief descriptions of the NSF-funded Electronic Submission (EXPRES) project. EXPRES EXPRES project (under which this work was was designed to promote the electronic interchange of performed) and our goals for this phase of the project, multi-media documents among the scientific research Following that is a brief description of the multicommunity. The NSF proposal submittal process was media document systems at Carnegie Mellon University chosen as a controlled sub-environment in which to (CMU) and the University of Michigan (UM), the two pursue the goals of the project, because this process institutions at which this work was performed. This is embodies many of the issues that must be addressed by _EXPRES. In particular, proposals are documents that -_ followed by a brief introduction to ODA and the ODA Tool Kit, a subroutine library that was used in the conusually contain information expressed in several media, struction of the translators, such as text, line drawings and raster images. These sections are followed by a discussion of In September of 1986, the NSF made equal three. general issues relating to the fidelity of document transyear awards to the Information Technology Center at lations. We then describe our approach to document CMU, and to the Center for Information Technology format translation using ODA, the problems we enIntegration at UM. In addition, several vendors have countered and our solutions. We provide some details donated equipment and provided technical support to about the implementation of the translators, our current the EXPRES project: IBM, DEC, Apollo Computer, status and our conclusions on the effort. The last secSun Microsystems and Apple. There are many issues that must be addressed to tion discusses some directions for further work on document interchange and an appendix contains a improve the ability of researchers to interchange multimedia electronic documents. To make the task Permission to copy without fee all or part of this material is granted manageable, we are concentrating on the problem of provided that the copies are not made or distributed for direct commercial advantage, the ACM copyright notice and the title of effective interchange of processable multi-media docuthe publication and its dateappear, and notice is given that copying ments among diverse systems. In particular, we are is by permission of the Association for Computing Machinery. To copy otherwise, or to republish, requires a fee and/or specific ignoring the method by which a document is transferred

Introduction to the Office Document Architecture

The Office Document Architecture (ODA) [30] is designed to aid the representation and interchange of office documents such as memoranda, letters and reports. It provides comprehensive facilities for describing the structure and content of complex multi-media documents.

Paragon: Novel uses of type hierarchies for data abstraction

* Multiple implementations of an abstract data type may be de qlared in a program. S e v e r a l imp lemen ta t i ons o f an a b s t r a c t d a t a t ype may be used s i m u l t a n e o u s l y in a program (one i m p l e m e n t a t i o n pe r v a r i a b l e ) . If several implementations of an abstract data type are used for different variables, t h o s e variables may i n t e r a c t . * A si__ng!e__im~.nt.a_ti.on may be written for several separaLe S/~_£i_ficati.ons, Automatic-Processing Goals * Static .t_ypa ..c.hecking of all variable declarations (object creations ) and procedure calls should be supported. * C_o..mp~le-time checkinq should ensure that al.l r_epXgsentation-selection decisions result in a program that can execute without run-time errors. Although many languages a r e d e s i g n e d to meet some of t h e s e g o a l s , no language known t o me can meet a l l o f theN. A f t e r a r ev i ew o f how o t h e r languages only paritally meet these goals, a description of Paragon i s g i v e n a l o n g wi th examples o f how a programmer can use Paragon t o a c h i e v e t h e s e g o a l s . The abstract data type specification goals are partially met by the object-oriented language d e s i g n s i n Simula [Dah168 ] and S m a l l t a l k [GoldbergS1, I n g a l l s 7 8 , I n g a l l s 8 l , Morgan81, Xerox81] , the T r a i t s a d d i t i o n s to Mesa [Curry82] and t h e F l a v o r s f a c i l i t y f o r L i s p [WeinrebS1] . An

Experience Implementing ODA

We spent significant resources, in personnel and in time, on the CMU ODA Tool Kit, a portable subroutine library for application programs manipulating ODA documents. The tool kit effort involved specification, design, implementation, testing and distribution.