EOL(ID:284/eol001)Expression Oriented LanguageLeon Lukaszewicz, Instytut Maszyn Matematyczynch, 1960 (Polish Academy of Sciences, Warsaw) Expression Oriented Language. A low-level language for strings. Versions: EOL-1, EOL-2, EOL-3. People: Structures: Related languages
References: M. Halpern, San Jose, Calif. expressions and for files containing a great amount of information. The instruction format is simple, and more complex operations can be defined by means of procedures, which can be written in the machine language. The possibility of modifying a program before its performance is provided. Extract: Introduction EOL is a simple, low level language for manipulating symbols expressed as strings of characters. The field of EOL application is rather wide, although the language has been designed mainly as a tool for implementing automatic programming systems. The original application of EOL was the processing of arithmetic and logic expressions, hence it has been named Expression-Oriented Language. Symbolic differentiation of a function is an example of such an application. The function is given in the form of a formula, and the formula of the derivative of this function is to be found. This task is not very difficult, as the rules of function differentiation are relatively simple. It does not require many numerical computations, apart from simple integer arithmetic operations, but it does require a certain amount of manipulation on symbols constituting the initial formula. Another application of the symbol manipulation language is to determine a function defined as a definite integral with a variable integration limit. The simplest way of solution is to present the result as the difference between primitive functions. However, the rules defining the primitive functions are rather complex and they do not always lead to a result, since very often these functions cannot be expressed as finite expressions, composed of elementary functions only. Because of this, the program begins with an attempt to solve the problem by defining the primitive function by a method relying mainly on symbol manipulation. If, however, no results are obtained in this way, the problem is solved using one of the numerical integration routines. Thus, in this example, the general method of solution is chosen by the program, reducing the programmer's work to a minimum. In particular he is freed from searching for the primitive function of the integrand. Generally, the basic aim of problem-oriented languages is to free the programmer from forming procedures leading to the solution of the problem. One of the basic EOL aims is to make the implementation of problem-oriented languages easier. A well-known example of a problem-oriented language is a report generator, commonly used in data-processing problems. However, there exists a possibility of creating other problem-oriented languages in many fields of science and technology and the EOL system has been used for these purposes. An example of such a language may be the problemoriented language for solving ordinary differential equations. In this case the programmer writes the problem specification in the form of a set of equations and initial conditions, and establishes the required precision and format of the results. The task is to transform the string of symbols representing the problem specification into a string of symbols representing the appropriate program for the actual solution of this problem in e.g. ALGOL. An example of a still more specialized problemoriented language might be a language for electric network analysis aiming to reduce the programmer's work to a minimum. With this system the programmer starts with the network description by writing down all the node symbols, and the characteristics of the branches connecting these nodes. Then he determines the currents or voltages, which are of interest to him, and establishes the form of the results. The task of the system is to transform the so-written problem specification into a set of differential equations describing this network, and then to build the program which would solve it in the required output format. This task provides a range of non-trivial problems, as the system must carry out a proper network analysis. For instance, the system has to decide when the first and when the second Kirchoff's law should be applied, possibly find a system of independent network lattices, and finally select the set of equations so as to obtain the simplest form of results. In such a case, the whole method of the electric network analysis should be contained in a problem-oriented system and this method might even be unknown to the programmer. In general, the level of automation in problemoriented languages is high and the programmer is required only to provide a necessary minimum of information about the problem he is interested in. This information is often reduced to a concise but complete description of the system being investigated and to the specification of desired outputs. On this basis the system chooses appropriate procedures for solving the problem. The implementation of universal procedure-oriented languages of automatic programming, such as ALGOL and COBOL, frequently consists in translating programs written in procedure-oriented language into programs written in machine language which use symbolic notation. As all these programs are written in the form of strings of symbols, the processing presents a problem belonging to the field of symbol manipulation. As procedure-oriented languages are used very often, their translation into machine language should be efficient; for instance, the translation time should be reasonably short. These matters have also been taken into account while designing the EOL language. The development of the EOL language started two years ago at the Institute of Mathematical Machines in Warsaw. The initial EOL-1 version was then elaborated and it permitted many experiments to be carried out. On this basis an improved EOL-2 version has been developed which is the subject of the present paper. It should be mentioned that many symbol manipulation languages have been developed up till now. While developing EOL, use has been made of many ideas applied in the IPL-V (Newell, 1960) and COMIT (MIT, 1961) languages. in The Computer Journal 10(1) May 1967 view details Data in EOL consists of 32 input strings (11 to 132), 32 output strings (Q1 to Q32), 32 expression lists (E1 to E32), 32 so-called files (P1 to P32), and one logical variable (H). The input and output strings are just character strings, but an expression is a string of symbols: words, which are themselves character strings; numbers, which are digit strings; and addresses, which are character strings used to label records in a file. Symbols are prefixed by delimiting marks indicating their type. A file is a string of records separated by record marks. A record is an expression, a section mark (which separates the file into sections), a sorting mark (which causes the sorting of subsequent records in the section), or a pointer (which marks the current position in the file for any reading or writing operations). Expressions are stored as linear lists of 24-bit segments; files are stored as linear lists of records. Instructions in EOL, which are represented in 24-bit cells in the ZAM computer, permit such operations as: recognizing and accepting specifically delimited symbols from input strings; placing symbols on output strings; moving symbol strings in various ways among expressions and files; catenating and segmenting words; comparing symbol strings; searching for specified symbol strings in expressions and files; performing integer arithmetic; conditionally (on H) transferring control to named instructions in the program; declaring and using switches (for both statements and procedures); and declaring and calling parameterless procedures. EOL also has a macro-instruction scheme that permits the writing of open subroutines with parameters. With its limited data and instruction set, EOL can no doubt be implemented, as the author claims, easily and efficiently. It has been used for the lexical and syntactical processing in the initial phases of a compiler for SAKO (the Polish version of FORTRAN II), and no doubt is adequate, as the author claims, for a variety of other symbol manipulation tasks, e.g., symbolic differentiation and integration, generating report-writing programs, translating programming languages, translating electrical network descriptions into differential equations, and generating programs to solve the equations. EOL is not a very exciting language, but it is probably an effective programming tool, though I doubt that it will receive much use away from the ZAM computer. Even though this paper is by no means intended as a complete specification of EOL, it would have been well to include some mention of the relationship between input and output strings and the actual input/output processes of the machine. in ACM Computing Reviews 8(06) November-December 1967 view details The development of the EOL language started two years ago at the Institute of Mathematical Machines in Warsaw. The initial EOL-1 version was then elaborated and it permitted many experiments to be carried out. On this basis an improved but as yet unimplemented EOL-2 version has been developed which is the subject of the present paper. Extract: Data Structure Data Structure In the EOL language the syntax is defined not only for the program, but also for input and output data and for intermediary results such as expression or files. 2.1. Input and output data are represented in the form of strings of arbitrary characters. Up to 32 input strings can be distinguished by means of the variables II,12,.,.,132. Similarly, up to 32 output strings can be distinguished by means of variables Q1,Q2,...,Q32. To illustrate values of strings denoted by variables I or Q we write for example 18 : ABCD Q7 ; RESULT X=l ; The above notation is intended exclusively for illustration purposes, and it is neither a part of a program nor serves to determine the data. The input data are read by EOL instructions character by character, so that each time, the first character of the indicated string is read and simultaneously deleted from this string. The output data are written by adding new characters at the end of the indicated output string. Assembling the input characters into symbols or detecting a specified character pattern is done by a program. Due to this, input and output data may have any form, the most convenient for the given problem. 2.2. Expressions The input data are used by the program to build linear lists such as expressions or files. Up to 32 various expressions can be distinguished in a program. The expressions are denoted by the variables E1,E2, ...,E32. In order to illstrate a value of some expressions we write for example El : "XA°3°8AP11 E5:"TO'BE'OR NOT'TO'BE E3 : "Y"="A1'*"CB"+'ALFA"*"X") Expressions are lists composed of constituents, formed of one of the marks ~ or ° or A, followed by a string of characters. The marks determine the structure of the list inside the computer. They do not appear in input or output strings. The constituents are divided into words, numbers and record addresses. a) A word consists of a string of arbitrary characters, preceded by the mark ". Usually a word constitutes an independent component of the text. b) A number is a freely chosen string of digits, possibly with an algebraic sign, and preceded by the mark °. Numbers in the EOL language permit one to perform operations on integers. c) The address of the record is composed of a string of any characters preceded by the mark A. These addresses serve to a store positions of the records in files. In the EOL programs there are many instructions enabling flexible processing of expressions, for example: a) Moving a determined number of constituents from the beginning of one expression to the beginning or to the end of another expression, the original order being kept or reversed. In a special case, every variable E may play the role of the so-called stack. This property significantly facilitates the forming of recursive procedures. b) Compressing several words into one word or splitting one word into separate characters. c) Testing whether the initial or the final constituent equals a fixed word or number, or belongs to a specified class of constituents, for in stance whether it is a letter. d) Searching for a given word or for a specified string of words in an expression. In the EOL programs the majority of operations handling not very great amounts of information are performed most frequently by means of expression processing. Expressions are implemented as linked pairs of words. Storage allocation of expressions including retrieval of abandoned cells for reuse is done automatically. 2.3. Files Up to 32 various files can be distinguished by means of variables P1.P2,... ,P32. Each of the files represents a list composed of any number of records. In order to illustrate the value of a file, we write for example P3 : vavbvcvcrvd t vevf Small latin letters denote formerly described expressions. Every record in a file consists of a mark v followed by an expression or by one of the following symbols: a - symbol, denoting the beginning or the end of a section in a file. jn - sorting symbol. This symbol written in the file causes a sorting operation on a file segment between this symbol and the nearest symbol cr or the end of the file. T - a pointer which serves to indicate a distinguished place in the file. In every file there is exactly one such pointer. Reading of or writing a file always concerns the record which follows directly after the pointer. In the EOL language there are many instructions which permit one to process files, for example: a) Shifting the pointer forward until it comes across the record that satis fies a specified condition. b) Storing the address of the record, placed directly after the pointer, as the initial constituent of an indicated expression. c) Placing the pointer before the record, the address of which is the ini tial constituent of an indicated expression. The last two operations permit one to manipulate addresses of records by means of instructions designed to process expressions. This enables one to determine freely the file structure, this facility being very important in many applications. For example, the EOL language often permits one to form files having a structure which allows an effective searching of information written in this file. The files are designed to store a large amount of information, for example to form tables for translation from one artificial language to another. Files are implemented as linked blocks, each block corresponding to one record. For storing files, a secondary storage can be used. Extract: Programs Programs The programs written in the EOL language consist of instructions and declarations. Instructions cause the execution of some simple operations, such as changing of list values or interrupting a normal sequence of program execution. The structure of EOL instructions is very simple. They are similar in spirit to computer instructions, but they serve for manipulating strings. An example of a procedure, written in EOL language, is given below. ELEMENT : PROC CLEAR II, LDR /*CLEAR INITIAL BLANKS*/ EQ II, LD /* IS THE INITIAL CHARACTER ALPHANUMERIC?*/ GOPL LI /*YES, GO TO LI*/ READ II, Z3, 1 /* READ ONE CHARACTER*/ RETURN LI : READ II, Z3, RD /*READ STRING OF LETTERS AND DIGITS*/ RETURN END The task of this procedure is to read a subsequent element of an arithmetic formula written as input string II. In the formula, either an arithmetic operator or an arbitrary string composed of letters and digits is considered as the formula element. This element is added as a separate constituent at the end of the expression E3. Blanks preceding an arbitrary element of the formula are removed. The first line contains the heading of the procedure, last line indicates its end. Inside the procedure on the left side the instructions are written and on the right side - comments. Every instruction consists of a key word like CLEAR, EQ, or READ which is followed by not more than three arguments. These arguments often consists of a letter with an index, i.g., II, Z3. The letter specifies more exactly the way of the execution of the instruction. The index determines the string, expression or file to be operated on. Every EOL instruction is represented in the Polish ZAM computer as a 24-bit word. These words are read one after another by the program called Interpreter, which depending on computer word content causes execution of one of the EOL instructions. The structure of procedures in the EOL language is similar to that of the PL/I language, which permits a block nesting and an independent definition and compilation of external procedures forming one program. Extract: Program Modification Program Modification Programs, and thus all EOL procedures written in their final form are always related to variables I, Q, E or P, with fixed indexes of a narrow range from 1 to 32. Operations on these indexes or their modification during the program execution are not included in the EOL language. Therefore, substituting parameters in procedures while executing the program is not possible. This enables a significant simplification of EOL implementation. On the other hand, these limitations create some difficulties while writing programs. For instance, a small number of variables requires a careful selection of their indexes. This can be inconvenient in bigger programs, where for instance, some variables should be common for several procedures. In order to lessen these inconveniences a method has been adopted for automatic program modification before its execution. This method is based on the well-known idea of macro-definitions which are then included in the program by means of macro-instructions. The procedures can be initially written in the source program as macro-definitions, in which the chosen indexes are written as formal parameters in the form of identifiers. These procedures can be included in the object program by means of macro-instructions, which assign actual numerical values to these identifiers. Due to this, fixed values of indexes can be established by the programmer at the moment of assembling several procedures into one program. The accepted method of program modification permits us to write the procedures with symbolic indexes. However, while writing the final program the programmer is charged with some additional operations which, in practice, are not too burdensome. At these costs, the EOL language could be significantly simplified and the efficiency of its operation increased as compared with languages in which the writing of programs is easier. Extract: EOL Language Extension EOL Language Extension EOL is a universal but relatively concise language, designed with only a basic set of instructions for symbol manipulation. More complex operations can be defined as procedures. However, in many applications the execution time of such procedures can be rather long. In order to make them more efficient, the EOL procedures can be also written in machine language. As a rule they are based on the data structure accepted in EOL, and use the Interpreter subroutines. Thus, these procedures may be treated as EOL language extensions defining specialized operations, tailored to a given problem. The EOL procedure written in machine language are often first written and debugged in EOL language and then translated into machine language by a programmer being familiar with the Interpreter and the EOL data structure. This system permits one to obtain a full program documentation in EOL language and possibly to perform it in another computer, equipped with the EOL Interpreter. Extract: Conclusions Conclusions EOL is a simple low-level symbol manipulation language, relatively efficient, flexible and easy to implement. These results have been made possible by the following features of this language: a) Arbitrary input or output strings, including control characters. b) Separate devices, including storage allocation methods, for processing short but complex expressions and for processing files containing a great deal of information. c) Simple format of instructions and the possibility of defining more complex operations by means of procedures which can be written also in machine language. d) Possibility of automatic program modification before its execution. The experiments conducted so far indicate EOL usefulness, especially for translating from one automatic programming language to another. in Bobrow, D. G. (ed) "Symbol Manipulation Languages and Techniques", Proceedings of the IFIP Working Conference on Symbol Manipulation Languages. North-Holland Publishing Co., Amsterdam, 1968 view details [321 programming languages with indication of the computer manufacturers, on whose machinery the appropriate languages are used to know. Register of the 74 computer companies; Sequence of the programming languages after the number of manufacturing firms, on whose plants the language is implemented; Sequence of the manufacturing firms after the number of used programming languages.] in Bobrow, D. G. (ed) "Symbol Manipulation Languages and Techniques", Proceedings of the IFIP Working Conference on Symbol Manipulation Languages. North-Holland Publishing Co., Amsterdam, 1968 view details in Computers & Automation 21(6B), 30 Aug 1972 view details The exact number of all the programming languages still in use, and those which are no longer used, is unknown. Zemanek calls the abundance of programming languages and their many dialects a "language Babel". When a new programming language is developed, only its name is known at first and it takes a while before publications about it appear. For some languages, the only relevant literature stays inside the individual companies; some are reported on in papers and magazines; and only a few, such as ALGOL, BASIC, COBOL, FORTRAN, and PL/1, become known to a wider public through various text- and handbooks. The situation surrounding the application of these languages in many computer centers is a similar one. There are differing opinions on the concept "programming languages". What is called a programming language by some may be termed a program, a processor, or a generator by others. Since there are no sharp borderlines in the field of programming languages, works were considered here which deal with machine languages, assemblers, autocoders, syntax and compilers, processors and generators, as well as with general higher programming languages. The bibliography contains some 2,700 titles of books, magazines and essays for around 300 programming languages. However, as shown by the "Overview of Existing Programming Languages", there are more than 300 such languages. The "Overview" lists a total of 676 programming languages, but this is certainly incomplete. One author ' has already announced the "next 700 programming languages"; it is to be hoped the many users may be spared such a great variety for reasons of compatibility. The graphic representations (illustrations 1 & 2) show the development and proportion of the most widely-used programming languages, as measured by the number of publications listed here and by the number of computer manufacturers and software firms who have implemented the language in question. The illustrations show FORTRAN to be in the lead at the present time. PL/1 is advancing rapidly, although PL/1 compilers are not yet seen very often outside of IBM. Some experts believe PL/1 will replace even the widely-used languages such as FORTRAN, COBOL, and ALGOL.4) If this does occur, it will surely take some time - as shown by the chronological diagram (illustration 2) . It would be desirable from the user's point of view to reduce this language confusion down to the most advantageous languages. Those languages still maintained should incorporate the special facets and advantages of the otherwise superfluous languages. Obviously such demands are not in the interests of computer production firms, especially when one considers that a FORTRAN program can be executed on nearly all third-generation computers. The titles in this bibliography are organized alphabetically according to programming language, and within a language chronologically and again alphabetically within a given year. Preceding the first programming language in the alphabet, literature is listed on several languages, as are general papers on programming languages and on the theory of formal languages (AAA). As far as possible, the most of titles are based on autopsy. However, the bibliographical description of sone titles will not satisfy bibliography-documentation demands, since they are based on inaccurate information in various sources. Translation titles whose original titles could not be found through bibliographical research were not included. ' In view of the fact that nany libraries do not have the quoted papers, all magazine essays should have been listed with the volume, the year, issue number and the complete number of pages (e.g. pp. 721-783), so that interlibrary loans could take place with fast reader service. Unfortunately, these data were not always found. It is hoped that this bibliography will help the electronic data processing expert, and those who wish to select the appropriate programming language from the many available, to find a way through the language Babel. We wish to offer special thanks to Mr. Klaus G. Saur and the staff of Verlag Dokumentation for their publishing work. Graz / Austria, May, 1973 in Computers & Automation 21(6B), 30 Aug 1972 view details in Computers & Automation 21(6B), 30 Aug 1972 view details |