The Oberon System family

Oberon simultaneously refers to a moduar, extensible operating system and an object-oriented programming language developed for its implementation. Although the original Oberon System had been conceived as the native operating system for a custom-built workstation, furhter implementations for several commercial platforms were developed later and are described here. All of these implementations are based on an efficient, retargetable Oberon compiler, and each provides a complete Oberon environment and the original library interface. This paper describes the structure of the compiler, summarizes the experience gained in adapting it for various CISC and RISC processors, and presents some empirical performance data. It also sheds light on the task of grafting an operating environment onto a variety of existing operating systems.     

Ada95编译系统中多平台技术的研究

支持多语种、多平台是当前编译技术的发展趋势,它适应了当前计算机系统迅猛更新的需要。文中提出了一个适用于不同计算机平台的多平台Ada95编译系统的模型,在此基础上讨论了Ada95编译系统中多平台支持的三个关键技术:平台配置机制、运行库多平台支持技术和多平台代码生成支持策略,并描述了相应的设计与实现方法。     

Ada95语言评述

Ａｄａ９５语言是在Ａｄａ８３基础上修订而成的，它几乎提供了现代程序设计范型及程序设计实践所需要的一切设施，它可以支持面向对象的程序设计、大型程序设计、实时与并行程序设计等等。     

Modular verification of Ada generics

This paper develops modular verification rules for Ada generics which are proven to be sound and complete. The generic mechanism in Ada allows modules to be parameterized by types, procedures and functions. The modularity property allows a generic to be verified once, and then exported to other modules which assume that it is correct. This requires the generic to have a specification which is used in verifying other modules, but its implementation cannot be used for this purpose. Thus, modular verification cannot be based on removing generics by macro expansion which requires the use of the generic's implementation. The main difficulty with specifying and verifying a generic is that the specification language may need to be extended with a new theory for specifying and reasoning about properties of objects whose type is a parameter to the generic. Such theories must be part of the specification of the generic, and this raises the possibility that the extended specification language may not be expressive, even if it was before the extension. The use of strings in our specification language prevents this from happening, which is proven in the paper; this is a major step toward establishing the completeness of our rules. Modularity also had a large impact on our semantics for programming constructs which is quite different from the usual semantics in the literature, even though it is still based the denotational semantics of Scott and Strachey. The main reason for this is that we had to modify the standard definition of validity. Modularity requires that validity depend on certain internal assertions in a program, such as the precondition of a procedure invoked in the program.     

ADA软件设计图元的优化

本文阐述了作为ＡＤＡ软件开发工具的图形化结构编辑器中使用的园元的优化策略及实现，分析了各种设计策略的优缺点，用实例来说明本设计方案的应用。     

Optimizing Code Generation from SSA Form: A Comparison Between Two Formal Correctness Proofs in Isabelle/HOL

Correctness of compilers is a vital precondition for the correctness of the software translated by them. In this paper, we present two approaches for the formalization of static single assignment (SSA) form together with two corresponding formal proofs in the Isabelle/HOL system, each showing the correctness of code generation. Our comparison between the two proofs shows that it is very important to find adequate formalizations in formal proofs since they can simplify the verification task considerably. Our formal correctness proofs do not only verify the correctness of a certain class of code generation algorithms but also give us sufficient, easily checkable correctness criteria characterizing correct compilation results obtained from implementations (compilers) of these algorithms. These correctness criteria can be used in a compiler result checker.     

Deriving correctness properties of compiled code

When developing safety-critical software, it is the correctness of the object code that is paramount. However, it is desirable to perform formal verification on the source program. To ensure that correctness results proved about the source program do apply to the object code, the compiler used can be formally verified. However, care must be taken to ensure that the compiler correctness theorem proved is suitable. We have combined a derived programming logic with a verified compiler for a generic subset of the Vista structured assembly language. We show how correctness properties of object code can be formally derived from corresponding correctness properties of the source program which have been proved using the programming logic. Thus we can be sure the results do apply to the object code. The work described has been performed using the HOL system and so is machine-checked.     

Ada任务的结构测试

Ａｄａ语言中，任务的运行方式与顺序执行的程序的运行方式完全不同。本文重点介绍对Ａｄａ软件进行结构测试时，任务单元的一些特殊问题及其解决方法。在建立分支表示插装时，需分析任务语句的不同特点及其语法现象，按不同的情况作相应处理，从而使测试结果能真实地反映被测程序的结构特性。     

一个Ada子集的编译设计与实现

Ａｄａ语言是美国国防部（ＤｏＤ）在国际范围内组织设计的软件工程语言。它具有实时性、模块性、并行性，在数据抽象，模块结构、并行控制和异常处理等方面提出一整套新概念、新方法，是现代计算机语言的成功代表。该文主要描述由ＰＣｘ８６／ＵＩＮＸ平台上的Ａｄｚ－ｚ编译系统的信息流导致的软件结构、结构内部的接口定义及每个软件元素的功能。     

