Browsing by Author "Kennedy, Kenneth W."
Now showing 1 - 3 of 3
Results Per Page
Sort Options
Item Implementation of set theoretic languages on computers with tagged architecture(1975) Hajare, Ankur Ramesh; Kennedy, Kenneth W.This thesis deals with the relation between computer languages and computer architecture. In particular, it deals with SETL, a very high level set oriented language, and its implementation on a machine suitable for executing it. Architectural features which aid in implementing SETL are discussed. A machine which directly executes a pre-processed version of SETL source code is described and microprograms for the execution of a few typical SETL operators are presented. This machine is a stack machine with tags which enable the hardware to distinguish between the data types of SETL. The preprocessing required for this machine consists of rearranging the tokens of the source program into Polish form. Three different representations of sets on this machine are compared. Simplified versions of the SETL machine which are comparable to some microprogrammed systems in existence today are also described. The problem of implementing SETL on the R-2 is discussed and a method for effectively utilizing the hierarchical memory segmentation provided by the R-2 addressing system is presented.Item Incremental compilation and code generation(1980) Bruce, Robert Ewing; Kennedy, Kenneth W.; Jump, J. Robert; Sinclair, James B.Time sharing compilers are typically batch compilers that have been modified, via inclusion of a symbolic debugger, to "emulate" an interactive environment. The trend is away from interaction with the language processor and toward interaction with a common symbolic debugger. There are several problems with this approach: 1) It causes great time delays when a problem is isolated and a source change is necessary to correct a "bug". The use of an editor, compiler, and linkage editor is required to get back to the symbolic debugger. 2) Using a symbolic debugger requires knowledge of yet another language (the debugger's language). 3) Typically a symbolic debugger is written to work with more than one language and therefore has to house (sometimes incompatible) constructs for all of the languages it supports. The incremental compiler on the other hand has a rapid response to source changes. There is no need for a complete recompilation and linkage edit in order to re-execute the program after a change is made. The time required to make a change is proportional to the size of the change and not to the size of the program. The BASIC language processing system discussed in this work can operate as an incremental language processor as well as a Link-Ready (LR) code generating compiler. The term 'link-ready' denotes a type of relocatable object code that is suitable for linking with the BASIC library as well as with other user-written routines that have been separately compiled by BASIC or any other language processor. The compiler system operates in two modes, a link-ready code generating mode commonly called a batch compiler and an incremental or interactive mode that allows the user to enter source code lines in any order receiving error messages (if the source line is in error) as each line is entered. A BASIC program is first developed using the incremental compiler. Once the program is "debugged", it is compiled using the batch compiler to produce a more efficient executable module.Item The efficient evaluation of attribute grammars(1975) Warren, Scott Kipling; Kennedy, Kenneth W.Knuth's attribute grammars are a powerful, natural way of specifying translations such as those involved in compiling programming languages, but until now efficient implementation has been possible only for restricted classes of attribute grammars. We present a method of constructing, for any attribute grammar, a recursive procedure which performs the specified semantic evaluation. These "treewalk evaluators" are produced by analysing the data dependencies of the attribute grammar to find an acceptable evaluation strategy. The resulting evaluators are efficient in the sense that they make no use of nondeterminism or searching through the parse tree and may be generated as directly executing machine code rather than requiring an interpreter. Our construction is therefore suitable for use in a practical compiler-writing system.