1 I E> R.AR.Y 
 
 OF THE 
 U N IVLR.5ITY 
 OF ILLINOIS 
 
 510.84 
 IZ6r 
 
 no. 237-242 
 
 cop. 2 
 
The person charging this material is re- 
 sponsible for its return on or before the 
 Latest Date stamped below. 
 
 Theft, mutilation, and underlining of books 
 are reasons for disciplinary action and may 
 result in dismissal from the University. 
 
 University of Illinois Library 
 
 * 
 
 IB W71 
 4 2 
 
 mm 
 
 DEC 
 
 L161— O-1096 
 
Digitized by the Internet Archive 
 
 in 2013 
 
 http://archive.org/details/eolreport241luka 
 
5/0. W 
 
 Report No. 2*kL 
 
 September X, ±9&1 
 
 )yv*sCtt 
 
 EOL REPORT 
 
 by 
 
 Leon Lukaszewicz 
 and 
 Jurg Nievergelt 
 
 UrtfVkHSlTY OF ILLINOIS 
 
 '5*1968 
 LIBRARY 
 
Report No. 2^1 
 
 EOL REPORT* 
 
 by 
 
 Leon Lukaszewicz 
 and 
 Jurg Nievergelt 
 
 September 1, 19^7 
 
 Department of Computer Science 
 University of Illinois 
 Urbana, Illinois 6l801 
 
 * 
 
 This work was supported in part by the National Science Foundation 
 under Grant No. GV-k6^G. 
 
ACKNOWLEDGEMENT 
 
 EOL has been implemented on an IBM 709^- by Freda S. Fischer, 
 M. Irwin-Zarecki, J. R. Sidlo, D. S. Edgar, and R. Sanders. Their 
 active participation in the project is gratefully appreciated. 
 
 111 
 
TABLE OF CONTENTS 
 
 Page 
 
 ACKNOWLEDGEMENT iii 
 
 1. INTRODUCTION 1 
 
 1.1. Purpose and history of EOL 1 
 
 1.2. The EOL Computer 2 
 
 1.2.1. Input and Output 2 
 
 1.2.2. Stacks 4 
 
 1.2.3. Instruction Address Stack 5 
 
 1.2.4. Logical Register H 5 
 
 1.2.5. Files ......... 6 
 
 1.3. General structure of EOL programs . . . 7 
 
 1.4. Formal description of syntax 8 
 
 1.5* Reference language and its representation .... 9 
 
 1.6. Notation for the values of variables 10 
 
 2. BASIC SYMBOLS 11 
 
 2.1. Characters 11 
 
 2.1.1. Letters 11 
 
 2.1.2. Digits 11 
 
 2.1.3. Delimiters 11 
 
 2.1.4. Precedence of characters 12 
 
 2.2. Markers 12 
 
 3- VARIABLES AND THEIR VALUES 13 
 
 3.1. Inputs. 13 
 
 3-2. Outputs 13 
 
 3-3- Stacks. l4 
 
 3.3.1. Words 14 
 
 3.3.1.1. Precedence of words 14 
 
 3.3.2. Numbers Ik 
 
 3.3.3. Address 15 
 
 3.3.3.1' Instruction address 15 
 
 3.3.3.2. Pointer position 15 
 
 3.3.4. Examples of stack values 15 
 
 3.3.5. Instruction address stack 15 
 
 3.4. Files 16 
 
 3.5. Logical values l6 
 
 3.6. Initial values l6 
 
 4. GENERAL FORMAT OF INSTRUCTIONS IT 
 
 4.1. Operators 17 
 
 4.2. Arguments IT 
 
 4.2.1. Literals 17 
 
 4.2.2. Integers 18 
 
 IV 
 
TABLE OF CONTENTS (Continued) 
 
 Page 
 
 4.2.3. Indexed mode symbols 18 
 
 4.2.3.1. Intermediate list 18 
 
 4. 2. 3. 2. Mode symbols 19 
 
 4.2.3.2.1. Mode of reading . . 19 
 
 4.2.3.2.2. Mode of adding. . . 20 
 
 4.2.3.2.3. Mode of testing . . 20 
 
 4.2.3.3. Indexes 21 
 
 4.2.3.4. Examples 21 
 
 4.2.4. Tests 22 
 
 4.2.4.1. Number of steps 22 
 
 4.2.4.2. Constituent test. . . 22 
 
 4.2.4.2.1. Class ....... 22 
 
 4.2.4.2.2. Word test operator. 23 
 
 4.2.4.2.3. Number test 
 
 operator. 24 
 
 4.2.4.2.4. Constituent 
 
 compared 24 
 
 4.2.4.2.5. Address test. ... 25 
 
 4.2.4.3. Record test 25 
 
 4.2.4.4. Examples. 25 
 
 4.2.5. Labels. ...... 26 
 
 4.3. Termination of reading a list 26 
 
 4.3.1. Reading an input or a stack 26 
 
 4.3.2. Reading a file 27 
 
 4.4. Instruction conventions 28 
 
 4.4.1. Missing second argument 28 
 
 4.4.2. Testing with an empty stack 28 
 
 4.4.3. Undefined result. . . 29 
 
 5. INSTRUCTIONS 30 
 
 5.1. Stack instructions 30 
 
 5.1.1. Move 30 
 
 5.1.2. Exchange 31 
 
 5.1.3. Set into stack 32 
 
 5.1.4. Clear stack 32 
 
 5.1.5. Test stack 33 
 
 5-1.6. Arithmetic instructions 34 
 
 5.I.T. Convert to word 35 
 
 5.1.8. Convert to number 36 
 
 5.1.9. Split 37 
 
 5.1.10. Compress 38 
 
 5.1.11. Count 38 
 
 5.2. Input instructions 39 
 
 5.2.1. Read 39 
 
 5.2.2. Clear input . ..... 40 
 
 5.2.3. Test input 4l 
 
 v 
 
TABLE OF CONTENTS (Continued) 
 
 Page 
 
 5. 3- Output instructions 42 
 
 5.3.1. Write 42 
 
 5.3.2. Set output 1^2 
 
 5.3.3. Output format instructions 43 
 
 5.4. File instructions 44 
 
 5.4.1. Put .' 44 
 
 5.4.2. Get 45 
 
 5.4.3. Save h6 
 
 5.4.4. Restore 46 
 
 5.4.5. Set into file 47 
 
 5.4.6. Clear file 47 
 
 5.4.7. Test file 48 
 
 5.4.8. Shift 49 
 
 5.4.9. Shift and count 50 
 
 5.4.ia Copy 51 
 
 5.5. Jump instructions 51 
 
 5-5.1. Simple jump 52 
 
 5.5.2. Conditional jump 52 
 
 5.5.3. Switch jump 53 
 
 5.5-4. Return 54 
 
 5.5.5. Stop 55 
 
 5.6. Table instructions 55 
 
 5.6.1. Search 55 
 
 5.6.2. Search and count 56 
 
 5.6.3. Extract 57 
 
 5.7. Macro instructions 58 
 
 5.8. Code 59 
 
 6. DECLARATIONS 60 
 
 6.1. Switches 60 
 
 6.1.1. Name switch 60 
 
 6.1.2. Index switch . 60 
 
 6.2. Tables 6l 
 
 6.2.1. Word table 6l 
 
 6.2.2. Number table 6l 
 
 6.3. Entry declaration 6l 
 
 6.4. External declaration 6l 
 
 6.5. Index declaration 62 
 
 7- PROGRAMS, PROCEDURES, MACROS 63 
 
 7-1. Programs 63 
 
 7.2. Procedure and statement 63 
 
 7.2.1. Comments 64 
 
 7.3. Macro definition 64 
 
 VI 
 
TABLE OF CONTENTS (Continued) 
 
 Page 
 
 7-4. Block structure and the scope of declarations . . 66 
 
 7.4.1. Procedures: external and internal. ... 66 
 
 7.4.2. Declaration of labels 67 
 
 7.4.3- Scope of a declaration of a label .... 67 
 
 7.4.4. Scope of an index declaration 68 
 
 7.4.5. Use of labels and formal indexes 68 
 
 7.4.6. Example 69 
 
 7«5« Flow of control in a program 69 
 
 BIBLIOGRAPHY 71 
 
 APPENDIX I. SUMMARY OF EOL SYNTAX 72 
 
 APPENDIX II. INDEX OF TERMS 78 
 
 Vll 
 
1 . INTRODUCTION 
 
 1.1. Purpose and history of EOL 
 
 EOL is a low-level language for manipulating strings of 
 characters. The following considerations guided the design of the 
 EOL language. 
 
 (a) It should be relatively easy to learn. 
 
 (b) It should be easily implemented on most computers. 
 
 (c) EOL programs should run efficiently. 
 
 (d) It should be well suited for two of the most 
 important applications of string manipulation 
 languages, namely: 
 
 (i) compiler writing 
 
 (ii) symbolic and algebraic manipulation 
 
 Concerning (a), EOL can be considered "to be the assembly 
 language of the fictitious EOL computer (to be described in 
 Section 1.2.), which has some fifty basic instructions and a very 
 simple general structure. 
 
 Concerning (b), the EOL system consists of a compiler 
 
 (see [8]), written in EOL, and an interpreter (see [9])> documented 
 
 in a language XI (see [10]) which is close to the assembly language 
 of many modern computers . 
 
 Concerning (c), the data structure of EOL is such that on a 
 binary, word oriented computer (for which EOL is mainly intended), 
 operations on strings are done word by word, not character by character. 
 A second feature which enhances the efficiency of EOL is the possibility 
 to call procedures written in machine language from EOL programs. 
 
 Concerning (d), reference [7] gives some examples of EOL 
 programs which are discussed in detail. These examples are also 
 intended to help the reader learn EOL. Another example of an EOL 
 application is the EOL compiler itself (see [8]). 
 