Static and Dynamic Program Compilation by Interpreter Specialization

Interpretation and run-time compilation techniques are increasingly important because they can support heterogeneous architectures, evolving programming languages, and dynamically-loaded code. Interpretation is simple to implement, but yields poor performance. Run-time compilation yields better performance, but is costly to implement. One way to preserve simplicity but obtain good performance is to apply program specialization to an interpreter in order to generate an efficient implementation of the program automatically. Such specialization can be carried out at both compile time and run time.Recent advances in program-specialization technology have significantly improved the performance of specialized interpreters. This paper presents and assesses experiments applying program specialization to both bytecode and structured-language interpreters. The results show that for some general-purpose bytecode languages, specialization of an interpreter can yield speedups of up to a factor of four, while specializing certain structured-language interpreters can yield performance comparable to that of an implementation in a general-purpose language, compiled using an optimizing compiler.     

Static analysis of exception handling in Ada

Since the signature of an Ada subprogram does not specify the set of exceptions that the subprogram can propagate, computing the set of exceptions that a subprogram may encounter is not a trivial task. This is a source of error in large Ada systems: for example, a subprogram may not be prepared to handle an exception propagated from another subprogram several layers lower in the call-tree. In a large system, the number of paths in exceptional processing is so great that it is unlikely that testing will uncover all errors in inter-procedural exception handling. Nor are compilers or code inspections likely to locate all such errors. Exception handling is an area where static analysis has a high potential payoff for systems with high reliability requirements. We discuss fundamental notions in computing exception propagation and describe an analysis tool that has proved to be effective in detecting inconsistencies in the exception-handling code of Ada applications.     

A portable virtual machine for Ada

A portable compiler can be constructed by letting it generate code for a virtual machine, which is then implemented on the real target machines. The design of a virtual machine which is especially suitable as a target machine for compiled Ada programs is described. The main design goals, implementability on mini-computers and portability, are discussed and the resulting design is described in some detail. Some implementation strategies for the machine are proposed and the feasibility of the virtual machine approach is discussed.     

The programming language standards scene, ten years on Paper 9: Ada

This paper, one of a simultaneously published set on ten years of activity in programming language standards, describes the developments in standardization of the programming language Ada which have taken place in the period 1983–1993.     

Using Ada for discrete event simulation

The process interaction approach is proposed for developing a discrete simulation environment in Ada. The introduction of simulation facilities in Ada not only concerns the classical aspect of model building, but allows a new class of problems to be tackled, that is the testing of correctness of programs intended for real-time applications. In this paper attention is focused on the presentation of the process scheduling in the simulation context and on the definition of standard forms of interactions among processes. Simulation facilities are organized by making use of Ada's structuring concepts.     

IAda: A language for robot programming based on Ada

We present a programming language for robots which we have implemented based on the Ada language. It is an interpreted language which permits dynamic configuration of software. It manipulates Ada tasks and subroutines. One of the Ada tasks is an inference engine of a logic programming language adapted to real-time constraints. We show how the conjunction of Ada tasks, to perform perception and action functions on the robot, to logic programs, for the control of these tasks, both manipulated by the IAda language, gives a powerful environment for robot programming.     

Experience acquiring and retargeting a portable Ada compiler

A technique for implementing Ada with reasonable effort on a piece of non-standard hardware is described. The target machine is a single processing element in an experimental multiprocessor based on NS32000. A portable Ada front-end compiler was used for retargeting, and the process of acquiring and evaluating the front end is described. Based on this experience, comments on the validation, quality and efficiency of Ada compilers are given, along with a detailed overview of the resultant system. The Ada system was built from scratch on the bare hardware. It has three main components: a code generator, a run-time system and an Ada kernel. The code generator is table driven and generates symbolic NS32000 assembler. This code is then assembled and linked by commercially available components. The run-time system and the kernel are implemented in assembly language and Concurrent Euclid and handle tasking, exceptions and scheduling. The result is a complete Ada implementation.     

Ada und Modula-2 — ein Vergleich

Zusammenfassung Die folgende Arbeit wendet sich an Entwickler großer Software-Systeme. Das Ziel ist eine systematische Darstellung der wesentlichen Eigenschaften von Ada und Modula-2, ihrer Unterschiede und Gemeinsamkeiten. Die beiden Sprachen werden anhand eines für die Zielgruppe typischen Kriterienkatalogs einander gegenübergestellt. Dem Leser soll ein Eindruck über die Brauchbarkeit der beiden Sprachen bei der Implementierung großer Software-Systeme vermittelt werden.