EASY(ID:4047/eas011)

Intermediate language

Country: us
- languages for us
- us/1972
Began: 1972
Type:Intermediate languages and VMs
- Intermediate languages and VMs
Sammet:EXP
- EXP
- EXP/1972
- EXP/us

Intermediate language for the Nanodata QM-1, target for SIMPL-T

SIMPL-Q

Target language for

References:

Perry, John G., Flink, Charles W., "A Microprogrammed High Level Language Debug System," Proceedings of the Fifteenth Annual Technical Symposium, National Bureau of Standards, (June 17, 1976) pp. 177-180. view details

Perry, John G., Hein, Robert R., "Virtual Machines for a Tactical Environment" view details
in [IEEE] Conference Digest COMPCON Fall 1976 view details

Flink, Charles W., "EASY—an operating system for the QM-1" in Proceedings of the tenth annual workshop on Microprogramming 1977 , Niagara Falls, New York, United States pp: 7 - 14 view details Abstract: The Emulation Aid SYstem is a virtual machine monitor for the Nanodata QM-1 microprogrammable computer. The system is designed to provide the user with an interactive interface for the development and subsequent use of emulations on the QM-1. EASY provides integrated support for: 1) interactive control of multiple, concurrently resident, virtual computers implemented via emulation, 2) input/output from emulations (virtual I/O) to the various real peripherals of the QM-1, and 3) diagnostic displays for debugging of both the emulations and the software running on the emulated computers. EASY is implemented at three distinct levels: the majority of the system software is programmed in a high-level language (SIMPL-Q); this (service) software, in turn, executes on an emulated intermediate language machine (also called EASY); the EASY machine executes as the highest priority task under a microprogrammed operating system kernel (called TASK). Via EASY the user currently has access to several previously developed emulations. EASY is the host system for ongoing emulator development at the Navy's Dahlgren Laboratory. Extract: The System Programming Language SIMPL-Q
The System Programming Language SIMPL-Q
One of the first tasks in the design of EASY was the selection of a suitable hlgh-level programming language. The plan was to take a suitable language and extend it by means of the addition of a few new intrinsic functions and procedures. These "system programming" extensions were to include synchronization operators (TRIGGER, WAIT), emulation control (STASK for start task, KTASK for kill task), a clean, table driven I/O interface (SIO), and control over interrupt handling (ARM, DISARM a procedure as an interrupt handler for a given interrupt level)s These extensions were essential to the tasks intended for the systems language, therefore a language had to be selected that would readily accept these extensions. The other key requirements for the language were a) "structured" control for readability and reliability, b) good bit manipulation support (for flexibility in interfacing to varied target emulations), and c) good character string support (for display and command interpreting).
The SIMPL-T programming language was suggested as a workable base language for several reasons, First, SIMPL-T is the base language in which the SIMPL family of compilers is implemented. Therefore, an extended language based on SIMPL-T would be self-hosting, Secondly, the -T in SIMPL-T stands for transportable. SIMPL-T is the member of the SIMPL family whose compiler is specifically designed to support easy bootstrapping and extension. Third, SIMPL-T supports part word operations addressable to the bit as well as a full complement of character string operations. Finally, SIMPL-T had just been bootstrapped to the CDC 6600-6700 computer system located at the author's facility.
SIF~L-T supports a basic set of structured
programming control structures consisting of
1) IF...THEN...ELSE...END (ELSE clause optional),
2) WHILE...DO...END (with optional EXIT and EXIT
ll for escapes from nested WHILE loops), and
3) CASE...OF 111... 121... Zstring case designator>l.,. ELSE.~.END (ELSE
optional).
These basic control structures can be augmented by means of macros to support (for readability purposes) other popular forms such as REPEAT...UNTIL...END. All source input is free form, and further, statements are terminated by the Simple ~END ~, or by the occurance of another keyword. There are no semicolons or other special statement delimiters.
The language is procedure (PROC) and function (FUNC) oriented. Parameters are passed by reference or value and are fully type-checked~ Data types include characters, integers (36-bit 2"s complement), strings (of characters), and onedimensional arrays of each of the 3 scalar types mentioned. Logical and bit operations are performed on integers.
The language does not support BEGIN ... END block-structures. All variables declared within a PROC or FUNC are local to each invocation of that procedure and managed on a run-time stack. Variables declared outside (before) procedure declarations are global to that compile module~ The use of ENTRY and EXTERNAL declarations allow Zhe linking of global data items or procedures between independent compile modules.
A powerful feature of SIMPL-T is an efficient and effective macro capability. Two types of macros can be defined: "DEFINE" macros support the invention of new keywords and intrinsic functions with parameters (as alluded to above), "MACRO" declared macros support conventional (possibly conditional) macro substitutions. This limited but easy-to-use extensibility of the language has significantly added to the reliability and readability of system software developed for EASY. The structure of (and lowest level interface to) all common system tables is defined by macros resident on a common system macro library. All modules within the system are documented with the aid of "documentation macros" that enforce standard format and content on comments included as procedure or module headers.
The SIMPL-T language, once extended by the addition of the SYSTEM keyword and a number of lesser extensions, was renamed SIMPL-Q to distinguish this member of the SIMPL family as the System programming language for the QM-I Further discussion of SIMPL-Q can be found in [FLIN77, FLIN77A].
The syntax and semantics of SIMPL-Q provide the only firm architecture for the programmer. A SIMPL-Q programming reference manual is in preparation -3- that will form a concise and complete statement of the syntax and semantics of SI~L-T, the extensions added to support system programming, and the data structures of concern to programmers defined by the current EASY machine emulator, This one source is intended to be the only standard to which future implementations of SIMPL-Q are designed. This high-level specification defines the SIMPL-Q machine architecture. Strict adherance to these standards will allow lower level machine organization to evolve without loss of significant software compatibility.

in [IEEE] Conference Digest COMPCON Fall 1976 view details

Flink, Charles W., "EASY—The Design and Implementation of an Intermediate Language Machine," Masters Thesis VPI&SU view details
in [IEEE] Conference Digest COMPCON Fall 1976 view details