Many concepts used in EOL were taken from other symbol 
 manipulation languages, in particular IPL-V [l] and COMIT [2]. The 
 basic features of EOL first appeared in [5]. Two previous versions, 
 EOL-1 and EOL-2 have been developed and implemented at the Institute 
 for Mathematical Machines in Warsaw, Poland, beginning in I965. On 
 this basis, an improved EOL-3 has been developed and implemented on 
 an IBM 709^ computer at the University of Illinois. 
 
 1.2. The EOL Computer 
 
 The EOL language can be described as the programming language 
 of the hypothetical EOL computer, shown in Figure 1. The EOL computer 
 is intended to be simulated on a conventional computer and is therefore 
 a pure software system. Binary fixed length word computers are best 
 suited for simulation of the EOL computer. 
 
 1.2.1. Input and Output 
 
 The EOL computer is equipped with a number of inputs, 
 identified by the variables 
 
 10, II, ..., la 
 
 and with outputs identified by variables 
 
 Q0, Ql, ..., Qp 
 
 In practice, inputs and outputs correspond to such devices as card 
 readers, line printers, or magnetic tapes. Therefore, the numbers 
 (X and 3 are usually small integers. Input and output data is 
 represented in the form of strings of arbitrary characters, like 
 letters, digits, arithmetic operators, etc. (see sections 3«1« and 
 3.2.). 
 
EOL COMPUTER 
 
 PO 
 
 PI 
 
 P6 
 
 10 
 
 la 
 
 Files 
 
 QO 
 
 QP 
 
 Inputs 
 
 Outputs 
 
 Figure 1 
 
The input data can be read under EOL program control, 
 character by character, and each character read is deleted from the 
 input string. Strings of consecutive characters read from an input 
 string can be assembled into larger units called words, which may 
 consist of an arbitrary number of characters. Input strings can be 
 tested under program control for occurrence of an arbitrarily specified 
 character pattern. Due to this, no limitations are imposed upon the 
 form of the input data so that the user may choose the format most 
 convenient for his purpose. 
 
 Similarly, the output strings are constructed under program 
 control and presented to an output by adding new characters at the end 
 of the indicated output string. 
 
 1.2.2. Stacks 
 
 Internal processing in the EOL computer is done mostly on a 
 number of stacks, identifed by the variables 
 
 SO, SI, ..., Sy 
 
 The number 7 depends on the particular implementation, and typically 
 is equal to 31 • 
 
 Stacks are linear lists of units called constituents, which 
 are strings of characters preceded by one of the marks or or /N . 
 These marks are not part of the EOL character set, but serve to 
 indicate the structure of a list and the types of its constituents. 
 
 A constituent may be of the type word, number, or address. 
 
 A word consists of a string of arbitrary characters, 
 preceded by the mark 
 
 A number is a freely chosen string of digits, possibly with 
 an algebraic sign and preceded by the mark . Numbers are usually 
 identified with the fixed point numbers available on the particular 
 computer on which EOL is implemented. They permit one to perform the 
 usual arithmetic operations on integers. 
 
An address is represented by any string of characters 
 preceded by the mark /s . Addresses are usually identified with 
 addresses available on the particular computer on which EOL is 
 implemented. They are used to identify 
 
 (a) a record in a file 
 
 (b) a position of the pointer in a file 
 
 (c) an instruction in an EOL program 
 
 The syntax of stack values is described in section 3- 3 = 
 
 In the EOL language there are many instructions which permit 
 flexible processing of stacks. For example, 
 
 (a) Moving a determined number of constituents from 
 the beginning of one stack to the beginning or to 
 the end of another stack, the original order of 
 constituents being kept or reversed. 
 
 (b) Compressing several words into one word or splitting 
 one word into separate words of one character each. 
 
 (c) Testing whether the initial or the final constituent 
 of a stack is equal to a given word or number. 
 
 In an EOL implementation, stacks are held in the main memory 
 as lists composed of pairs of computer words. Storage allocation for 
 stacks including retrieval of abandoned pairs for reuse proceeds 
 dynamically and automatically, using a "garbage collection" technique. 
 
 1.2. 3- Instruction Address Stack 
 
 A special instruction address stack IAS is used to hold 
 return addresses of subroutine calls. 
 
 1.2.^. Logical Register H 
 
 A one bit register H is used to hold the outcome (success or 
 failure) of tests. H can be tested by conditional transfer instruc- 
 tions. The two possible values of the variable H are denoted by 
 "plus" and "minus". A successful test leaves the value of H 
 
unchanged, an unsuccessful one sets it to "minus". Thus the effect 
 of several consecutive test instructions is that H will be "minus" if 
 at least one of the tests failed (logical OR). All conditional 
 transfer instructions automatically reset H to "plus", whether or not 
 the condition is satisfied. 
 
 1.2.5. Files 
 
 In the EOL computer mass storage is provided by files, 
 identified by the variables. 
 
 PO, PI, ..., Po. 
 
 Usually, the files PO and PI are held in core storage, and the others 
 correspond to such back-up storage devices as discs, drums, or magnetic 
 tapes . 
 
 Each of the files represents a linear list composed of any 
 number of records. 
 
 A normal record consists of a string of constituents, preceded 
 by the mark v. The entire content of a stack or part of it may be 
 stored as a normal record in a file. 
 
 A special record consists of a mark v followed by the 
 symbol a. It is used to denote the boundary between different sections 
 of a file. 
 
 In every file there is exactly one pointer t which indicates 
 some place or some record in the file. Reading from or writing into a 
 file always concerns the record which follows directly after the 
 pointer. 
 
 The syntax of file values is described in section 3«^« 
 
 In the EOL language there are many instructions which permit 
 one to process files, for example: 
 
 (a) Shift the pointer forward until it is positioned 
 
 immediately before the first-record that satis if ies 
 a specified condition. 
 
(b) Store the address of the record which is placed 
 directly after the pointer as the initial 
 constitutent of an indicated stack. 
 
 (c) Place the pointer of a file directly in front of 
 the record whose address is the initial constituent 
 of an indicated stack. 
 
 The last two operations permit one to manipulate addresses 
 of records by means of instructions designed to process stacks. This 
 facility is very important in many applications where an effective 
 search for information depends on the data structure in a file. 
 
 Files are designed to store a large amount of information. 
 For example., in program translation they may serve for storing 
 tables of identifiers or processed programs. 
 
 1.3» General structure of EOL programs 
 
 An EOL program consists of a sequence of macro definitions 
 followed by a sequence of external procedures. Macro definitions 
 can be included in external procedures at compile time. A macro 
 definition alone or an external procedure along with all macro 
 definitions which are to be included in this external procedure are 
 units which can be compiled separately (independent of any other 
 macro definition or external procedure). 
 
 Both a macro definition and a procedure consists of a 
 heading (which includes; among other things ; the symbols MACRO or 
 PROC); a procedure body, and a termination symbol END. 
 
 A procedure body is a sequence of statements; and a 
 statement in turn may be : 
 
 (a) An instruction; which usually causes the 
 
 execution of a simple action such as a change 
 of the value of a variable, However; a macro 
 instruction; which causes the insertion at compile 
 time of a copy (possibly modified by the replacement 
 of actual for formal parameters) of a macro 
 
 7 
 
definition in place of this macro instruction, 
 may be arbitrarily complex. 
 
 (b) A procedure. The fact that a procedure may contain 
 statements which are again procedures gives rise to 
 the nested block structure of EOL. 
 
 (c) Declarations, used to declare switches, tables of 
 constants (numbers or literals), formal indexes, 
 or labels with a special function (external labels 
 or entry points into a procedure). 
 
 (d) Comments, which have no effect on the execution of 
 programs . 
 
 Execution of an EOL program begins with the first instruction 
 of the procedure declared to be MAIN (see 7-2. ), and proceeds to the 
 instruction written next, unless the present instruction (a jump) or 
 the statement written next (a non executable statement) explicitly 
 state otherwise. 
 
 In the EOL language programs as well as input and output 
 data have the form of strings of characters. In particular any EOL 
 program may be the input to or the result of another program written 
 in this language. 
 
 l'^« Formal description of syntax 
 
 This report uses the Backus notation (which was designed 
 for the description of ALGOL [3]) to describe the syntax of EOL 
 programs and data. This notation has been extended with the following 
 conventions : 
 
 (a|b. .. | z ) denotes 
 
 a,b . . . z 
 [a|b... Iz] denotes 
 
 precisely one of the symbols 
 none or one of the symbols 
 
 a,b. . . z' 
 
 ' a J*' denotes "an arbitrary non-empty 
 
 sequence of symbols a" 
 
[a].. denotes "an arbitrary 3 possibly empty 
 
 sequence of symbols a" 
 
 Examples : 
 
 {A|b} may denote A 
 
 {A|b}.. may denote ABA 
 
 [A|b].. may denote an empty sequence 
 
 1.5» Reference language and its representatio n 
 
 The EOL language as defined in this report will be called 
 the reference language. Both the program and the data are defined 
 in this language as sequences of basic symbols satisfying some 
 specified syntax rules. Typographical features such as a space or 
 line feed are not part of the reference language. 
 
 In order to allow compatibility with available equipment and 
 clarity for a user, the EOL reference language admits various 
 representations. In such a representation each symbol of the reference 
 language has a character or typographical feature associated with it. 
 
 In the examples of programs contained in this report, the 
 following representation of the reference language is used. 
 
 (1) The symbol j j is replaced by an arbitrary non-empty 
 
 string of blanks . 
 
 (2) Each <delimiter> can be surrounded from both sides 
 by any number of blanks . 
 
 (3) The symbol \ denotes carriage return and line feed. 
 (k) If the last nonblank character in a line is the 
 
 character "-", then the next line is treated as a 
 continuation of the current line and not as a new 
 line. 
 (5) The remaining characters of the representation are the 
 same as in the reference language. 
 
 The above convention is not used for auxiliary notations for the values 
 of variables as described in 1.6., where the symbol j | preserves its 
 
 9 
 
form, while blanks and line feeds have no meaning. 
 
 1.6. Notation for the values of variables 
 
 In the examples given in this report the following notation 
 is used to illustrate the value of a variable : 
 
 <variable name> : <variable value> [— f ||- ] 
 
 The symbol H means that the elements (e.g. characters, constituents, 
 records) occur in the sequence <variable value> in the order in which 
 they are written from left to right. The symbol \- means that these 
 elements occur in the sequence in the order in which they are written 
 from right to left. If none of these symbols occur the effect is the 
 same as if the sequence were terminated by -\ . This latter symbol is 
 often used to emphasize the end of a sequence. 
 
 Examples : 
 
 II : ABCD 
 
 13 : H 
 
 Si+ : ~A1~=~3 H 
 
 S l+ : ~3~=~A1 h 
 
 The latter two notations are equivalent. It should be stressed here 
 that this type of notation is of auxiliary significance only and 
 has no influence on program execution or the data structure. 
 
 10 
 
2. BASIC SYMBOLS 
 
 The EOL reference language is built up of the following 
 "basic symbols 
 
 <basic symbol>: :={<character>|<marker>] 
 
 2.1. Characters 
 
 <character>: : = {<Letter> | <digit> j <delimiter>} 
 
 2.1.1. Letters 
 
 <letter>: :=(A|B. . . |Z) 
 
 The above set can be extended arbitrarily with other letters, e.g. 
 lower case letters . 
 
 2.1.2. Digits 
 
 <digit>: : = {0|l|2 ....... |9) 
 
 2.1.3- Delimiters 
 
 <delimiter>: : = { u | , | : | ' MM/I/} 
 
 The above list can be extended arbitrarily with any other delimiters. 
 In the reference language the character X serves the purpose of 
 separating consecutive statements in an EOL program, while 7 is assigned 
 no function. In particular implementations these delimiters may denote 
 typographical features, e.g. X may denote "carriage return line feed" 
 for output on a printer and "end of card" for input from a card reader. 
 7 may denote "start new page" on output or the "escape character" used 
 in several character codes. 
 
 11 
 
2 . 1 . h . Precedence of characters 
 
 The order of precedence is defined for the EOL character 
 set by the following list: 
 
 L-J 
 
 A,B, Z 
 
 0,1, 9 
 
 We say that a character which on the above list occurs earlier precedes 
 any character which occurs later and that the later character follows 
 the earlier one. 
 
 2.2. Markers 
 
 <marker>: : = ( I I \a\ It) 
 
 Markers,, except the pointer t, serve to define the structure of stacks 
 and files as described later. The pointer serves to distinguish a 
 certain record in a file. 
 
 The precedence of the characters which do not occur in this list is 
 undefined. It may be defined in a particular implementation. 
 
 12 
 
3. VARIABLES AND THEIR VALUES 
 
 EOL programs operate on a limited number of variables 
 selected from the following set : 
 
 inputs 10, II,... ICC 
 
 outputs QO, Ql, ...QP 
 
 stacks SO, SI, . . 0S7 
 
 files PO, P1,...P5 
 
 logical variable H 
 
 instruction address stack IAS 
 
 OL, p, 7, 6 denote same fixed poitive integers which depend 
 on the particular implementation. For instance, OL = p = 1, 7 = 31; 
 6 = 3. 
 
 3-1. Inputs 
 
 <input value>: :=<character string> 
 
 <character string>: :=[<character>] . . 
 
 Examples : 
 
 II : JOHN l_j SMITH 
 13 : A = B * (C + D) l_j X -\ 
 
 3-2. Outputs 
 
 <output value>: :=<character string> 
 
 Example : 
 
 Q2 : X = 3-1^159; l_i END 
 13 
 
3.3- Stacks 
 
 <stack value>: :=[<constituent>] . . 
 <c ons t i t uent> : : = { <word> | <numbe r> | <addres s>} 
 
 3.3.I. Words 
 
 <word>: := . {<character>) . . 
 
 Examples : 
 
 "ABC ~X=A+B ^ X ; "38 
 
 3.3-1-1' Precedence of words 
 
 We say that the word X precedes the word Y if in the process 
 of matching them character by character from left to right, in the first 
 pair of different characters the character of the word X precedes the 
 corresponding character of the word Y.(see 2.I.U.). 
 
 We assume that absence of a character (at the end of a word) 
 precedes any character. 
 
 We say that the word X follows the word Y if the word Y 
 precedes the word X. 
 
 3. 3-2. Numbers 
 
 <number>: := <integer> 
 
 <integer>: :=[+ I -] (<digit>) 
 
 Examples 
 
 o^r o 
 
 36 u -48 0006 
 
 Ik 
 
3-3-3- Address 
 
 <address>: :={<instruction address>|<pointer position>} 
 
 3.3-3-1- Instruction address 
 
 <instruction address>: := {<character>} . . 
 
 An instruction address is a symbol which denotes the location of an 
 instruction in a program. Instruction addresses are used automatically 
 by procedure calls and returns (see section 5-5-)- They may be 
 operated upon under program control by exchanging the values of the 
 instruction address stack IAS and of another stack (see 5.1.2.). 
 
 3.3.3.2. Pointer position 
 
 <pointer position>::= (<character>) . . 
 
 A pointer position is a symbol which denotes the beginning or the 
 end of a file or the boundary between two records in a file. It may 
 be used to save the current position of a file pointer and to "restore 
 the pointer to that place later. 
 
 3.3.^-. Examples of stack values 
 
 SI 
 
 ST 
 Sl6 
 
 ~Xl"="A~*~ ( ~B~+~GAMMA~ ) 
 
 "z"+"y~="x \- 
 
 °13^P08"X 
 
 3.3.5. Instruction address stack 
 
 The instruction address stack IAS is used mainly for storing 
 addresses of instructions of the type CALL. These addresses can be 
 used later by the RETURN instruction (see 5-5«)- 
 
 15 
 
Example : 
 
 IAS : "38' A63' 18 -\ 
 
 S\ /\ , /\ 
 
 3.4. Files 
 
 <file value>: : = [<record>] . .t [<record>] 
 <record>: :=l <stack value> 0} 
 
 The symbol a makes possible division of the file into sections. 
 Therefore, each file can consist of an arbitrary number of sequentially 
 ordered sections. 
 
 Examples : 
 
 PI : t 
 
 P3 : V "A _ BC°38t 
 
 P6 : a b c crt d e f 
 
 where a,b, . . . denote stack values 
 
 3. 5. Logical value 
 
 <logical value>: : = {+ I -} 
 
 Examples : 
 
 H 
 
 3-6. Initial values 
 
 By convention at the beginning of each program run the 
 variable H has the value "+" while all stacks (including IAS) are 
 empty. The initial values for inputs, outputs and files must be 
 defined for each particular run. 
 
 16 
 
4. GENERAL FORMAT OF INSTRUCTIONS 
 
 The form of an EOL instruction is either 
 
 <operator> ^ [<argument>[ ,<argument>[ , <argument>] ] ] 
 
 or 
 
 <operator> \j <argument>., , <argument> 
 
 The latter is a special case of a three -argument instruction where 
 the second argument need not be written because it is assigned a 
 standard value (see 4.4.1.). 
 
 4.1. Operators 
 
 An operator is always a string of capital letters, e.g. 
 
 move, set, search 
 
 The operator determines an instruction or a class of instructions which 
 are differentiated more exactly by the form of their arguments. 
 
 4.2 . Arguments 
 
 <argument>: :={<literal>|<integer>|<indexed mode symbol>| 
 <test>|<label>} 
 
 4.2.1. Literals 
 
 <literal>: :={ ? <any string of characters with the 
 
 restriction that quotation marks can occur 
 
 only in adjacent pairs. Such a pair inside 
 
 the literal denotes one quotation marl^ 1 I {L |g}*) 
 
 IT 
 
In the above definition 
 
 I ' ienotes the character X 
 G* denotes the character y 
 
 Examples of literals 
 
 'A 1 
 
 i « 
 U u u 
 
 •A 1 'A' 
 
 L* 
 
 denotes A 
 
 denotes three blanks 
 
 denotes A 'A 
 
 denotes ' * 
 
 denotes K 
 
 4.2.2. Inte 
 
 gers 
 
 See section 3°3=2. 
 
 4.2.3° Indexed mode symbols 
 
 <indexed mode symbol>: :-<mode symbolXindex> 
 
 4.2.3°1° Intermediate list 
 
 Many EOL instructions serve to transform some list of 
 elements. Execution of these instructions can be divided into three 
 steps : 
 
 (1) The successive elements of the source list indicated 
 by the first argument of an instruction are read 
 
 to form an intermediate list. The possible modes 
 of reading a source list are described in 4.2. 3 .2.1. 
 
 (2) The intermediate list is transformed in a way 
 determined by the instruction operator. 
 
 (3) The result is added to the destination list indicated 
 by the second argument of the instruction. The 
 possible modes of adding the intermediate list to a 
 destination list are described in k.2. 3 .2. 2. 
 
 18 
 
Some instructions cause reading of at most one element of the source 
 list ; others may cause reading of an arbitrary number of elements. 
 The moment when reading the source list is to be terminated is defined 
 by a test indicated by the last argument of the instruction . For 
 further discussion on the intermediate list see section 4. 3. 
 
 4.2.3.2. Mode symbols 
 
 <jnode symbol>: : = {a|b|y|z|t|c|D"|I |Q) 
 
 The <mode symbol> specifies the mode in which certain steps of the 
 execution of an instruction are performed. In some instructions 
 the mode symbol indicates also the type of variable to be operated 
 upon. 
 
 4.2.3.2.1. Mode of reading 
 
 The mode of reading a source list to form an intermediate 
 list is defined by the mode symbols as follows : 
 
 A read and delete successive constituents 
 
 from the beginning of a stack S. 
 
 B read and copy successive constitutents 
 
 from the beginning of a stack S without 
 deleting them. 
 
 Z read and copy the last constituent from 
 
 a stack S without deleting it. 
 
 I read and delete successive characters 
 
 from the beginning of input I. 
 
 C read and delete successive records 
 
 following the pointer t in a file P. 
 
 D read and copy successive records following 
 
 the pointer t in a file P without deleting 
 them. The pointer is then placed after the 
 last record which has been read. 
 
 19 
 
4.2.3-2.2. Mode of adding 
 
 After an intermediate list has been created and perhaps 
 transformed then it is added to the destination list in a way defined 
 
 by the mode symbol as follows : 
 
 A reverse the order of the constituents 
 
 in the intermediate list, then attach 
 this modified list at the beginning 
 of stack S. 
 
 B attach the intermediate list of 
 
 constitutents at the beginning of 
 a stack S. 
 
 Y reverse the order of the constituents 
 
 in the intermediate list, then attach 
 this modified list at the end of a 
 stack S. 
 
 Z attach the intermediate list of 
 
 constituents at the end of a stack S. 
 
 C reverse the order of the records in the 
 
 intermediate list, then insert this modified 
 list in the file P directly after the 
 pointer t . 
 
 D insert the intermediate list of records 
 
 in a file P directly after the pointer t , 
 then place the pointer t directly after 
 the last record of the inserted list. 
 
 Q attach the intermediate list of characters 
 
 at the end of output Q. 
 
 4.2.3.2.3. Mode of testing 
 
 Indexed symbols are also used to indicate a constituent 
 which is tested against another constituent defined by the instruction, 
 
 20 
 
In this case the meaning of the indexed symbol is as follows: 
 
 B test using the first constituent 
 
 of a stack S. 
 
 Z test using the last constituent 
 
 of a stack S. 
 
 T test using consecutively all the 
 
 constituents in a stack So The test 
 is said to be fulfilled if it is 
 fulfilled in relation to at least one 
 constituent of S. 
 
 4.2.3.3. Indexes 
 
 <index>: : = {-<actual index>| '<formal index>) 
 <actual index>: :={l|2 | . . . .fi} 
 
 where 0, is equal to the maximum of OL, (3, y , 5. 
 
 <f ormal index>: :=<letter>[<letter>|<digit>] . . 
 
 To facilitate the description of instructions, the following 
 symbols are introduced to denote indexes : 
 
 <n>: :=<index> 
 <m>: :=<index> 
 <k>: :=<index> 
 
 4.2.3.U. Examples 
 
 Indexed mode symbols with actual indexes : 
 
 Al, B8, A7, PI 
 
 Indexed mode symbols with formal indexes : 
 
 A'X, B ? C2, P'AB 
 21 
 
k.2.k. Tests 
 
 <test>: : = {Cumber of steps>j<constituent test>|<record test-" 
 
 In most instructions the <test> argument defines the 
 
 moment when the process of forming an intermediate list should be 
 
 terminated. This argument is always placed as the last argum' 
 an instruction. 
 
 4.2.^.1. Number of steps 
 
 Cumber of steps>: :=:*{<integer>| {B|z)<k>} 
 
 The <number of steps> is determined either by <integer> or 
 the first or the last constituent of stack S<k>, The absolute value of 
 this number indicates the number of elements to be read from a scarce 
 list to form an intermediate list. 
 
 4*2. U. 2. Constituent test 
 
 Constituent test>s ; {<word test>|Cumber test>j<address test>} 
 
 <word test>; ;={<class>|<word test operator> 
 
 {<literal>| Constituent compared>} } 
 
 Clumber test>: ;=<number test operator> 
 
 {<integer> | Constituent compare d>} 
 
 <address test>: ^Constituent compared> 
 
 A Constituent test> defines a condition which may or 
 may not be fulfilled by a constituent. 
 
 k. 2. k. 2.1. Glass 
 
 Class>: : = {Class letter>} . . 
 Class letter>: ; = {L|d|b|r} 
 
 22 
 
In the sequence which forms the <class> symbol each <class 
 letter> may appear only once. The meaning of the <class letter > is 
 as follows : 
 
 L denotes letters 
 
 D denotes digits 
 
 B denotes the character u (''blank") 
 
 R denotes all remaining characters 
 
 The classes specified by the above symbols are mutually 
 exclusive and they exhaust all the characters used in EOL. 
 
 A <class> symbol denotes a set of characters. A character 
 belongs to this set if it belongs to one of the classes specified by 
 the <class letters> used in this symbol „ 
 
 Examples : 
 
 LD denotes all letters and digits 
 
 RB denotes all characters except 
 letters and digits 
 
 LRB denotes all characters except digits 
 
 When testing a word against a <class> symbol the first 
 character only in the tested word is considered. For instance, the 
 test of a word with the class symbol DL is fulfilled if the first 
 character of this word is a digit or a letter. ' Otherwise, the 
 test fails. 
 
 4.2.4.2.2. Word test operator 
 
 <word test operator>: :=[ {PR | PEJFL|fe)/] 
 
 The word test operator specifies what relation is to be 
 tested between the word indicated by an instruction and the word 
 indicated by <literal> or Constituent comparedX 
 
 23 
 
The indicated options of <word ' I >perator> have the 
 
 following meanings 
 
 O perator 
 
 empty 
 PP./ 
 
 pe/ 
 fl/ 
 fe/ 
 
 Relation 
 
 equal 
 
 precedes 
 
 precedes or equal 
 
 f O.I LOWS 
 
 follows or equal 
 
 k.2.k.2.3. Number test operator 
 
 Cumber test operator^ , = [ {GT JGE| LT |lE}/] 
 
 The <numher test operator> specifies what relation is to 
 be tested between the number indicated by an instruction and the 
 number indicated by <literal> or Constituent comparedX 
 
 The indicated options of <number test operator> have the 
 following meaning: 
 
 Operat or 
 
 empty 
 GT/ 
 
 ge/ 
 
 IT/ 
 IE/ 
 
 Relation 
 
 equal 
 
 greater than 
 
 greater than or equal 
 
 less than 
 
 less than or equal 
 
 k-.2.k.2..k-. Constituent compare d 
 
 Constituent compared>: : = {b|Z JT}<k> 
 
 Constituent compare d> specifies a constituent or a 
 ■ .' i I jents which are to be tested. The meaning of the 
 letters B, Z, and T is explained in (^.2.3.2.3. ). 
 
 2k 
 
4.2.4.2.5- Address test 
 
 The <address test> specifies a constituent or a list of 
 constituents (assumed to be addresses) which are to be tested. The 
 address test has no operator and, hence, tests for equality. 
 
 4.2.4.3. Record test 
 
 <record test>: := ^constituent test>|s*|R*) 
 
 (1) A record test of the type Constituent test> is 
 fulfilled if the first constituent in the record which is located 
 directly after the pointer in the indicated file satisfies the test. 
 
 (2) A record test of the type S* is fulfilled if a 
 special record a is located directly after the pointer in the 
 indicated file. 
 
 (3) A record test of the type R* is fulfilled if the 
 special record a is located just before the pointer in the indicated 
 file. 
 
 The file in which the record is to be tested is determined 
 by the instruction which contains the <record test>. 
 
 4.2.4.4. Examples 
 
 The test symbols written on the left test a constituent 
 (which is defined by the instruction which contains this constituent 
 test) for the condition specified on the right. 
 
 B3 equal to the first constituent in S3- 
 
 Both constituents are assumed to be of 
 the same type--words, numbers or 
 addresses . 
 
 LT/T2 less than at least one of the constituents 
 
 of S2. Both constituents are assumed to 
 be numbers . 
 
 PE/Z5 precedes or is equal to the last constituent 
 
 in S5« Both constituents are assumed to be 
 words . 
 
 25 
 
If the two constituents tei 
 the result of the test is undefined k.k.^.). 
 
 4.2.5. Labels 
 
 <label>s i-<3. non-empty sequence of characters different from ^ |,|: j •> 
 
 Labels are used in programs to denote instructions, switches, 
 procedures and macro-definitions. 
 
 Examples ; 
 
 ALFA 
 * 
 
 Xl+2 
 
 ^ ° 3 • Termination of reading a list 
 
 The first step in executing many instructions consists of 
 forming an intermediate list by reading the consecutive elements of a 
 source list indicated by the first argument of an instruction (see 
 4.2.3.I. )• This action is terminated when either all the elements 
 of the list (up to some definite point) have been read or when the 
 conditions defined by the test argument are fulfilled. 
 
 In some cases, when no elements are read from the source 
 list, the intermediate list remains empty. For example, this is the 
 case when the source list is initially empty or when the first 
 element of this list fulfills the test. In all these cases execution 
 of the instruction is terminated without performing any other of its 
 steps, possibly with the exception that H is set to minus. 
 
 k . 3 • 1 • Read ing an i nput or a st ack 
 
 This section includes the cases of reading the consecutive 
 constituents in a stack and of reading the consecutive characters 
 'jer in an input string or in a constituent of type word. The 
 of the reading is determined by the following rules. 
 
 2.6 
 
(1) If the <test> argument is absen t, then all the elements 
 of the indicated list are read. In particular, if this list is 
 initially empty then execution of the instruction is immediately 
 terminated without changing any of the variables. 
 
 (2) If the test argument is <number of steps> then the 
 reading is terminated when the number of elements which have been read 
 is equal to the number defined by the test argument. 
 
 (3) If the test argument is Constituent test> then tl 
 reading is terminated with the last constituent which does not fulfill 
 the test. Therefore, the first constituent not read is the one which 
 fulfills the test. 
 
 If the first element of a list fulfills the test, no element 
 is read and execution of the instruction is terminated without 
 changing any of the variables . 
 
 (h) If the test argument is present and all the constituents 
 of a stack have been read before the indicated test is fulfilled then 
 the reading is terminated and H is set to minus. If the source list 
 is initially empty then execution of the instruction is terminated 
 and H is set to minus. 
 
 4.3.2. Reading a file 
 
 Termination of the reading of consecutive records in a file 
 is governed by the following rules. 
 
 (1) If the <test> argument is absent , then the reading is 
 terminated when all the records between the pointer t and the end 
 
 of the file have been read. In particular, when the pointer t 
 
 is initially at the end of the file then execution of the instruction 
 
 is immediately terminated without changing any variables. 
 
 (2) If the test argument is <number of steps> then the 
 reading is terminated when the number of the records which have been 
 read is equal to the number deinfed by that argument, unless conditions 
 described in paragraph (k) arise. 
 
 27 
 
(3) If the test argument ie <constituent test> then the 
 reading of a file is terminated with the last record which does not 
 fulfill the test. If the record just after the pointer fulfills 
 the test, no record is read and execution of the instruction is 
 terminated. Other conditions are described in paragraph k. 
 
 (k) If the test argument is of the type <number of steps-- 
 or Constituent test> and all the records between the pointer \ and 
 the nearest record a or the end of the file have been read before t 
 indicated test is fulfilled, then the reading is terminated and H is 
 set to minus. 
 
 (5) If the test argument is equal to S* then the reading 
 of a file is terminated just before a special record a is read or 
 when an end of file is met. 
 
 (6) If the test argument is equal to R* then the reading 
 of a file is terminated just after a special record a has been read. 
 If the record a is not met, then all the records between the pointer t 
 and the end of file are read and H is set to minus. 
 
 h.k. Instruction conv e ntions 
 
 The following conventions are valid for all the instructions 
 described in section 5. even if they are not specifically mentioned. 
 
 k . h . 1 . Missi ng sec ond argument 
 
 Some stack instructions have the format 
 
 <operator> u <a.rgument>, ,<argument> 
 
 in which case the second argument is said to be missing. By convention, 
 each such instruction has the same effect as one in which the second 
 argument is present and equal to B<h>, where <n> is the index that 
 occurs in the first argument. 
 
 k.k.2. Test ing wit h an empty stack 
 
 If the last argument of an instruction is of the type <test> 
 I it refers to a stack which is empty, then the only effect of this 
 
 28 
 
instruction is to set the value of H to minus. 
 
 k.k.3. Undefined result 
 
 In the description of many instructions certain implicitly 
 or explicitly mentioned assumptions are made. For instance: 
 
 (1) In arithmetic instructions it is assumed that the 
 quantities defined by two argument of the instruction are numbers. 
 
 (2) In all tests it is assumed that the two quantities to 
 be compared are of the same type, e.g. they are both words, both 
 numbers or both record addresses. 
 
 (3) It is assumed that any instruction which uses a label 
 lies within the scope of exactly one declaration of this label. 
 
 In the case when such assumptions are not fulfilled, the 
 result of the execution of the instruction is undefined. 
 
 29 
 
5 . INSTRUCTIONS 
 
 <instruction>; :={<stack ins true tion>|<input instruction^ 
 <output instruction>|<file instruction>| 
 <jump instruction>|<table instruction>| 
 <macro instruction>|<code>} 
 
 5.1. Stack instructions 
 
 <stack instruction>: :={<move>|<exchange>|<set into stack>] 
 
 <clear stack>|<test stack>| 
 <arithmetic instruction>| <convert to word>| 
 <c on vert to number>|<split>|<compress>|<count>} 
 
 5.1.1. Move 
 
 <move>: :=MOVE u (a|b|z)<ti>, (A | B | Y |Z}^n> 
 
 [,{<number of steps>| Constituent test)] 
 
 Read successive constituents from S<n> and add them to S<m>. 
 
 The first argument specifies the mode of reading constituents 
 from stack S<n> (see ^.2.3.2.1. )• 
 
 The second argument specifies the mode of adding to stack 
 S<m> the constituents which have been read (see U.2.3.2.2. ) . 
 
 The third argument (or its absence) specifies the moment 
 when reading of constituents from S<n> is to be terminated (see lj-.3-l.)< 
 
 Examples : 
 
 Let us assume that 
 
 SI : "XA"l"="l8°3"; 
 S3 : "ALFA" u 
 S8 : ";~= 
 H : + 
 
 30 
 
Execution of the MOVE instruction on the left causes the 
 results indicated on the right. 
 
 MOVE Al, A3, *2 
 
 MOVE Bl, B3, ' = ' 
 MOVE Bl, A3, R 
 MOVE Bl, Z3, T8 
 MOVE Al, Y3, Z8 
 
 MOVE A3, B3, B 
 MOVE A3, B3, D 
 MOVE B3, B3 
 
 SI 
 
 : 
 
 "-"iBVi 
 
 S3 
 
 '• 
 
 ~l"XA~ALFA~ u 
 
 S3 
 
 : 
 
 ~xa~i~alfa~ u 
 
 S3 
 
 • 
 
 ~i"xa"alfa" u 
 
 S3 
 
 : 
 
 ~ALFA~ y ~xa~i 
 
 SI 
 
 : 
 
 -=-l8°3 
 
 S3 
 
 ' 
 
 "alfa" u ~i"xa 
 
 no 
 
 changes 
 
 H 
 
 . 
 
 _ 
 
 S3 
 
 ALFA y ALFA y 
 
 5.1.2. Exchange 
 
 <exchange>: :=EXCHANGE y {B<n>| IAS} , {B<m>| IAS) 
 
 Exchange the contents of the stacks indicated by the first 
 and second argument „ 
 
 Example : 
 
 Let 
 
 SI 
 
 S8 
 
 IAS 
 
 XI Q 
 -X2° 3 
 LI L2 
 
 Execution of the following instructions causes: 
 
 EXCHANGE Bl, B8 
 
 EXCHANGE IAS, Bl 
 
 SI : 
 
 -X2° 3 
 
 S2 : 
 
 : "Xl'Q 
 
 SI : 
 
 : LI L2 
 
 IAS ; 
 
 : "X1"Q 
 
 31 
 
EXCHANGE IAS, IAS no changes 
 
 Exchanging the instruction address stack IAS allows the 
 programmer to operate on the return addresses of his subroutine calls. 
 
 5.I.3. Set into stack 
 
 <set into stack>: :=SET u {b|z)<i>, {<integer>|<literal>) 
 
 Add to S<n> the constituent whose value is indicated by the 
 second argument. In the case of <integer> the constituent added is of 
 type number. In the case of <literal> it is of type word. 
 
 The first argument specifies the mode of adding the 
 constituent to S<n> (see 4.2.3.2.2.). 
 
 Examples : 
 
 Let S5 : ~X°3 
 
 Execution of the following instructions causes 
 
 SET B5, 7 S5 : °T~X°3 
 
 SET Z5 ; 'ALFA' S5 : _ X°3~ALFA 
 
 5.1.4. Clear stack 
 
 <clear stack>: :=CLEAR u A<n>[, {<h umber of steps>| Constituent test>) ] 
 
 Read and delete consecutive constituents from the beginning 
 of stack S<n>. 
 
 The second argument (or its absence) specifies the moment 
 when reading and deleting of constituents from S<h> is to be terminated 
 (see 4.3.1. ). 
 
 Example : 
 
 Let 
 
 S3 : ~XA~: "18 
 o. 
 
 32 
 
 S4 : °1°3°5 
 
Execution of the following instructions causes : 
 
 CLEAR A3, *2 S3 : "l8 
 
 CLEAR Ak, GT/4 SJ+ : °5 
 
 5.1.5. Test stack 
 
 <test stack>: :=TEST u {A | B |z}<n>[ , Constituent test>] 
 
 If the second argument is present and S<n> is not empty 
 then read one constituent from S<n> (see ^.2.3.2.1.) and test if it 
 fulfills the relationship specified "by the second argument (see k.2.k.2.), 
 If the test fails, then assign the value minus to H. 
 
 If the second argument is present and S<n> is empty, then 
 assign the value minus to H. 
 
 If the second argument is absent and S<n> is not empty , 
 then assign the value minus to H. Furthermore, if the first 
 argument is equal to A<h>, delete the first constituent from S<n>. 
 
 If the second argument is absent and S<n> is empty nothing 
 changes. Thus a test stack with a missing second argument tests 
 whether a stack is empty „ 
 
 Examples ; 
 
 Let 
 
 SI : "Xl°8 -\ 
 
 S5 : H 
 
 H : + 
 
 Execution of the following instructions causes: 
 
 TEST Al, D S3 1 °8 -\ 
 
 H : - 
 
 TEST Bl, LB H : no change 
 
 TEST Zl, GT/8 H : - 
 
 33 
 
TEST A 5 H : no change 
 
 TEST Z5 H : no change 
 
 5.1.6. Arithmetic instructions 
 
 Arithmetic instructions>: : = {ADD | SUB | MULT |DIV) u {A|B|Z)<n> J , 
 
 [{B|Z)<in>] , {<integer>|{B|z)<k» 
 
 Perform the arithmetic operation indicated by the operator 
 on the operands specified by the first and the third argument. Put 
 the result on stack S<m>. 
 
 If the second argument in the instruction is omitted then 
 the result is added at the beginning of S<n>. 
 
 The first argument specifies the mode of reading S<n> to 
 obtain the first operand (see 4.2.3.2.1,,). 
 
 The third argument specifies either an integer or the mode 
 of reading S<k> to obtain the second operand. 
 
 The second argument indicates the mode of adding the result 
 to S^n> (see 4.2.3.2.2. ). 
 
 The meaning of the operators is as follows : 
 
 ADD add 
 
 SUB subtract (the operand specified 
 
 by the third argument from the 
 operand specified by the first 
 argument ) 
 
 MULT multiply 
 
 DIV divide (the operand specified by 
 
 the first argument by the operand 
 specified by the third argument) 
 
 3^ 
 
ADD, SUB and MULT yield only one constituent as result. DIV yields 
 two constituents as a result. The first is the remainder of the 
 division, which has the same sign as the dividend. The second is the 
 integral part of the quotient. If the divisor is zero the division 
 is not performed and H is set to minus. If the stack indicated by 
 either the first or the third argument is empty then H is set to minus 
 
 Examples : 
 
 Let 
 
 SI 
 
 Va°o 
 
 S3 : -11 3 
 
 Execution of the following instructions causes 
 
 ADD Bl, Zl, B3 
 MULT Al,,2 
 DIV A3,, Zl 
 
 DIV A3, B3, Bl 
 
 SUB Bl, B3, Z3 
 
 SI 
 
 ' 
 
 °9-A°0°-2 
 
 SI 
 
 '• 
 
 °18-A°0 
 
 S3 
 
 ° 
 
 no change 
 
 H 
 
 • 
 
 - 
 
 SI 
 
 £ 
 
 no change 
 
 S3 
 
 * 
 
 °-2°-l"3 
 
 result undefined (the constituent 
 indicated by the third argument is 
 not of type number) 
 
 5=1,7' Convert to word 
 
 <convert to word>: i=WORD u {A |B |z}<n>[ , (B |z}<m>] 
 
 If S<n> is empty, set H to minus. Otherwise, read one 
 constituent (which is supposed to be of type number) from S<n> 
 (see 4.2.3-2.1.), convert it to a constituent of type word which 
 expresses this number in decimal notation and add the result to S<m> 
 (see 4.3.2.2,2.). The word obtained is an integer (see 4,2.2.) which 
 
 35 
 
has no leading zeros (with the exception of zero which results ii 
 single digit zero) and no plus sign if it is positive. 
 
 If the second argument in the instruction is omitted tl 
 the result is added at the beginning of S<h>. 
 
 Examples : 
 
 Let 
 
 S3 : °6°7 
 S5 . °-ii"a 
 
 Execution of the following instructions causes: 
 
 WORD B3, Z3 S3 : °6°7~6 
 
 WORD A 5 S5 : ~-ll~A 
 
 WORD Z5 result undefined 
 
 5 <> 1 . 8. Convert to number 
 
 <convert to number>: :=NUMBER u {A |B|z}<n>[ , {B|z}<m>] 
 
 If S<n> is empty , set H to minus. Otherwise, read one 
 constituent (which is supposed to be a word of the form <integer> 
 from S<h> (see 4.2.3»2.1.), convert it to a constituent of type number 
 whose value is given by the integer in S<n>, and add the result 
 to stack S<m> (see 4.3.2.2.2.). 
 
 If the second argument in the instruction is omitted then 
 the constituent obtained is added at the beginning of S<n>. 
 
 Examples : 
 
 Let 
 
 S3 : "+ll"A 
 S5 : "-07 - B 
 
 36 
 
Execution of the following instructions causes 
 
 NUMBER B3, B5 S5 : °11~-07~B 
 
 NUMBER A 5 S5 : °-7"b 
 
 5.1.9. Split 
 
 <split>::=SPLIT u {A |B|z)<n>[ , (A | B | Y|z}<5n>| 
 
 , [ (A|b|y|Z)<Si]>], {<number of steps>|<word test>} ] 
 
 If stack S<n> is empty, set H to minus. Otherwise, read from 
 S<n> one constituent (which is assumed to he a word) and form a 
 sequence of constituents each of which consists of a single character in 
 such a way that the first character of the constituent read forms 
 the first constituent in the new sequence, the second character forms 
 the second constituent, etc., until a termination criterion (specified 
 by the third argument) is satisfied. Then add this sequence of 
 constituents to S<m>. The first argument in the instruction specifies 
 the mode of reading from S<n> (see 4.2.3.2.1.). 
 
 The second argument specifies the mode of adding to S<m> the 
 sequence of constituents formed from the constituent which was split 
 (see 4.2.3.2.2.). If the second argument is omitted this sequence is 
 added to the beginning of S<n> (with order preserved). Thus a missing 
 second argument is equivalent to a second argument B<n>. 
 
 The third argument specifies the moment when splitting is 
 terminated. The word read from S<n> is treated as a sequence of 
 characters and the rules of reading of section 4.3.1. are applied. 
 If the third argument is absent, then the whole word is split. 
 
 Examples : 
 
 Let 
 
 SI : ~AB=3 _ CC 
 
 37 
 
Execution of the following instructions causes : 
 SPLIT Al SI : ~A~B~=~3~CC 
 
 SPLIT Bl, Zl, *1 SL : ~AB=3~CC~A 
 
 SPLIT Al,,'=' SI : "a"b"gC 
 
 5.1.10. Compress 
 
 <compress>: := COMPRESS u {A|B}<n>[ , {B |z}<m>| , [ {B Z}<m>], 
 {<num"ber of steps>|<word test>) ] 
 
 If S<n> is empty, set H to minus. Otherwise, read 
 successive constituents (all of which are assumed to be of type 
 word) from S<n>, concatenate these to form one new constituent of 
 type word, and add the result to S<m>. 
 
 The first argument specifies the mode of reading S<n> 
 (see 4.2.3.2.1. ). 
 
 The second argument specifies the mode of adding the result 
 to S<m>. The absence of this argument is equivalent to the case when 
 it is equal to B<n>. 
 
 The third argument, (or its absence) specifies the moment 
 when reading of constituents from S<n> is to be terminated., If it is 
 missing, then all constituents of S<n> are read. 
 
 5.1.11. Count 
 <count>; :=COUWT u [A |B}<n>[ , {B |z}<m>| , [{B|z)<m>] , Constituent test>] 
 
 If S<n> is empty set H to minus. Otherwise, read successive 
 constituents from S<n> and generate a constituent of the type number 
 whose value is equal to the number of constituents just read. Then 
 add this constituent to S<m>. 
 
 The first argument specifies the mode of reading constituents 
 from S<n> (see 4.2.3-2.1.). 
 
 38 
 
The second argument specifies the mode of adding the 
 resulting constituent to S<m> (see 4.2.3.2.2.). The absence of this 
 argument is equivalent to the case when it is equal to B<n>. 
 
 The third constituent (or its absence) specifies the moment 
 when reading of constituents from S<n> is to be terminated. 
 
 Examples : 
 
 Let 
 
 S3 : ~AY~BX~CZ 
 Sk : ° 3 °h 
 
 The instructions given below cause: 
 COUNT A3, Bk, 'BX f 
 
 COUNT Ah, , 5 
 
 S3 
 
 ; 
 
 BX CZ 
 
 sk 
 
 : 
 
 °1°3°4 
 
 sk 
 
 : 
 
 °2 
 
 H 
 
 : 
 
 - 
 
 S4 
 
 : 
 
 2°3°4 
 
 COUNT B4 
 
 5-2. Input instructions 
 
 <input instruction^ :={<read>|<clear input>|<test input>) 
 
 5-2.1. Read 
 
 <read>: :=READ u I<n>, (B |z}<m>[ , {<number of steps>|<word test}] 
 
 Read and delete successive characters from input I<h>, 
 concatenate these characters to form one word, and add this word 
 as one constituent to S<m>. The order of characters in the word 
 being formed is the same as the order in which they are read. 
 
 The second argument specifies the mode of adding to S<m> 
 the word which has been formed (see 4.2.3.2.2.). 
 
 39 
 
The third argument (or its absence) specifies the moment 
 when reading of input characters is to be terminated (see 4.3.1.). 
 
 Examples : 
 
 Let 
 
 11 
 
 : XI = 28; \ u H 
 
 S3 
 
 : "PQ H 
 
 H 
 
 : + 
 
 Execution of the instructions given below causes: 
 READ II, B3, *5 
 
 READ II, Z3, R 
 
 READ II, B3 * . ' 
 
 QQ . "vl - Oft. \ 
 
 11 
 
 ; *•■_, ~\ 
 
 S3 
 
 "XI = 28 "PQ 
 
 11 
 
 = 28; \ u -| 
 
 S3 
 
 "pq'xi 
 
 ii 
 
 H 
 
 S3 
 
 "XI = 28; X , 
 
 H 
 
 - 
 
 5.2.2. Clear input 
 <clear input>: :=CLEAR u l<n>[ , {<number of steps>|<word test>) ] 
 
 Read and delete successive characters from l<n>. 
 
 The second argument (or its absence) specifies the moment 
 when reading of input characters is to be terminated (see 4.3.1.). 
 
 Examples 
 
 Let 
 
 13 : X u u SKIP u -| 
 H : + 
 
 4o 
 
Execution of the instructions given "below causes: 
 
 CLEAR 13, 'SKIP' 13 : SKIP u H 
 
 CLEAR 13/ D 13 : H 
 
 H : - 
 
 5.2.3. Test input 
 
 <test input>: :=TEST p I<n>[,<vord test>] 
 
 If the second argument is present and I<n> Is not empty 
 then read without deletion one character from E<a> and regard it as 
 a word. If this word does not satisfy the relation defined by the 
 second argument set H to minus. 
 
 If the second argument is present and I<n> is empty, set H 
 to minus . 
 
 If the second argument is absent and I<n> is not empty 
 set H to minus . 
 
 If the second argument is absent and I<n> is empty then 
 nothing changes . Thus an input test with a missing second argument 
 tests whether an input is empty. 
 
 Examples ; 
 
 Let 
 
 II : XI = Ik H 
 
 15 : H 
 
 H : + 
 
 Execution of the following instructions causes: 
 
 TEST II, LR H : no change 
 
 TEST II H : - 
 
 TEST 15, LR H : - 
 
 TEST 15 H : no change 
 
5.3« Output instructions 
 
 <output instructions :={<write>|<set output> | <output format instruction^) 
 
 5.3.I. Write 
 
 <write>: :=WRITE u {A|B|Z)<n>, Q<3n>[ , {<number of steps>|<word test>} ] 
 
 Read successive constituents (all of which are assumed to be 
 of type word) from S<n> and add them one after another to the end of 
 output Q<m>, in the same order in which they occurred in S<n>. 
 
 The third argument (or its absence) specifies the moment 
 when reading of constituents from S<n> is to be terminated (see k.^.l). 
 
 Examples : 
 
 Let 
 
 ST : "Xl"="l3" u "\ -i 
 
 Q2 : RESULT u -j 
 
 Execution of the following instructions causes: 
 
 WRITE AT, Q2 S7 . _| 
 
 Q2 : RESULT u XI = 13 u \ 
 
 WRITE BT, 02, R Q2 : RESULT u XI 
 
 WRITE AT, Q2, *9 ST : -\ 
 
 Q2 : RESULT u XI = 13 u \ 
 H : - 
 
 5.3.2. Set output 
 
 <set output>: :=SET u Q<n>,<literal> 
 
 Add to the end of Q<n> the literal indicated by the second 
 argument . 
 
 k2 
 
Examples ; 
 
 Let 
 
 Q3 : X = H 
 
 Execution of the following instructions causes: 
 
 SET Q3, '13' Q3 : X = 13 H 
 
 SET Q3, 'UNDEF' Q3 : X = UNDEF H 
 
 5 • 3 • 3 • Output format instructions 
 
 <output format instruct ion>: : = [BLANK JUNE] PAGE} u Q<5n>,<number of steps> 
 
 Perform the indicated operation as many times as specified 
 by the second argument. 
 
 The instruction operators have the following meaning: 
 
 BLANK Put blank characters at the end 
 
 of Q<m> 
 
 LINE Skip to the beginning of a new 
 
 line on the output Q<m> 
 
 PAGE Skip to the beginning of a new 
 
 page on the output Q<m> 
 
 (The operators LINE and PAGE are dependent on the particular EOL 
 implementation' e.g., they may be defined only for the printer, not 
 for other output devices.) 
 
 If in the hardware representation the characters X and y 
 mean skipping to a new line or to a new page, respectively, then the 
 last two operators have the following meaning: 
 
 LINE Put the character X at the end 
 
 of Q<m> 
 
 PAGE Put the character y at the end 
 
 of Q<m> 
 
 ^3 
 
Example ; 
 
 Let 
 
 Q3 
 
 X = 10 H 
 
 Execution of the following instructions causes : 
 
 BLANK Q3, *k 
 LINE Q3, *2 
 
 Q3 
 
 x - 10 UUUU H 
 
 Q3 : X = 10 XX -i 
 
 (provided X means line feed 
 carriage return) 
 
 5.4. File instructions 
 
 <file instructions : = {<put>|<get>|<save>|<restore>| 
 
 <set into file>|<clear file>| 
 <test file>|<shift>|<shift and count>| 
 <copy>} 
 
 5.4.1. Put 
 
 <put>:;=PUT u {A|B|z)<n>, {c|D}<nx>[,{<number of steps>| Constituent test>) ] 
 
 Read successive constituent from S<n>, form one record of 
 them and place it in the file P<m>. 
 
 The first argument specifies the mode of reading S<h> 
 (see 4.2.3.2.1. ). 
 
 The second argument specifies the mode of adding to P<m> 
 the record consisting of the constituents which have "been read 
 (see 4.2.3.2.2.). 
 
 The third argument (or its absence) specifies the moment 
 when reading of constituents from S<n> is to be terminated (see 4.3.1.)° 
 
 44 
 
Example : 
 
 Let 
 
 K> : Vbt^c H 
 
 S3 : -A°3°8-l 
 
 Execution of the following instructions causes : 
 
 PUT B3, C2, *2 E2 : "Vbt "A^C -I 
 
 PUT A3, D2 P2 : v/ a v b v/ ~A°3°8t v/ C 
 
 S3 : H 
 
 5.4.2. Get 
 
 <get>::=GET u {C | D)<n>, [A |b | Y|z)<jii> 
 
 [,{<number of steps>| Constituent test>} ] 
 
 Read the record which follows directly the pointer in P<h>, 
 then read successive constituents from this record and add them to 
 S<m>. 
 
 The first argument specifies the mode of reading the 
 record from P<n> (see 4. 2. 3*2.1. ) . 
 
 The second argument specifies the mode of adding to S<m> the 
 constituents which have been read (see 4. 2. 3 .2. 2.). 
 
 The third argument (or its absence) specifies the moment 
 when reading of constituents from the record is to be terminated 
 (see 4.3.2. ). 
 
 Examples : 
 
 Let 
 
 P2 : N/ at N/ "A"B°3"c H 
 S3 : "XQ H 
 
 45 
 
Execution of the following instructions causes 
 
 GET C2, B2 
 
 GET D2, Y3, *2 
 
 P2 
 
 S3 
 
 P2 
 S3 
 
 at 
 
 'C -I 
 
 "A"B 3"XQ H 
 no change 
 
 "xq'b'a H 
 
 5.4.3' Save 
 
 <save>: :=SAVE u P<n> ; {b|z}<jti> 
 
 Read the current position of the pointer in file P<n> and 
 save it as a constituent of type address on stack S<m>. 
 
 The second argument specifies the mode of adding this 
 constituent to S<m> (see 4.2.3.2.2. ). 
 
 5.4.4. Restore 
 
 <restore>::=RESTORE u [ {A |B|z)<h>, ]P<m> 
 
 If the first argument is missing, place the pointer at the 
 "beginning of file P<m>. Otherwise, read one constituent (which is 
 assumed to be a pointer position) from S<n>, and place the pointer 
 into the position indicated by this constituent. If S<n> is empty, 
 set H to minus . 
 
 The first argument specifies the mode of reading the 
 constituent from S<n>. 
 
 Example : 
 
 Let 
 
 a b c at d 
 
 PI 
 
 S3 : C X 
 where C is the address of the record ^c. 
 
 46 
 
Execution of the following instruction causes 
 
 RESTORE PI PI : t v aVc v a v d 
 
 RESTORE B3, PI PI : ^Vbt v cVd 
 
 5.4.5. Set into file 
 
 <set into f ile>: :=SET u (C |D}<n>, {<integer>|<literal>|s*) 
 
 Add to the file P<n> the record specified by the second 
 argument. If the second argument is S*, the special record ^a is 
 added. If it is <integer> or <Literal>, a record composed of one 
 constituent only is added. <Integer> defines a constituent of type 
 number and <literal> a constituent of type word. 
 
 The first argument specifies the mode of adding the record 
 to P^i> (see 4.2.3.2.2.). 
 
 Example : 
 
 Let 
 
 PI : ^at^Vc 
 
 Execution of the following instructions causes 
 
 SET a, 3 PI : "'at^Vc 
 
 SET Dl, 'AB' PI : ^a^ABt v b v c 
 
 SET CI, S* PI : ^at^oVc 
 
 5,4.6. Clear file 
 
 <clear f ile>: :=CLEAR g P<n>[ , {<number of steps>|<record test>) ] 
 
 Read and delete successive records from P<n>, beginning at 
 the current pointer position. 
 
 47 
 
The second argument (or its absence) specifies the moment 
 when reading (and deleting) records from P<n> is to be terminated 
 (see 4.3-2.). 
 
 Example : 
 
 Let 
 
 P2 : at b c a d 
 
 H 
 
 Execution of the following instructions causes 
 
 CLEAR P2, *2 
 
 CLEAR P2, *3 
 
 CLEAR P2, R* 
 CLEAR P2 
 
 E2 
 
 : at c d 
 
 P2 
 
 : at d 
 
 H 
 
 : 
 
 P2 
 
 : "at^d -| 
 
 P2 
 
 : "at H 
 
 5.4.7. Test file 
 
 <test file>::=TEST u P<h>[ ,<record test>] 
 
 Test file P<n>, and if it does not satisfy the 
 
 relationship specified by the second argument (or its absence) 
 
 1 
 
 set H to minus . 
 
 The following cases can arise: 
 
 (a) If the second argument is missing, test whether 
 P<n> is empty (if not, set H to minus). 
 
 (b) If the second argument is a Constituent test>, 
 then test the first constituent of the record which 
 follows directly the pointer. If this constituent 
 does not satisfy the relationship, set H to minus. 
 
 (c) If the second argument is S*, test whether the record 
 which follows directly the pointer is v o. If not, 
 set H to minus. 
 
(d) If the second argument is R*, then test whether 
 
 the record which immediately precedes the pointer 
 is v o. If not, set H to minus. 
 
 Examples : 
 
 Let 
 
 PI : Vot "A°3 V C 
 
 Execution of the following instructions causes: 
 
 TEST PI, LD H : no change 
 
 TEST PI, 'B' H : - 
 
 TEST PI, R* H : no change 
 
 TEST PI, S* H : - 
 
 TEST PI H : - 
 
 5.4.8. Shift 
 
 <shift>::=SHIFT u P<n>[ , {<humber of steps>|<record test>}] 
 
 Shift the pointer in file P<h> forward. The moment of 
 stopping the pointer is specified by the second argument (or its 
 absence) in the same way as it is when reading the file (see 4.3*2.), 
 In the same circumstances the variable H is also given the value 
 minus . 
 
 Examples : 
 
 Let 
 
 where 
 
 PI : atDcdae-l 
 
 "ALFA°3 /X P ^ 
 
 h9 
 
while the first constituents in the records b and c are different 
 from ALFA. Then execution of the following instructions causes: 
 
 SHIFT PI, 'ALFA' 
 SHIFT PI, *10 
 
 SHIFT PI 
 
 PI 
 
 PI 
 H 
 
 PI 
 H 
 
 v V, sy . ss -\s s/ 
 
 a b ct d a e 
 
 a b c dt a e 
 
 V N/. SS \S , V N/ . 
 
 a b c d a et 
 
 no change 
 
 5.^.9. Shift and count 
 
 <shift and count>; :=SHTFTC u P<n>, {b|Z)<ju> 
 
 [,{<number of steps>|<record test>) ] 
 
 Shift the pointer in file P<n> forward. The moment of 
 stopping the pointer is specified by the third argument (or its 
 absence) in the same way as it is when reading a file (see 4.3.2.). 
 Add one constituent of type number, whose value is equal to the 
 number of records skipped by the file pointer, to S<m> in the mode 
 specified by the second argument (see k.2.3-2.2.) . 
 
 Example 
 
 Let 
 
 PI : at b c a d 
 
 S3 
 
 Al 
 
 Execution of the following instructions causes: 
 SHIFTC PI, B3, R* PI : VWot^d 
 
 SHIFTC PI, Z3 
 
 S3 
 
 PI 
 S3 
 
 Yai 
 
 V V, V v n/, a 
 
 a b c a dt 
 
 Al% 
 
 50 
 
5.4.10. Copy 
 <copy>: :=C0PY u (C| D}<n>, {c|D]<m>[, {<number of steps>|<record test>) ] 
 
 Read successive records in P<n> and add them to P<m>. 
 
 The first argument specifies the mode of reading records 
 from file P<n> (see 4.2.3.2.1. ). 
 
 The second argument specifies the mode of adding to 
 file P<m> the records which have "been read (see 4.2.3«2.2.). 
 
 The third argument (or its absence) specifies the moment 
 when the reading of records from P<n> is to be terminated (see 4.3.2), 
 
 Examples : 
 
 Let 
 
 PI : at b c a d H 
 
 P2 : pt q r H 
 
 Execution of the following instructions causes: 
 COPY CI, D2, *3 
 
 COPY Dl, C2, R* 
 
 COPY CI, C2 
 
 PI 
 
 ; 
 
 at ad i 
 
 P2 
 
 : 
 
 \/ \y \y . v v 
 
 P b ct q r 
 
 H 
 
 : 
 
 - 
 
 PI 
 
 * 
 
 a b c at d 
 
 P2 
 
 '• 
 
 V , \S V, V V 
 
 pt c b q r 
 
 PI 
 
 i 
 
 at 
 
 P2 
 
 • 
 
 pt d a c b q r 
 
 5*5' Jump instructions 
 
 <jump instruction>: : = {<simple jump>j Conditional jump>| 
 
 <switch jump>|<return>|<stop>} 
 
 51 
 
5.5-1- Simple jump 
 
 <s iraple jump>: : = {GOTO | CALL) u <label> 
 
 Go to the instruction indicated by <label>. CALL in 
 addition causes the address of the instruction in which this operator 
 occurs to be placed as one constituent of type address at the 
 beginning of the instruction address stack IAS. 
 
 5.5.2. Conditional jump 
 
 Conditional jump>: : = {GOMI |GOPL| CAMI |CAPL) u <label> 
 
 If the condition indicated by the operator of the instruction 
 is fulfilled then go to the instruction indicated by <label>. In 
 either case reset H to plus. 
 
 CAPL and CAMI in addition place the address of the 
 instruction in which these operators occur at the beginning of the 
 instruction address stack IAS. 
 
 The conditions indicated by the operators are: 
 
 Operators Condition 
 
 GOPL, CAPL value of H is plus 
 
 GOMI, CAMI value of H is minus 
 
 Example : 
 
 If the value of H is equal to minus, then the instruction 
 
 CAMI ALFA 
 
 causes placing the address of this instruction on top of the stack IAS, 
 going to the place of the program denoted by the label ALFA and 
 resetting the value of H to plus. 
 
 52 
 
5«5-3- Switch jumps 
 
 <switch jump>: :={GONA | GOIN | CAM | CAIN} ^ {A |B |Z}<n>,<label> 
 
 Read one constituent from S<n>, and use this constituent 
 to select a label from the label list of the switch indicated by 
 the second argument of the <switch jump>. Then go to the instruction 
 indicated by the label which was selected. In case of CANA and CAIN, 
 in addition place the address of this instruction <switch jump> at 
 the beginning^of IAS. 
 
 The first argument specifies the mode of reading the 
 constituent from S<n> (see 4-. 2. 3-2.1. ) . If S<n> is empty, set H to 
 minus and proceed. 
 
 The operator of the instruction specifies the type of switch 
 which is referred to by the second argument as follows : 
 
 GONA, CANA refer to a name switch (see 6.1.1.) and assume that the 
 
 constituent read from S<n> is a word. The label 
 
 selected from the label list of the switch is equal 
 to the word read from S<n>. • 
 
 GOIN, CAIN refer to an index switch (see 6.1.2.) and assume that the 
 constituent read from S<n> is a number,, The index 
 of the label selected from the label list of the 
 switch is equal to the absolute value of the number 
 read from S<n>. The index of the first label of the 
 label list is defined to be zero. 
 
 The process <of selecting a label from the label list of the 
 switch (see 6.1.1. and 6.1.2.) may fail because: 
 
 (1) stack S<n> is empty, or 
 
 (2) the word read from S<n> does not occur in the 
 
 label list of the name switch or the number read from S<ii> is outside 
 the range of legal indexes of the index switch. 
 
 53 
 
In both cases the switch jump is not executed, H is set to 
 minus and control proceeds to the instruction following this switch 
 jump. 
 
 Examples : 
 
 Assume a name switch KEY and an index switch LX are 
 declared as follows: 
 
 KEY : NAME FOR, IF, BEGIN, END 
 
 LX : INDEX LA, LB, LC 
 
 Let the values of stacks SI, S2, S3 and Sk be: 
 
 51 : Va°8 
 
 52 : - 
 
 53 : "BEGIN _ REAL"x 
 Sk : °-2°k 
 
 Then the switch jumps on the left have the same effect as the simple 
 jumps listed on the right below: 
 
 GOIN Bl, LX GOTO LA 
 
 CANA B3, KEY CALL BEGIN 
 
 CAIN B^, LX CALL LC 
 
 while the switch jumps CAIN Zl, LX and CAIN Z2, LX both set H to minus 
 5-5. 1 +. Return 
 
 <return>: :=RETURN 
 
 Read and delete the first constituent (which is assumed to 
 be an instruction address) from IAS, and go to the instruction which 
 
 ^ 
 
follows immediately the one whose address was just read. If the 
 instruction address stack IAS is empty, or if its first constituent 
 is not an instruction address, the outcome of RETURN is undefined. 
 
 5.5.5. Stop 
 
 <stop>: :=STOP 
 
 Stop program execution. 
 
 5-6. Table instructions 
 
 <table instruction^ :={<search>|<search and count>|<extract>} 
 
 5.6.1. Search 
 
 <search>: :=SEARCH u {A |B |z]<n>,<Label> 
 
 Read one constituent from S<n>. If the value of that 
 
 constituent is present on the list of the table or name switch 
 
 indicated by the second argument, leave H unchanged. Otherwise, 
 set H to minus. 
 
 The first argument of the instruction specifies the mode of 
 reading a constituent from S<n> (see h. 2. 3. 2.1.). 
 
 The second argument determines the label of the table or 
 name switch. 
 
 If the indicated table is of the type number table, then 
 the constituent read from S<h> is assumed to be a number. In the 
 case of a word table or name switch this constituent is assumed to be 
 a word. If these conditions are not satisfied, then the result of 
 the instruction is undefined. 
 
 55 
 
Examples : 
 
 Let 
 
 SWITCH 
 
 WORE/TABLE 
 
 NUMBERTABLE 
 
 SI 
 
 S2 
 
 : NAME A, B, C 
 
 TABLE 'A', 'B', 'C 
 TABLE '5, 7, 11 
 
 °7°12 
 "x°3~c 
 
 Execution of the following instructions causes 
 
 SEARCH Al, NUMBERTABLE 
 
 SEARCH Zl, NUMBERTABLE 
 
 SEARCH Z2, SWITCH 
 
 SEA I , WORDTABLE 
 
 SEARCH Bl, WORDTABLE 
 
 SI 
 
 : 12 
 
 H 
 
 : no change 
 
 H 
 
 ; 
 
 H 
 
 no change 
 
 H 
 
 : no change 
 
 result undefined 
 
 5.6.2. Search and count 
 
 <search and count>: :=SEARCHC u {A |B |z}<n>, [ : B jZ}<m>],<label> 
 
 Perform the instruction <search> using the first argument 
 and the <label>. If the search is successful then the index of the 
 first element in the list of the table or name switch which is 
 equal to the constituent read from S<n>, is added as one constituent 
 to S<m>. 
 
 The second argument specifies the mode of adding the 
 resulting constituent to S<m> (see k.2.^,.2.2.) . The absence of 
 this argument is equivalent to the case when it would be equal 
 to B<r. . 
 
 56 
 
Examples : 
 
 Let 
 
 KEY : TABLE 'IF', 'FOR', 'BEGIN', 'END' 
 SI : "FOR'REAL 
 
 S3 : 'index 
 
 Execution of the following instructions causes: 
 
 SEARCHC Bl, Z3, KEY S3 : "lNDEX°l 
 
 SEARCHC A1,,KEY SI : °1~REAL 
 
 SEARCHC Z1,,KEY H : - 
 
 5.6.3. Extract 
 
 <extract>-=EXTRACT u {A |b |z}<n>, [ {B|z)<m>],<label> 
 
 Read one constituent, which is assumed "to be a number, from 
 S<n>, and use the absolute value of this number as an index to extract 
 an element from the list of the table or name switch indicated by the 
 third argument. Then add this element as a constituent to S<m>. 
 The index of the first element in a list is zero. 
 
 The first argument specifies the mode of reading the 
 constituent from S<n> (see 4.2.3.2.1.). 
 
 The second argument specifies the mode of adding the resulting 
 constituent to S<m> (see 4. 2. 3*2. 2. ) . The absence of this argument 
 is equivalent to the case when it would be equal to B<h>. 
 
 The last argument determines the label of the table or 
 name switch. 
 
 The element extracted from a number table is added to S<m> 
 as a constituent of the type number. The element extracted from a 
 word table or name switch is added to S<m> as a constituent of the 
 type word. 
 
 57 
 
If the absolute value of the number read from S<n> is 
 greater than or equal to the number of elements in the tab] 
 name switch, then H is set fr aj as. 
 
 Examples t 
 
 Let 
 
 EX TABLE 'AB', 'BB*, I 1 , 'BZ', 'ZZ 1 
 
 S3 
 
 S5 : "DQ, 
 
 °3°12 
 
 The execution of the following instructions causes: 
 EXTRACT B.3, B5, EX S5 : "AZ"DQ 
 
 EXT PACT A3,, EX S3 I 
 
 EXTRACT Z3,,FX H 
 
 
 5« 7- Macro instructions 
 
 <macro instruction^ s=<macrc name> y <actual parameter list> X 
 
 <macro name>; s=<label> 
 
 <actual parameter list>; ;=[<actual param, f 
 
 [ ,<actual param ] . . ] 
 
 <actual parameter>: ; = { [<macro name continuation^ ]{<actual index>| 
 
 <formal index>) |<label>|<iiteral>} 
 
 A macro instruction calls for the insertion, at compilation 
 time, of the procedure bcdy of the macro definition which has the 
 same macro name and macro name continuations, with all formal parameters 
 bhe macro definition replaced by the corresponding actual parameters. 
 See section 7»3° on macro definitions. 
 
 actual parameter list in the macro inclusion statement 
 - be compatible with the formal parameter list of the macro 
 del m. I.e., the number of positions in both lists must be the 
 
 58 
 
same, identical macro name continuations must occur in corresponding 
 positions, and parameters of the same type (<index>, <label>, or 
 <Literai>) must occur in corresponding positions. 
 
 5.8. Code 
 
 <code>: ;=C0DE u [<n>, [<n>, ]]<label> 
 
 Go to the external procedure written in machine language 
 specified by the label which is the last argument of the instruction, 
 
 The two indexes <n> and <m> can be used to transmit 
 arguments to the external procedure. 
 
 Details of combining EOL and machine language programs are 
 necessarily dependent upon the particular computer installation 
 and, hence, must be defined separately for each implementation. 
 
 59 
 
6. DECLARATIONS 
 
 <declaration>: :={<switch>|<table>|<external declaration>| 
 <entry dec laration>|< index declaration^ ■ 
 
 6.1. Switches 
 
 <switch>: :={<name switch>|<index switch>} 
 
 6.1.1. Name switch 
 
 <name switch>: :={<Label>:} . .NAME u <Label list> 
 <label list>: ;=<label>[ ,<Label>] . . 
 
 Name switches are used by means of switch jumps described 
 in section 5«5°3° and by table instructions described in section 5-6. 
 
 Example of name switch : 
 
 ID : NAME A, AB, +, **, 3 
 
 6.1.2. Index switch 
 
 <index switch>: :={<label>: } . .INDEX u <label list> 
 
 Index switches are used by means of switch jumps described 
 in section 5 • 5 • 3 • 
 
 Example of index -switch ; 
 
 XI : INDEX Q, lH, ++ 
 
 6o 
 
6.2. Tables 
 
 <table>: :={<word table>|<number ta"ble>} 
 Tables are used by means of table instructions (see 5.6.). 
 
 6.2.1. Word table 
 
 <word table>: :={<label>: } . .TABLE u <Literal>[ ,<Literal>] . . 
 Example: 
 
 WT : TABLE 8 KEY% '/'; L*> "" 
 
 6.2.2. Number table 
 
 <number table>: :={<Label>: ) . .TABLE u <integer>[ ,<integer>] . . 
 Example : 
 
 NT : TABLE 3, 8, -6, + 12 
 
 6.3. Entry declaration 
 
 <entry declaration> : : = (<label>; } . .ENTRY 
 
 An entry declaration provides an alternative point of entry 
 into a procedure in addition to the normal entry through the procedure 
 name. See 7«^«3« on "the scope of label declarations. 
 
 6.k. External declaration 
 
 <extern>: : = {<La"bel>: } . .EXTERN[ u <comment string>] 
 
 An external declaration declares each of its labels to be 
 external to the external procedure in which this declaration occurs; 
 
 61 
 
i.e., that it is the name or an entry point of another external 
 procedure (see 7«1« on external procedures and 7«^«3« on the scope 
 of declarations). 
 
 6.5- Index declaration 
 
 <index declarations :={<formal index>: ) . .EQU u ''actual index> 
 
 An index declaration assigns an actual index to each one 
 of the formal indexes (see 7*3°) occuring in the declaration 
 (see 4.2.3»3«) everywhere within the scope of this declaration 
 (see 7.4.4. ). 
 
 62 
 
7- PROGRAMS, PROCEDURES, MACROS 
 
 7-1. Programs 
 
 <program>: :=[<macro-def inition>] . . 
 
 [<external procedure>] . . 
 <external procedure>: :=<procedure> 
 
 A program consists of a sequence of macro-definitions 
 followed by a sequence of external procedures. An external procedure 
 is a procedure which is not contained within any other procedure- 
 It is intended that in EOL implementations each macro-definition alone 
 and each external procedure along with all the macro-definitions 
 which are included in this external procedure forms a unit which can 
 be compiled separately, independently of any other part of the program. 
 
 7.2. Procedure and statement 
 
 <procedure>: : = {<procedure name>: } . . (MAIN] PROC} [ ,_, <comment string>] \ 
 <procedure body>ENPf ,_, <comment string>] X, 
 
 <procedure name>: :=<label> 
 
 <procedure body>: : = [<statement> A.].. 
 
 <statement>: : = { [<label>: ] . .<instruetion>|<declaration>| 
 <procedure>|<comment>] 
 
 In each program exactly one procedure should be distinguished 
 by the key word MAIN (usually, but not necessarily, an external 
 procedure). Program execution starts with this procedure (see 7-5-)" 
 
 Notice that the definition of procedure is recursive, hence 
 procedures may be nested. Instructions and declarations are the 
 subject of section 5. and 6., respectively. 
 
 63 
 
7.2.1. Comments 
 
 <comment>: :={ COMMENT | C) u <comment string> 
 
 <comment string>: :=<an arbitrary sequence of characters 
 
 that does not begin with ":" and does 
 not contain X> 
 
 Comments have no effect on program execution. They are used only 
 for explanations. 
 
 7.3. Macro definition 
 
 <macro def inition>: :={<macro name>: } „ .MACRO u <formal parameter list> X 
 
 <procedure body>END[ u <comment string>] X 
 
 <macro name>: :=<label> 
 
 <formal parameter list>: :=[<formal parameter>[ ,<f ormal parameter>] . . ] 
 
 <formal parameters. :={ [<macro name continuation> ! ]<formal index>j 
 
 <formal label>|<f ormal literal>} 
 
 <macro name continuations ;=<letter>[<letter>|<digit>] . . 
 
 <formal index>: :=<letter>[<letter>|<digit>] , , 
 
 <f ormal labels :=<label> 
 
 <f ormal literal>: :=<literal> 
 
 Macro-definitions cause the definition of a program section 
 in which <formal index>, <formal label> or <formal literal> can occur, 
 only those, however, which are in <f ormal parameter list> of this macro 
 definition. A <macro instruction> (see 5°7«) will insert this section 
 into the program before execution begins. The name of a macro-definition 
 can be extended by <macro-name continuations Thus two macro-definitions 
 of the same name can be totally different when their names have 
 different continuations. 
 
 6k 
 
Macro name continuations may be used in an analogous role 
 as the mode symbols A, B, Y, Z, etc, play in many instructions, 
 such as MOVE. 
 
 Examples : 
 
 ABC : MACRO LA, 'X', S'K 
 SET B'K, 
 GOMI LA 
 RETURN 
 END 
 
 QX : MACRO SZ'P, L, EX 
 CLEAR I ! L 
 ABC EX, ! + ! , S ! P 
 END 
 
 The second macro definition contains a macro instruction 
 (see 5=7') referring to the first macro-definition ABC, hence at 
 compilation time a copy of the procedure body of the first (inner) 
 macro-definition is inserted in place of the macro instruction 
 occurring in the second (outer) macro-definition. 
 
 In such cases of macro instructions that occur in macro- 
 definitions, replacement of actual for formal parameters proceeds 
 by passing parameters from outer to inner macros. 
 
 Example : 
 
 Let us suppose that macros ABC and QX are defined according to the 
 examples above. Then the macro instructions given below on the 
 left are replaced as indicated on the right: 
 
 ABC E, 'ALFA 1 , S'l SET Bl, 'ALFA' 
 
 GOMI E 
 RETURN 
 
 65 
 
L : PROC 
 
 ABC, E, 'B', S'T 
 END 
 
 QX SZ'3, 4, X 
 
 and then by 
 
 PROC 
 
 B'T, 'B 1 
 GOM.' 
 RETURN 
 END 
 
 i 
 
 ' ■-', S'3 
 
 CLEAR I k 
 SET B3, '+' 
 
 GOMI X 
 RETURN 
 
 7 . h . Block structure and the scope of declarations 
 
 7.4.1, 
 
 Procedures 
 
 external and internal 
 
 EOL uses the concepts of external procedures and of nested 
 block structure of PL/1 [^-]. The main purpose of these concepts 
 is to allow separate compilation of external procedures, and, 
 within an external procedure, to delimit the pe of a declaration 
 of an identifier to only those parts of a program where this 
 identifier is used. This allows the same identifier (in the case 
 of EOL: a label or a formal index) to denote different quantities 
 in different parts of a program. 
 
 An EOL procedure is defined by an occurrence of the symbol 
 PROC or MAIN and the corresponding occurrence of the symbol END 
 (see 7.2.). The <procedure body> which occurs between the symbols 
 PROC or MAIN and END that define a procedure P is said to be the 
 content of P, and any part of this procedure body is said to be 
 contained in P. 
 
 A procedure which is not contained in any other procedure 
 (i.e., an "outermost" one) is an external procedure , and its 
 procedure name as well as all its entry points are external labels . 
 
 66 
 
Any other procedure is an internal procedure . 
 
 That part of the content of a procedure P that is not 
 contained in any other procedure contained in P is said to be 
 internal to P, and is called the interior of P. 
 
 7.4.2. Declaration of labels 
 
 A label is declared by occurring at the left of an EOL 
 statement, i.e. an instruction, declaration or procedure. Occurrence 
 on the right of a statement represents use of the label, not a 
 declaration. 
 
 The name(s) of an external procedure and all its entry points 
 (i.e. all the labels of entry declarations (see 6,3.) that occur in the 
 interior of an external procedure are external labels. All other 
 labels are internal. 
 
 7.4.3' Scope of a declaration of a label 
 
 The scope of a declaration of an external label is the content 
 of the external procedure whose name or entry point this label is, 
 excluding the contents of all procedures contained in (or equal to) 
 this external procedure in whose interior another declaration of the 
 s ame label occurs . 
 
 The scope of any declaration other than an entry declaration 
 of an internal label is defined as the content of that procedure P 
 to which the declaration is internal, excluding the contents of all 
 procedures contained in P in whose interior another declaration of the 
 same label occurs. The scope of an entry declaration of a label L 
 is the same as if X had been declared to be a name of the procedure 
 in whose interior this entry declaration occurs. 
 
 Anywhere within the scope of a declaration D of a label L, 
 use of L refers to the same label, namely the one declared by D. 
 If D is an external declaration (see 6.4.), then use of L refers to 
 the external procedure whose name is L or which has an entry point L. 
 
 67 
 
A procedure name or entry point L of an external procedure 
 can be referred to from another external procedure provided the place 
 from which reference is made lies within the scope of an <external 
 declaration> of the label L. 
 
 "J.k.h. Scope of an index declaration 
 
 The scope of an index declaration (see 6.5.) is the content of 
 that procedure P to which this declaration is internal, with the 
 exclusion of the contents of all procedures contained in P in whose 
 interior another declaration of the same formal index occurs. 
 
 7.4„5- Use of labels and formal indexes 
 
 Every use of a label or formal index must lie within the 
 scope of exactly one declaration of that label or formal index, 
 respectively. Otherwise, that label or formal index will be either 
 undefined or multiply defined. There is no interaction between labels 
 and formal indexes, i.e. it is possible that the declarations of a 
 label X and of a formal index X have overlapping scopes. 
 
 For compilation of an external procedure the above requirement 
 on the use of labels is sufficient. For successful execution of a 
 program, on the other hand, it is required in addition that if a label 
 L occurs in an external declaration, then there exists in the program 
 an external procedure whose name is L or which has an entry point L. 
 
 68 
 
7.^.6. Example 
 
 Arrows indicate the declaration referred to "by each 
 use of a label. 
 
 X 
 
 A 
 
 M 
 
 X 
 
 PROC 
 
 EXTERN M 
 
 GOMI M 
 
 CALL X 
 
 GOTO A 
 END 
 
 MAIN 
 
 * 
 
 PROC 
 
 # 
 END 
 
 PROC 
 
 EXTERN X 
 
 CALL X 
 
 * 
 END 
 
 PROC 
 
 CALL 
 
 t 
 < 
 * 
 
 END 
 END 
 
 X 
 
 41 
 
 * — 
 
 
 
 
 !Z) 
 
 7«5 • Flow of control in a program 
 
 Execution of a program begins with the first instruction 
 that is internal to the procedure declared to be MAIN (see 7-2. ). 
 With the exeception of jump instructions (see 5.5.); which specify 
 their successor explicitly, control always passes to the next 
 instruction that is internal to the same procedure as the present 
 instruction is. This means that all declarations and all procedures 
 contained in the procedure in whose interior control is at present 
 
 69 
 
are skipped in the process of execution, and that the only way of 
 entering or leaving a procedure is by means of a jump instruction. 
 If the last instruction is the interior of a procedure is not a 
 jump, or is a conditional jump whose condition is not satisfied, then 
 the successor of this instruction is not defined. 
 
 In the example below the label of each instruction coincides 
 with the order in which the program is executed. 
 
 
 MAIN 
 
 
 X 
 
 : PROG 
 
 
 3 
 
 : MOVE Al, 
 
 Z2, *1 
 
 k 
 
 : RETURN 
 END 
 
 
 T 
 
 ; TABLE 'A 
 
 1 I'D 1 
 
 j B > 
 
 1 
 
 : READ 17, 
 
 Bl, B 
 
 2 
 
 : CALL X 
 
 
 5 
 
 : WRITE Z2 
 
 , Q6 
 
 N 
 
 TABLE 1, 
 
 2, 3 
 
 6 
 
 STOP 
 END 
 
 
 70 
 
BIBLIOGRAPHY 
 
 [1] Newell, A. et al., "information Processing Language-V Manual/' 
 second edition, Prentice Hall 196k. 
 
 [2] "COMIT Programmers Reference Manual/' MIT Press 1962. 
 
 [3] Naur, P. et al., "Revised Report on the Algorithmic Language 
 ALGOL 60," Comm. ACM, Vol, 6, No. 1, pp. 1-17; January I963. 
 
 [k] "PL/l: Language Specifications," IBM Systems Reference 
 Library, Form C28-6571-2; January I966. 
 
 [5] Lukaszewicz, L., "EOL^\. Symbol Manipulation Language," 
 
 The Computer Journal, Vol. 10, No. 1, pp. 53-59; May 1967. 
 
 [6] Lukaszewicz, L., "Outline of EOL Language," File No. 733> 
 Department of Computer Science, University of Illinois; 
 June 1967. 
 
 [7] Lukaszewicz, L., Nievergelt, J., "EOL Programming Examples — A 
 Primer," Report No. 2J+2, Department of Computer Science, 
 University of Illinois jj September 19^7 • 
 
 [8] "The EOL Compiler," File No. , Department of Computer Science, 
 
 University of Illinois; to appear. 
 
 [9] "The EOL Interpreter," File No. , Department of Computer 
 
 Science, University of Illinois; to appear. 
 
 [10] Lukaszewicz, L., "Language XI,", File No. 73^, Department of 
 Computer Science, University of Illinois; June 19^7 • 
 
 71 
 
APPENDIX I. SUMMARY OF EOL SYNTAX 
 
 1. Programs, Procedures, Macro-definitions 
 
 <program>: :=[<macro-def inition>] . . [<external procedure>] . . 
 
 <macro-definition>: :={<Iabel>: }. .MACRO u <£ ormal parameter list> K 
 
 <procedure "body> END [ jj <comment string>] X 
 
 <external procedure>: :=<procedure> 
 
 <procedure>: :={<label>:} . . {PROC|MAIN) [ u <comment string>] A 
 <procedure body> END [ u <comment string>] \ 
 
 <procedure body>: :=[<statement> \] . . 
 
 2. Statements 
 
 <statement>: :={[<label>: ]. .<instruction>| 
 <declaration>| 
 <procedure>| 
 <comment>} 
 
 Instructions 
 
 <instruction>: :={<stack instruction>j 
 <input instruction>j 
 <output instruct ion>) 
 <file instruction>| 
 <jump instruction>| 
 <table instruction>j 
 <macro instruction>| 
 <code>) 
 
 72 
 
k. Declarations 
 
 <dec larat ion> : : = { <swi t ch> | <ta"b le> | 
 
 external declaration>| 
 Cntry dec larat ion>| 
 <index declaration>) 
 
 5 . Comments 
 
 <comment>: :=C[OMMENT] u <comment string> 
 
 <comment string>: :=<an arbitrary sequence of characters starting 
 
 with a character different from : and where 
 the character X does not occur> 
 
 6. Stack instructions 
 
 MOVE u {A|B|z}<n>, {A |b | Y|z]<m>[ , {<number of steps>| 
 
 Constituent test>) ] 
 
 EXCHANGE u (B<n>|lAS}, {BCi>|lAS} 
 
 SET u {B|z}<n>, {<integer>|<literal} 
 
 CLEAR u A<n>[ , [Cumber of steps>j Constituent test>} ] 
 
 TEST u {A [B|z)<h>[, Constituent test>] 
 
 (ADD | SUB | MULT | DIV} u [A |b |z}<n>, [ {B |z}<n>] , {<integer>| (B |z}<k» 
 
 WORD u {A|B|z}<n>[,{B|z}<m>] 
 
 NUMBER u {a|b|z]0[, {B|z}<m>] 
 
 SPLIT u {A|B|z)<n>[,{A|B|Y|z)<m>| 
 
 , [ (a|b| Y|z)<m>], {<number of steps>|<word test>) ] 
 
 COMPRESS u {A|B)<n>[, [b|z}o| 
 
 , [{B|z}<m>], {<number of steps>|<word test>)] 
 
 COUNT u {A|B}<n>[, {B|z}<m>| , [{B|z)<m>], Constituent test>] 
 
 73 
 
7- Input instructions 
 
 READ u I<h>, {B|Z}<m>[, {<number of steps>|<word test>} ] 
 CLEAR p I<n>[, {<number of steps>|<word test>] ] 
 TEST u I<n>[,<word test>] 
 
 8. Output instructions 
 
 WRITE u {A|B|Z}<n>, Q<m>[, {<number of steps>|<word test>) ] 
 
 SET u Q<n>, <literal> 
 
 BLANK u Q<n>, <number of steps> 
 
 LINE u Q<n>, <number of steps> 
 
 PAGE u Q<n>, <number of steps> 
 
 9» File instructions 
 
 PUT u {A|B|z)<n>, {c|D)<hi>[,{<humber of steps>| Constituent test>) ] 
 
 GET u {c|D}<n>, {A | B| Y| Z)<m>[ , {<number of steps>| Constituent test>) 
 
 SAVE u P<n>, {BJZ}<m> 
 
 RESTORE u [{a|b|z)<ti>, ] P<m> 
 
 TEST u P<n>[,<record test>] 
 
 SHIFT u P<n>[, {<number of steps>|<record test>} ] 
 
 SHIFTC u P<n>, [B|z]<m>[, {<number of steps>|<record test>} ] 
 
 SET u {c|D}<n>, {<integer>|<literal>|s*} 
 
 CLEAR u C<n>[ , (<n umber of steps>|<record test>) ] 
 
 COPY u {c|D)<n>, {c|D)<m>[,{<number of steps>|<record test>} ] 
 
 lh 
 
10. Jump instructions 
 
 {GOTO | CALL | GOMI |G0PL | CAMI | CAPL} u <label> 
 {G0NA|G0IN|cANA|cALN) u {a|b|z)<ti>, <label> 
 RETURN 
 STOP 
 
 11. Table instructions 
 
 SEARCH u { A | B | Z } <n>, <labe 1> 
 
 SEARCHC (j {A|B|z)<n>,[{B|z)<m>], <label> 
 
 EXTRACT y {A| b| Z)<n>, [ {b| Z)<m>] , <label> 
 
 12. Macro instructions 
 
 <macro instruction>: :=<label> [_i <actual parameter list> 
 
 13- Code 
 
 <code>: :=C0DE j [<h>, [<ra>, ] ]<label> 
 
 Ik. Switches 
 
 {<label>: } . . {NAME | INDEX} u <label>[ ,<label>] . . 
 
 15. Tables 
 
 {<label>: }. .TABLE y {<literal> [,<Literal>] . . | 
 
 <integer> [ , <integer>] . . } 
 
 16. External declarations 
 
 {<label>:}. .EXTERN [ u <comment string>] 
 
 75 
 
17- Entry declaration 
 
 {<label>:). .ENTRY [ u <comment string>] 
 
 18. Index declarati 
 
 on 
 
 {<forraal index>: ) . .EQU u <actual index> 
 
 19. Labels 
 
 <label>: :=<a non-empty sequence of characters different from 
 
 ( u \,\'.V-)> 
 
 20. Literals 
 
 <literal>: :={ '<any string of characters with the restriction 
 
 that quotation marks can occur only in adjacent 
 pairs. Such a pair inside the literal denotes 
 one quotation mark>' |{L|g}*) 
 
 21. Indexes 
 
 <actual index>: : = (0|l|2 I . . . |31} 
 
 <formal index>: :=<letter>[<letter>|<digit>] 
 
 22. Abbreviation for indexes 
 {<n>|^n>|<k>) : :=<index> 
 
 23. Special symbols 
 
 <special symbol>: : = (l|g |s |R}* 
 
 76 
 
2k. Tests 
 
 <record test>: : = {<constitutent test>| (s|r)*} 
 
 Constituent test>: :={<word test>|<number test>|<address test> 
 
 <word test>: : = {<class>| [PR|PE|FL| FE>/] { {b|z |T}<k>|<literal>} } 
 
 <number test>: :=[ {LT |LE|GT |gE}/] { {B |z |T}<k>|<integer>} 
 
 <address test>: :={B|Z |T)<k> 
 
 <class>::=[L] [D] [B] [R] 
 
 25. Number of steps 
 
 <number of steps>: :=*{<integer>| {B|z}<k>} 
 
 26. Integers 
 
 <integer>: :=[+ | -] {digit} . . 
 
 27. Parameter lists 
 
 <formal parameter list>: : = [<formal parameter>[ _,<formal parameter>] . . ] 
 <actual parameter list>: :=[<actual parameter>[ ,<actual parameter>] . . ] 
 
 28. Formal parameters 
 
 <formal parameter>: :={ [<macro name continuation^ ]<formal index>| 
 
 <formal label>|<formal literal>} 
 
 <macro name continuations :=<letter> [<letter>|<digit>] . . 
 
 <formal label>: :=<label> 
 
 <formal literal>: :=<literal> 
 
 29. Actual parameters 
 
 <actual parameter>: :=([<macro name continuation>' ] {<actual index>| 
 
 <formal index>} j<label>|<literal>} 
 77 
 
APPENDIX II. INDEX OF TbRMS 
 
 A 
 
 A 
 
 ACTUAL INDEX 
 
 ACTUAL PAKAMPT^R 
 
 ACTUAL PARAMETER L I r : 
 
 ADD 
 
 ADDING 
 
 ADDRESS 
 
 ADDRESS 
 
 ADDRESS TEST 
 
 ADDRESS TEST 
 
 ARGUMENT 
 
 ARITHMETIC INSTRUCTI 
 
 B 
 
 B 
 
 B 
 
 B 
 
 BASIC SYMBOL 
 
 BLANK 
 
 BLOCK STRUCTURE 
 
 C 
 
 C 
 
 c 
 
 CAIN 
 
 CALL 
 
 CAMI 
 
 CANA 
 
 CAPL 
 
 CHARACTER 
 
 CHARACTER STRING 
 
 CLASS 
 
 CLASS LETTER 
 
 CLEAR FILE 
 
 CLEAR INPUT 
 
 CLEAR STACK 
 
 CODE 
 
 COMMENT 
 
 COMMENT STRING 
 
 COMPRESS 
 
 CONDITIONAL JUMP 
 
 CONSTITUENT 
 
 CONSTITUENT COMPARED 
 
 CONSTITUENT TEST 
 
 CONTAINED 
 
 CONTENT 
 
 CONVERT TO NUMBER 
 
 CONVERT TO WORD 
 
 COPY 
 
 ST 
 
 4. 
 
 2. 
 
 3. 
 
 2. 
 
 1 
 
 4. 
 
 2. 
 
 3. 
 
 2. 
 
 2 
 
 4. 
 
 2. 
 
 3. 
 
 3 
 
 
 5. 
 
 7 
 
 
 
 
 5. 
 
 7 
 
 
 
 
 5. 
 
 1. 
 
 6 
 
 
 
 4. 
 
 2. 
 
 3. 
 
 2. 
 
 2 
 
 1. 
 
 2. 
 
 2 
 
 
 
 3. 
 
 3. 
 
 3 
 
 
 
 4. 
 
 2. 
 
 4. 
 
 2 
 
 
 4. 
 
 2. 
 
 4. 
 
 2. 
 
 5 
 
 4. 
 
 2 
 
 
 
 
 5. 
 
 1. 
 
 6 
 
 
 
 4. 
 
 2. 
 
 3. 
 
 2. 
 
 1 
 
 4. 
 
 2. 
 
 3. 
 
 2. 
 
 2 
 
 4. 
 
 2. 
 
 3. 
 
 2. 
 
 3 
 
 4. 
 
 2. 
 
 4. 
 
 2. 
 
 1 
 
 2 
 
 
 
 
 
 5. 
 
 3. 
 
 3 
 
 
 
 7. 
 
 4 
 
 
 
 
 4. 
 
 2. 
 
 3. 
 
 2. 
 
 1 
 
 4. 
 
 2. 
 
 3. 
 
 2. 
 
 2 
 
 7. 
 
 2. 
 
 1 
 
 
 
 5. 
 
 5. 
 
 3 
 
 
 
 5. 
 
 5. 
 
 1 
 
 
 
 5. 
 
 5. 
 
 2 
 
 
 
 5. 
 
 5. 
 
 3 
 
 
 
 5. 
 
 5. 
 
 2 
 
 
 
 2. 
 
 1 
 
 
 
 
 3. 
 
 1 
 
 
 
 
 4. 
 
 2. 
 
 4. 
 
 2. 
 
 1 
 
 4. 
 
 2. 
 
 4. 
 
 2. 
 
 1 
 
 5. 
 
 4. 
 
 6 
 
 
 
 5. 
 
 2. 
 
 2 
 
 
 
 5. 
 
 1. 
 
 4 
 
 
 
 5. 
 
 8 
 
 
 
 
 7. 
 
 2. 
 
 1 
 
 
 
 7. 
 
 2. 
 
 1 
 
 
 
 5. 
 
 1.10 
 
 
 
 5. 
 
 5. 
 
 2 
 
 
 
 3. 
 
 3 
 
 
 
 
 4. 
 
 2. 
 
 4. 
 
 2. 
 
 4 
 
 4. 
 
 2. 
 
 4. 
 
 2 
 
 
 7. 
 
 4. 
 
 1 
 
 
 
 7. 
 
 4. 
 
 1 
 
 
 
 5. 
 
 1. 
 
 8 
 
 
 
 5. 
 
 1. 
 
 7 
 
 
 
 5. 
 
 4.10 
 
 
 
 78 
 
COUNT 
 
 D 
 
 D 
 
 D 
 
 DECLARATION 
 
 DECLARATION OF FORMAL INDEXES 
 
 DECLARATION OF LABELS 
 
 DELIMITER 
 
 DIGIT 
 
 DIV 
 
 ENTRY 
 
 ENTRY DECLARATION 
 
 EQU 
 
 EXCHANGE 
 
 EXTERN 
 
 EXTERNAL DECLARATION 
 
 EXTERNAL LABEL 
 
 EXTERNAL PROCEDURE 
 
 EXTERNAL PROCEDURE 
 
 EXTRACT 
 
 FE 
 
 FILE 
 
 FILE 
 
 FILE INSTRUCTION 
 
 FILE VALUE 
 
 FL 
 
 FLOW OF CONTROL 
 
 FORMAL INDEX 
 
 FORMAL INDEX 
 
 FORMAL LABEL 
 
 FORMAL LITERAL 
 
 FORMAL PARAMETER 
 
 FORMAL PARAMETER LIST 
 
 G* 
 
 GE 
 
 GET 
 
 GOIN 
 
 GOMI 
 
 GONA 
 
 GOPL 
 
 GOTO 
 
 GT 
 
 H LOGICAL REGISTER 
 
 I 
 
 IAS 
 
 INDEX 
 
 INDEX 
 
 INDEX DECLARATION 
 
 INDEX SWITCH 
 
 INDEXED MODE SYMBOL 
 
 INITIAL VALUES 
 
 INPUT 
 
 INPUT 
 
 INPUT INSTRUCTION 
 
 INPUT VALUE 
 
 INSTRUCTION 
 
 INSTRUCTION ADDRESS 
 
 5. 1.11 
 
 
 
 4. 2. 3. 
 
 2. 
 
 1 
 
 4. 2. 3. 
 
 2. 
 
 2 
 
 4. 2. 4. 
 
 2. 
 
 1 
 
 6 
 
 
 
 6. 5 
 
 
 
 7. 4. 2 
 
 
 
 2. 1. 3 
 
 
 
 2. 1. 2 
 
 
 
 5. 1. 6 
 
 
 
 6. 3 
 
 
 
 6. 3 
 
 
 
 6. 5 
 
 
 
 5. 1. 2 
 
 
 
 6. 4 
 
 
 
 6. 4 
 
 
 
 7. 4. 1 
 
 
 
 7. 1 
 
 
 
 7. 4. 1 
 
 
 
 5. 6. 3 
 
 
 
 4. 2. 4. 
 
 2. 
 
 2 
 
 1. 2. 5 
 
 
 
 3. 4 
 
 
 
 5o 4 
 
 
 
 3. 4 
 
 
 
 4 o 2 * 4. 
 
 2. 
 
 2 
 
 7. 5 
 
 
 
 4. 2. 3. 
 
 3 
 
 
 7. 3 
 
 
 
 7. 3 
 
 
 
 7. 3 
 
 
 
 7. 3 
 
 
 
 7. 3 
 
 
 
 4. 2. 1 
 
 
 
 4. 2. 4. 
 
 2. 
 
 3 
 
 5. 4. 2 
 
 
 
 5. 5. 3 
 
 
 
 5. 5. 2 
 
 
 
 5. 5. 3 
 
 
 
 5. 5. 2 
 
 
 
 5. 5. 1 
 
 
 
 4. 2. 4. 
 
 2. 
 
 3 
 
 1. 2. 4 
 
 
 
 4. 2. 3. 
 
 2. 
 
 1 
 
 1. 2. 3 
 
 
 
 4. 2. 3. 
 
 3 
 
 
 6. 1. 2 
 
 
 
 6. 5 
 
 
 
 6. 1. 2 
 
 
 
 4. 2. 3 
 
 
 
 3. 6 
 
 
 
 1. 2. 1 
 
 
 
 3. 1 
 
 
 
 5. 2 
 
 
 
 3. 1 
 
 
 
 5 
 
 
 
 3. 3. 3. 
 
 1 
 
 
 79 
 
INSTRUCTION ADDRESS STACK 
 
 INSTRUCTION ADDRESS STACK 
 
 INTEGER 
 
 INTEGER 
 
 INTERIOR 
 
 INTERMEDIATE LIST 
 
 INTERNAL 
 
 INTERNAL PROCEDURE 
 
 JUMP INSTRUCTION 
 
 K 
 
 L 
 
 L* 
 
 LABEL 
 
 LE 
 
 LETTER 
 
 LINE 
 
 LITERAL 
 
 LOGICAL REGISTER H 
 
 LOGICAL VALUE 
 
 LT 
 
 M 
 
 MACRO DEFINITION 
 
 MACRO INSTRUCTION 
 
 MACRO NAME 
 
 MACRO NAME 
 
 MACRO NAME CONTINUATION 
 
 MAIN 
 
 MARKER 
 
 MODE OF ADDING 
 
 MODE OF READING 
 
 MODE OF TESTING 
 
 MODE SYMBOL 
 
 MOVE 
 
 MULT 
 
 N 
 
 NAME 
 
 NAME SWITCH 
 
 NORMAL RECORD 
 
 NUMBER 
 
 NUMBER 
 
 NUMBER OF STEPS 
 
 NUMBER TABLE 
 
 NUMBER TEST 
 
 NUMBER TEST OPERATOR 
 
 OPERATOR 
 
 OUTPUT 
 
 OUTPUT 
 
 OUTPUT FORMAT INSTRUCTION 
 
 OUTPUT INSTRUCTION 
 
 OUTPUT VALUE 
 
 PAGE 
 
 PE 
 
 POINTER 
 
 POINTER POSITION 
 
 PR 
 
 PRECEDENCE OF CHARACTERS 
 
 PRECEDENCE OF WORDS 
 
 1. 
 
 2. 
 
 3 
 
 
 3. 
 
 3. 
 
 5 
 
 
 3. 
 
 3. 
 
 2 
 
 
 4. 
 
 2. 
 
 2 
 
 
 7. 
 
 4. 
 
 1 
 
 
 4. 
 
 2. 
 
 3. 
 
 1 
 
 7. 
 
 4. 
 
 1 
 
 
 7. 
 
 4. 
 
 1 
 
 
 5. 
 
 5 
 
 
 
 4. 
 
 2. 
 
 3. 
 
 3 
 
 4. 
 
 2. 
 
 4. 
 
 2. 1 
 
 4. 
 
 2. 
 
 1 
 
 
 4. 
 
 2. 
 
 5 
 
 
 4. 
 
 2. 
 
 4. 
 
 2. 3 
 
 2. 
 
 1. 
 
 1 
 
 
 5. 
 
 3. 
 
 3 
 
 
 4. 
 
 2. 
 
 1 
 
 
 1. 
 
 2. 
 
 4 
 
 
 3. 
 
 5 
 
 
 
 4. 
 
 2. 
 
 4. 
 
 2. 3 
 
 4. 
 
 2. 
 
 3. 
 
 3 
 
 7. 
 
 3 
 
 
 
 5. 
 
 7 
 
 
 
 5. 
 
 7 
 
 
 
 7. 
 
 3 
 
 
 
 7. 
 
 3 
 
 
 
 7. 
 
 2 
 
 
 
 2. 
 
 2 
 
 
 
 4. 
 
 2. 
 
 3. 
 
 2. 2 
 
 4. 
 
 2. 
 
 3. 
 
 2. 1 
 
 4. 
 
 2. 
 
 3. 
 
 2. 3 
 
 4. 
 
 2. 
 
 3. 
 
 2 
 
 5. 
 
 1. 
 
 1 
 
 
 5. 
 
 1. 
 
 6 
 
 
 4. 
 
 2. 
 
 3. 
 
 3 
 
 6. 
 
 1. 
 
 1 
 
 
 6. 
 
 1. 
 
 1 
 
 
 1. 
 
 2. 
 
 5 
 
 
 1. 
 
 2. 
 
 2 
 
 
 3. 
 
 3. 
 
 2 
 
 
 4. 
 
 2. 
 
 4, 
 
 1 
 
 6. 
 
 2. 
 
 2 
 
 
 4. 
 
 2. 
 
 4. 
 
 2 
 
 4. 
 
 2. 
 
 4, 
 
 2. 3 
 
 4. 
 
 1 
 
 
 
 1. 
 
 2. 
 
 1 
 
 
 3. 
 
 2 
 
 
 
 5. 
 
 3. 
 
 3 
 
 
 5. 
 
 3 
 
 
 
 3. 
 
 2 
 
 
 
 5. 
 
 3. 
 
 3 
 
 
 4. 
 
 2. 
 
 4. 
 
 2. 2 
 
 1. 
 
 2. 
 
 5 
 
 
 3. 
 
 3. 
 
 3. 
 
 2 
 
 4. 
 
 2. 
 
 4. 
 
 2. 2 
 
 2. 
 
 1. 
 
 4 
 
 
 3. 
 
 3. 
 
 1. 
 
 1 
 
 80 
 
PROC 
 
 
 
 7. 
 
 2 
 
 
 
 PROCEDURE 
 
 
 
 7. 
 
 2 
 
 
 
 PROCEDURE BODY 
 
 
 
 7. 
 
 2 
 
 
 
 PROCEDURE NAME 
 
 
 
 7. 
 
 2 
 
 
 
 PROCEDURES 
 
 
 
 7. 
 
 4. 
 
 1 
 
 
 PROGRAM 
 
 
 
 7. 
 
 1 
 
 
 
 PUT 
 
 
 
 5. 
 
 4. 
 
 1 
 
 
 Q 
 
 
 
 4. 
 
 2. 
 
 3. 
 
 2. 2 
 
 R 
 
 
 
 4. 
 
 2. 
 
 4. 
 
 2. 1 
 
 R* 
 
 
 
 4. 
 
 2. 
 
 4. 
 
 3 
 
 READ 
 
 
 
 5. 
 
 2. 
 
 1 
 
 
 READING 
 
 
 
 4. 
 
 2. 
 
 3. 
 
 2. 1 
 
 READING A FILE 
 
 
 
 4. 
 
 3. 
 
 2 
 
 
 READING A STACK 
 
 
 
 4. 
 
 3. 
 
 1 
 
 
 READING AN INPUT 
 
 
 
 4. 
 
 3. 
 
 1 
 
 
 RECORD 
 
 
 
 1. 
 
 2. 
 
 5 
 
 
 RECORD 
 
 
 
 3. 
 
 4 
 
 
 
 RECORD TEST 
 
 
 
 4. 
 
 2. 
 
 4. 
 
 3 
 
 REFERENCE LANGUAGE 
 
 
 
 1. 
 
 5 
 
 
 
 REPRESENTATION OF 
 
 REFERENCE LANGUAGE 
 
 1. 
 
 5 
 
 
 
 RESTORE 
 
 
 
 5c 
 
 4o 
 
 4 
 
 
 RETURN 
 
 
 
 5. 
 
 5. 
 
 4 
 
 
 S* 
 
 
 
 4* 
 
 2* 
 
 4, 
 
 3 
 
 SAVE 
 
 
 
 5a 
 
 4. 
 
 3 
 
 
 SCOPE OF A DECLARATION 
 
 OF A LABEL 
 
 7. 
 
 4. 
 
 3 
 
 
 SCOPE OF AN INDEX 
 
 DECLARATION 
 
 7. 
 
 4. 
 
 4 
 
 
 SCOPE OF DECLARATIONS 
 
 
 7. 
 
 4 
 
 
 
 SEARCH 
 
 
 
 5. 
 
 6. 
 
 1 
 
 
 SEARCH AND COUNT 
 
 
 
 5. 
 
 6. 
 
 2 
 
 
 SET INTO FILE 
 
 
 
 5. 
 
 4. 
 
 5 
 
 
 SET INTO STACK 
 
 
 
 5. 
 
 1. 
 
 3 
 
 
 SET OUTPUT 
 
 
 
 5. 
 
 3. 
 
 2 
 
 
 SHIFT 
 
 
 
 5. 
 
 4. 
 
 8 
 
 
 SHIFT AND COUNT 
 
 
 
 5. 
 
 4. 
 
 9 
 
 
 SIMPLE JUMP 
 
 
 
 5. 
 
 5. 
 
 1 
 
 
 SPECIAL RECORD 
 
 
 
 1. 
 
 2. 
 
 5 
 
 
 SPLIT 
 
 
 
 5. 
 
 1. 
 
 9 
 
 
 STACK 
 
 
 
 1. 
 
 2. 
 
 2 
 
 
 STACK 
 
 
 
 3. 
 
 3 
 
 
 
 STACK INSTRUCTION 
 
 
 
 5. 
 
 1 
 
 
 
 STACK VALUE 
 
 
 
 3. 
 
 3 
 
 
 
 STATEMENT 
 
 
 
 7. 
 
 2 
 
 
 
 STOP 
 
 
 
 5. 
 
 5. 
 
 5 
 
 
 SUB 
 
 
 
 5. 
 
 1. 
 
 6 
 
 
 SWITCH 
 
 
 
 6. 
 
 1 
 
 
 
 SWITCH JUMP 
 
 
 
 5. 
 
 5. 
 
 3 
 
 
 SYNTAX FORMAL DESCRIPTION 
 
 1. 
 
 4 
 
 
 
 T 
 
 
 
 4. 
 
 2. 
 
 3. 
 
 2. 3 
 
 TABLE 
 
 
 
 6. 
 
 2 
 
 
 
 TABLE INSTRUCTION 
 
 
 
 5. 
 
 6 
 
 
 
 TERMINATION OF READING 
 
 A LIST 
 
 4. 
 
 3 
 
 
 
 TEST 
 
 
 
 4. 
 
 2. 
 
 4 
 
 
 TEST FILE 
 
 
 
 5. 
 
 4* 
 
 7 
 
 
 TEST INPUT 
 
 
 
 5. 
 
 2. 
 
 3 
 
 
 TEST STACK 
 
 
 
 5. 
 
 1. 
 
 5 
 
 
 TESTING 
 
 
 
 4. 
 
 2. 
 
 3. 
 
 2. 3 
 
 USE OF FORMAL INDEXES 
 
 
 7. 
 
 4. 
 
 5 
 
 
 81 
 
USE OF LABELS 
 
 VARIABLE 
 
 WORD 
 
 WORD 
 
 WORD TABLE 
 
 WORD TEST 
 
 WORD TEST OPERATOR 
 
 WRITE 
 
 Y 
 
 Z 
 
 z 
 z 
 
 7. 
 
 4. 
 
 5 
 
 
 
 3 
 
 
 
 
 
 1. 
 
 2. 
 
 2 
 
 
 
 3. 
 
 3. 
 
 1 
 
 
 
 6. 
 
 2. 
 
 1 
 
 
 
 4. 
 
 2. 
 
 4. 
 
 2 
 
 
 4. 
 
 2. 
 
 4. 
 
 2. 
 
 2 
 
 5. 
 
 3. 
 
 1 
 
 
 
 4. 
 
 2. 
 
 3. 
 
 2. 
 
 2 
 
 4. 
 
 2. 
 
 3. 
 
 2. 
 
 1 
 
 4. 
 
 2. 
 
 3. 
 
 2. 
 
 2 
 
 4. 
 
 2. 
 
 3. 
 
 2. 
 
 3 
 
 YMBOLS 
 
 
 
 
 
 
 
 BRACES 
 
 
 
 
 1. 
 
 4 
 
 
 BRACKETS 
 
 
 
 
 1. 
 
 4 
 
 
 CONSTITUENT 
 
 MARK 
 
 FOR 
 
 ADDRESS 
 
 1. 
 
 2. 
 
 2 
 
 CONSTITUENT 
 
 MARK 
 
 FOR 
 
 NUMBER 
 
 1. 
 
 2* 
 
 2 
 
 CONSTITUENT 
 
 MARK 
 
 FOR 
 
 WORD 
 
 1. 
 
 2. 
 
 2 
 
 END OF TEXT 
 
 MARKS 
 
 
 
 1. 
 
 6 
 
 
 GAMMA 
 
 
 
 
 2. 
 
 1. 
 
 3 
 
 LAMBDA 
 
 
 
 
 1. 
 
 5 
 
 
 LAMBDA 
 
 
 
 
 2. 
 
 1. 
 
 3 
 
 POINTER 
 
 
 
 
 1. 
 
 2. 
 
 5 
 
 RECORD MARK 
 
 
 
 
 1. 
 
 2. 
 
 5 
 
 SIGMA 
 
 
 
 
 1. 
 
 2. 
 
 5 
 
 SIGMA 
 
 
 
 
 3. 
 
 4 
 
 
 slash 
 
 
 
 
 1. 
 
 4 
 
 
 82 
 
AUG i 6 1968 
 
JUf, 
 
 ?0 
 
 %