High-level Language Compilers Research Articles

Hierarchical microprogram generating system

A general purpose microprogram generating system has been developed to compose, together with a hardware/microprogram debugger, a general purpose development support system for LSI Processor Modules such as Am2900, MMI6700, and/or MACROLOGIC. The microprogram generator, designed to be applicable to a wide variety of microinstruction sets from vertical to horizontal including sophisticated control schemes like pipelining, has a three-level hierarchical structure. The lowest level generator is a microassembler, which has already been applied to many computers and shown its easiness of defining instructon sets and high-speed generation of object microcodes. The second level generator is an optimizing assembler, which translates a sequence of microoperations to an optimum sequence of microinstructions considering data dependency and concurrent executability of microoperations on a defined object machine. The highest level generator is the high-level microprogramming language compiler which generates an optimum sequence of microoperations utilizing techniques of optimization for high-level language compilers. Example definitions of a microinstruction set and an object machine, source programs, and object listings show the effectiveness of the hierarchical microprogram generating system.

Hardware Description Language Applications: An Introdiction and Prognosis

Just as Software designers use high-level languages like Algol, Fortran, PL/I, and Snobol to express algorithms in terms of language statements, so digital hardware designers use hardware description languages to describe the digital systems they want to design. But whereas compilers for many high-level programming languages have been developed and implemented, the process of transforming a high-level computer hardware description language specification of a system into a logic diagram is still in its infancy.

Experience with the programming language MODULA

The new programming language MODULA has been designed by Wirth for the programming of dedicated small computers used in the real-time environment. The language is based on PASCAL; as well as a straightforward set of algorithmic features, MODULA contains features for multiprogramming and machine-specific mechanisms for referencing peripheral hardware. An extension of block structure is used to structure programs, permitting explicit control of the communication of names between distinct parts (modules) of the program. This paper describes a compiler for MODULA, written in the programming language BCPL, which runs on a PDP-11/40 computer under the RSX-11D operating system. The code produced by the compiler is run on PDP-11s under a very small executive (less than 150 words). The quality of the code produced compares well with that of compilers for other high-level languages. The use of the language is illustrated by the construction of a real-time scheduler similar to that written by Brinch Hansen in CONCURRENT PASCAL. A brief discussion is given of experience gained in the use of the language and comments made about the inclusion and exclusion of certain language features.

A General-Purpose Macro Processor as a Poor Man's Compiler-Compiler

A method for quickly producing compilers for high level languages is described. The technique consists of feeding a description of the language to be translated to a general-purpose macro processor. Used in this way, the macro processor functions as a compiler-compiler, providing automatic parsing, lexical scanning, symbol table operations, and handling of syntactic errors. A complete syntactic and semantic description of a WHILE statement (except for Boolean expression processing) is given in only seven lines, as an example. A system programming language implemented by this method is discussed in order to illustrate the main ideas. The compiler produced for this language is compared to other compilers produced by conventional methods.

System design of a grammar-programmable high-level language machine

An architectural concept called Grammar-Programming is introduced which allows computers to be constructed that can directly execute a variety of high-level languages. Representing an intermediate level between the basic hardware/firmware functions of ordinary computers and the software operations of language translators, it is shown how grammar-programs can be constructed which specify the syntax and semantics of various programming languages. The Grammar-Programmable Machine (GPM) then uses these specifications to process directly the users' high-level language programs. In the Ph.D. dissertation* upon which this abstract is based, a model is first developed for representing the syntactic and semantic characteristics of context-free language generators, and an automaton called a Syntax Network (SN) is constructed. Next a simple, statement-directed language is introduced to express the states of the syntax network and to define the actual grammar-programming language. A simulator is then implemented which is used to test the grammar-programs written for ALGOL and SNOBOL. Finally, the architectural organization for the Grammar-Programmable Machine is described at the register-transfer level. By taking advantage of its intermediate position between software compilation and hardware interpretation of high-level languages, the Grammar-Programmable Machine is able to emphasize the best features of both techniques and to achieve a potential that neither can reach individually.

Simulation language implementation on minicomputers

Recent developments have shown the feasibility of implementing sophisticated simulation language facilities on even a modest minicomputer configuration. Unlike conventional simulation languages which, in the main, operate in a non-interactive batch mode, minicomputers generally allow the user to simulate in a highly interactive manner. This paper discusses three strategies used by the authors to implement different versions of an interactive simulation language on a minicomputer, and describes the means of achieving highly interactive simulation features. There are two fundamentally different approaches to implementing a simulation language. The first, a translator approach, makes use of existing software, for example editors, high-level language compilers, job control language features, and the language is built using these software foundation blocks. The second approach is to construct the facility independently of existing software and to provide a package which is quite independent of the computer's operating system. This second approach can be further subdivided into two branches, the compiler approach, in which the object code produced by a simulation language compilation is the machine code of the particular computer, and secondly the interpreter approach, where the object code is machine independent and is subsequently interpreted by code expressed in a high-level language. The various implementation strategies are described and the advantages and disadvantages of each approach are discussed in relation to three implementations of a simulation language for PDP8 computers.

Direct microprogrammed execution of the intermediate text from a high-level language compiler

Microprogramming commonly executed operations can improve the computational speed of data processing systems. This paper describes how microprogramming may be used to execute directly the intermediate text generated by a high-level language compiler after syntactic and semantic analysis of the input source program. Direct microprogrammed execution of common forms of intermediate text—i.e. quadruples, triples, and duos—has been simulated. A comparison is made, in terms of storage requirements and execution time, of this direct microprogrammed system with the present methods which result in machine language representation and execution of the intermediate text. Direct generation of a microprogram from the high-level language statements is also examined. Timing assumptions for comparative purposes have been based on the IBM 360 MOD 50 system. Simulation and timing estimates for the microprograms have been carried out on a microprogram directed simulator which closely represents the architectural organization of the MOD 50.

High-level language translation in SYMBOL 2R

The SYMBOL 2R Computing System represents an attempt to bridge the gap between machine languages and higher level programming languages. This gap has always limited the users' ability to communicate with the machine, thus creating a communication problem. Early attempts at solving this communication problem consisted of developing a series of user-oriented programming languages, i.e., assembler languages and higher level languages, supplemented with a host of translator programs that would transform the higher level languages into machine language. For several years it seemed that this approach represented the only economically feasible solution. In 1965, W. H. Burkhardt (2) suggested the development of high-level language computers Burkhardt did suggest that the availability of low cost components would make high-level language computers an economically feasible solution. In fact, the recent decline in the cost of components as compared with the steady, if not increasing cost of the software needed to develop and maintain compilers for high-level languages, has made the high-level language computer solution seem even more attractive.

Direct microprogrammed execution of the intermediate text from a high-level language compiler

Microprogramming commonly executed operations can improve the computational speed of data processing systems. This paper describes how microprogramming may be used to execute directly the intermediate text generated by a high-level language compiler after syntactic and semantic analysis of the input source program. Direct microprogrammed execution of common forms of intermediate text - i.e.: quadruples, triples, and duos - has been simulated. A comparison is made, in terms of storage requirements and execution time, of this direct microprogrammed system scheme with the present methods which result in machine language representation and execution of the intermediate text. Direct generation of a microprogram from the high-level language statements is also examined. Timing assumptions for comparative purposes have been based on the IBM 360 MOD 50 system. Simulation and timing estimates for the microprograms have been carried out on a microprogram directed simulator which closely represents the architectural organization of the MOD 50.