LIBRARY OF THE 
 
 UNIVERSITY OF ILLINOIS 
 
 AT URBANA-CHAMPAIGN 
 
 510.84 
 T4G3c 
 
 no.1-10 
 
AUG 5197S 
 
 The person charging this material is re- 
 sponsible for its return to the library from 
 which it was withdrawn 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 AT URBANA-CHAMPAIGN 
 
 111 
 
 
 JUL 07?Fri 
 
 IMP 
 I thill 
 
 L161 — O-1096 
 
Digitized by the Internet Archive 
 
 in 2012 with funding from 
 
 University of Illinois Urbana-Champaign 
 
 http://archive.org/details/osl2operatingsys00alsb 
 
Report No. k-60 
 
 £10. 8U 
 l£63c 
 
 no 
 
 .6 
 
 ONFERENCE 
 
 imgm. 
 
 OSL/2 
 AN OPERATING SYSTEM LANGUAGE 
 
 by 
 Peter Allyn Alsberg 
 
 ENGINEERING LIBRARY 
 UNIVERSITY OF ILLINOIS 
 
 URBANA, ILLINOIS 
 
 CAC Document No. 6 
 
Report No. kGO 
 
 OSL/2 
 AN OPERATING SYSTEM LANGUAGE 
 
 by 
 PETER ALLYN ALSBERG 
 
 June 10, 1971 
 
 Department of Computer Science 
 University of Illinois at Urbana-Champaign 
 Urbana, Illinois 6l801 
 
 This work was supported in part by the Advanced Research Projects 
 Agency as administered by the Rome Air Development Center under 
 Contract No. USAF 30(602)-4l44 and submitted in partial fulfillment 
 of the requirements for the degree of Doctor of Philosophy in Computer 
 Science, June 1971. 
 
■uiunvLWimv 
 
 ABSTRACT 
 
 OSL/2, an Operating System Language, was designed for the 
 coding of supervisory systems. OSL/2 is an ALGOL-based language that 
 may be readily extended to a general purpose language with the addition 
 of a few data types (e.g., floating point numbers). The language replaces 
 an interrupt concept with the P and V operators on semaphores described 
 by Dijkstra. Concepts of multiple processes and system layers allow 
 OSL/2 to be used as a job control language for an OSL/2 coded supervisory 
 system. The system layering concepts provide for easy system extension 
 and hierarchical structuring. A powerful method of specifying access 
 techniques is used to implement queues , tables, etc. and treat them as 
 primitive data items in the language. The language is presented in narra- 
 tive and reference formats. Hardware implications are discussed and an 
 OSL/2 compiler which runs on the Burroughs 5500 is briefly described. The 
 implications of the language on system measurement, simulation, and modifi- 
 cation are also discussed. 
 
IV 
 
 TABLE OF CONTENTS 
 
 Chapter Page 
 
 1. OSL/2 Concepts, Philosophies, and Goals 1 
 
 2. An Introduction to the OSL/2 Syntax and Semantics 10 
 
 2.1. The Primitive Data Types 12 
 
 2.1.1. Integer 12 
 
 2.1.2. Boolean 13 
 
 2.1.3. String ll+ 
 
 2.1.1*. Patterns 15 
 
 2.1.5. Pointers l6 
 
 2.1.6. Conditional and Case Expressions 17 
 
 2.2. Composite Data Types 18 
 
 2.3. Statements 30 
 
 2.3.1. Blocks, Compound Statements, Case Statements 
 and Conditional Statements Are Recursively 
 
 Defined 30 
 
 2.3.2. Iterative Statements .... 31 
 
 2.3-3. Assignment Statement 3^4 
 
 2.3.^-. Pattern Matching Statement 36 
 
 2.3.5 • Procedure Statements 38 
 
 2.h. Procedures and Functions 39 
 
 2.5- Control Concepts ^9 
 
 2.5-1. Escape Statements U9 
 
 2.5.2. Semaphores 50 
 
 2.5.3. Processes 52 
 
Chapter Page 
 
 2.5.1*. Traps 3k 
 
 2.5.5. Primitives 55 
 
 2.6. Compile Time Facilities 57 
 
 3. System Measurement, Modification, and Debugging in an 
 
 OSL/2 Environment 60 
 
 k. The Hardware Requirements of OSL/2 6k 
 
 5. Conclusions 78 
 
 Appendix 
 
 A. A Reference to OSL/2 Syntax and Semantics 8l 
 
 B. An. OSL/2 Compiler 167 
 
 LIST OF REFERENCES 2U7 
 
 VITA 2U9 
 
VI 
 
 LIST OF FIGURES 
 
 Figure Page 
 
 1. Variable stack while in block 1 69 
 
 2. Variable stack after entering the procedure "addl" 71 
 
 3. Two stack layout if " append (addl(r ,m) )" is written 
 
 instead of "addl(r,m) M 72 
 
 h. Final addressing scheme 75 
 
Chapter 1 
 OSL/2 Concepts, Philosophies, and Goals 
 
 For many years supervisory and monitor systems have "been coded 
 in machine level languages hy a rather priviledged set of system coders. 
 Machine level languages have been used to improve system efficiency. The 
 systems programmer has been allowed the privilege of unprotected access 
 to all portions of a system on the assumption that he is a capable coder 
 not subject to the errors of the normal applications coder. 
 
 Unfortunately, assembly language coded systems have shown them- 
 selves to be grossly inefficient. For example, consider the differences 
 in system overhead and reliability between two similar systems like ASP 
 [1, 2, 3, k] and HASP [5] on the IBM system/ 360. HASP commonly experiences 
 two to four times less overhead than ASP. Yet, in the opinion of this 
 author, a factor of at least 2 if not k improvement is still available 
 in HASP if the queuing and event structure were reorganized. Even a 
 reasonably small system like IBSYS [6] for the IBM 709^ has significantly 
 less throughput capability than P0RTH0S [7] when a university job mix is 
 being processed. Analyses of the GECOS systems for the GE machines, EXEC 
 systems for Univac machines, etc., would yield similar examples of widely 
 varying efficiencies in different assembly language coded systems for the 
 same machine. By comparison the Burroughs MCP [8] (Master Control Program) 
 for the B5500 experiences relatively low system overhead even though the 
 B5500 MCP is coded in the high level language ESPOL [9]— an ALGOL language 
 derivative. The important point to be made here is that assembly language 
 has not automatically brought efficiencies. Good system design is clearly 
 the most important factor and does lead to efficiencies. 
 
An examination of existing operating systems also shows that, 
 with the notable exception of the THE Multiprogramming System [10], errors 
 are plentiful. The author's personal experience has "been that even in 
 very old systems, about five to ten per cent of the errors that were dis- 
 covered late in the life of a system were undiscovered key punch errors. 
 Of the remaining errors, about one third to one half are addressing errors, 
 most of which could be caught by a simple array bounds or index check in 
 a high level language. After encountering literally hundreds of examples 
 of trivial errors which should not have been made by systems programmers, 
 the author has come to the conclusion that systems programmers are as 
 prone to make mistakes as applications coders. They are in need of tools 
 which help them avoid inadvertant errors by restricting the scope of their 
 actions to the particular task at hand - for example, an automatic index 
 bounds check. Because of the drastic and widely propagated effects of a 
 system error, systems programming requires at least as much protection as 
 that available to applications programming. 
 
 The cost of building operating and support systems is now so 
 prohibitive that new machines are required to be downward compatible with 
 old machines on which working assembly language system software already 
 exists. Yet new hardware architectures continue to be developed with a 
 wide variety of addressing features that cannot be used because they con- 
 flict with old techniques. This is especially unfortunate when one realizes 
 that the vast majority of system software need not be machine dependent. 
 Most system software is concerned with table and queue manipulation, i.e., 
 with the specification of scheduling algorithms. Machine dependence has 
 been forced as a by-product of the use of machine dependent languages. 
 
3 
 
 The only parts of a system that are truly machine dependent are the 
 interrupt handlers of the supervisor, the code emitter portions of the 
 higher level language compilers, and the assembly language itself. 
 
 In 1968 Wells and Alsberg designed OSL - an Operating System 
 Language [ll]. OSL executed on one processor and was connected to any 
 number of other processors such as arithmetic units, data channels, and 
 peripheral storage devices. First in first out queues and pointers were 
 provided as primitive data types in the language. Interrupts were 
 handled by automatically invoked procedures. It was possible to dynamically 
 change the procedures to be invoked for each interrupt. 
 
 OSL was a block structured ALGOL 60 derivative which interfaced 
 with hardware through eight primitive procedures. For example, the "route" 
 primitive connected an interrupt with the procedure to process the interrupt. 
 Each of these primitives was designed to be implemented on most machines 
 with an extremely small number of instructions (usually, only about a dozen 
 were required) . In this manner one could guarantee an easy implementation 
 of the hardware interface on most machines . 
 
 A task scheduler for a multiprogramming system was coded in OSL. 
 Since multiprocessing and multiprogramming concepts were embedded in OSL 
 only a few dozen lines of code were required. This code was then examined 
 with the intention of running the same code on an IBM 360/75 and an IBM 
 709^+. Due to the limited time available to the authors, they were unable 
 to build OSL compilers for both machines. However, by the time the project 
 was abandoned, they had verified that the identical OSL code could be made 
 to run on both machines and that the primitives involved could be imple- 
 mented in just a few instructions on both machines. 
 
OSL was designed with machine independence as a major goal. Thus 
 it was completely divorced from any particular addressing scheme. As a 
 result a multiprogramming system coded in OSL would very likely run poorly 
 on an infinite memory descriptor machine like a B5500 or a virtual memory 
 paged machine like a 360/67 or a Sigma "J. Similarly, a failure to specially 
 treat other machine dependent features such as bulk core, head per track 
 disks, hypertape drives, etc. would lead sometimes to large inefficiencies. 
 However, OSL did assure the transportability of an entire operating sys- 
 tem among virtually all medium and large scale computers. 
 
 Subsequent work by the author lead to the design of OSL/2. OSL 
 had been designed to provide a common, machine independent systems language 
 for the largest possible number of machines. OSL/2 used another approach. 
 OSL/2 would be machine ignorant in its design. That is, OSL/2 would be 
 designed to easily specify well structured operating system concepts and 
 algorithms independent of existing machines. Once the language was designed, 
 the hardware necessary to implement the language concepts would be examined. 
 Finally, the appropriate compromises would be made in the language to make 
 it practical. 
 
 Several goals were set at the beginning of the design effort. 
 
 1) Since the heart of an operating system is its queues and tables, 
 the language must allow the specification and manipulation of arbi- 
 trarily structured queues and tables as if they were primitive data 
 items in the language . 
 
 2) The language should provide facilities for the control and synchroni- 
 zation of multiple processes. 
 
 3) The specification of hierarchically structured or layered systems must 
 be straightforward. 
 
k) It must be easy to insert and delete code to measure the performance 
 
 of a system coded in OSL/2 . 
 5) OSL/2 should be both an operating system language and an adequate job 
 control language. The task of an operating system is to sequence or 
 control one or more processes and to allocate resources to these 
 processes. Similarly a job control language must specify the 
 sequencing or control of one or more processes and specify the 
 resources required by each process. Since these tasks are so similar, 
 one language should handle both tasks. These five goals were met by 
 the process control concepts and the generalized data access techni- 
 ques. 
 
 A process in OSL/2 is a program or procedure that may execute 
 concurrently and asynchronously with any other process. For example, a 
 separately running compiler is a process. It is possible to split the 
 compiler into a scanner and a parser which each run simultaneously. The 
 scanner might process the input stream to find all special words and identi- 
 fiers and enter these in tables for the parser to use. The parser communi- 
 cates with the scanner to get the next identifier, special word, or other 
 symbol the scanner has processed. In this case the compiler, a process 
 which includes the parser, would initiate the scanning procedure as a second 
 process. The result is one program with two concurrent processes. 
 
 The process management facilities of OSL/2 allow one process to 
 create and, optionally, monitor new processes. If a process initiates a 
 second process which the first process will monitor, then the first process 
 becomes the operating system for the second process. The first process 
 may define new primitives for the second process to use or may even redefine 
 
existing primitives for the second process. For example, a statistical 
 system might create a new primitive that performs correlation and redefine 
 the storage allocation primitive for those processes that will be monitored 
 by it. 
 
 Each time a process creates a second process which it monitors, 
 a new level or layer is added to the system. Communication between layers 
 is through the primitive procedures. A primitive action may be frequently 
 redefined in new layers. It is also possible to redefine a primitive within 
 one layer. This will be described in detail later. 
 
 A process may spin off one or more processes as asynchronously 
 running procedures. (For example, consider the previous compiler example 
 or the ILLIAC IV operating system [12, 13] which has about a dozen of these 
 processes — one for each operating system task.) When these processes 
 must cooperate with each other, they synchronize their operations through 
 the use of P and V operators on semaphores. These operators were defined 
 and analyzed by Dijkstra [ik] and Habermann [15]. P and V operators, which 
 will be discussed later, provide a powerful process synchronization facility, 
 P and V operators are truly primitive in the sense that they are simple 
 to implement in hardware or software and they provide a base from which 
 more complex process communication techniques can be constructed. 
 
 The process statements provide system layering and process 
 synchronization facilities. Furthermore, the ability to initiate processes 
 and declare data (e.g. files) at any level, allows OSL/2 to serve as an 
 extremely powerful job control language. 
 
 Through the use of the generalized data access facility the 
 programmer may define new data types such as FIFO queues, priority queues, 
 
and special tables. Each time such a data type is accessed, for example 
 in an expression or on the right hand side of an assignment statement, a 
 fetch operation is performed. Each time an attempt is made to store a new 
 value in a data item of this type, for example on the left hand side of 
 an assignment statement, a store operation is performed. The semantics 
 of fetch and store operations and special functions related to the new 
 data type, are defined in the access definition. 
 
 The coder can define fetch and store operations for queues or 
 tables that perform very complex manipulations of these data types. There- 
 after, a complex process such as inserting a new element into a queue or 
 into a table may be written as a simple assignment statement. If, at a 
 later time, changes are to be made to the queuing algorithms, these changes 
 are made only in the definition and the rest of the code is unaltered. 
 If desired, a coder can add instrumentation in the access definition. Since 
 all manipulations of an access type are defined in the access definition, 
 the definition provides a single spot at which every fetch, store and 
 special function call can be recorded. 
 
 Thus the data access facility allows a programmer to define 
 arbitrarily complex data structures that may then be accessed as primitive 
 data items in the language. Furthermore, since this feature is used to 
 implement the queues and tables that define the state of the system, they 
 provide a central place where measurement of the system can be readily 
 performed. 
 
 It should be stressed that OSL/2 is not an extensible language 
 in the general sense that GPL [l6, IT] and ALGOL 68 [l8, 19] are. OSL/2 
 does allow the coder to specify a class of new data types and the semantic 
 
interpretation of fetches and stores on that data type. Unlike most 
 extensible languages, OSL/2 does not allow binary operators to be created 
 or redefined. This restriction makes the language easier to implement 
 yet still provides those data extension features both necessary and 
 desirable for systems programming. 
 
 The author's continual frustration with the lack of good symbol 
 manipulation facilities in existing algorithmic languages led him to 
 adopt the pattern matching concepts of SNOBOL. Many other "nice" features 
 like patterns and case expressions have been added to the language for 
 the convenience of the coder. Most of these facilities are frills that 
 are not essential to the thesis. They are included primarily to document 
 the fact that such formerly diverse constructs as SNOBOL patterns, bit 
 manipulation, and asynchronous processes can all exist harmoniously within 
 a single, block structured, algorithmic language without the specification 
 of scores of new primitives and exception conditions. Most of these 
 facilities were added to basic ALGOL 60 by extending the primitive data 
 base to include structures, strings, patterns and pointers or by making 
 logical extensions to existing statements, such as the iteration statement. 
 
 Unfortunately, systems programmers tend to be very poor docu- 
 menters of their work. Unless they are made to write program logic manuals 
 and flowcharts before they write the code, they will most likely never 
 provide these flowcharts or logic manuals. 
 
 Therefore , many of the features in the language are included to 
 aid in the structuring and documentation of a piece of code. For example, 
 the lack of a GO TO statement not only forces clean program structure but 
 also allows a compiler to perform better global optimizations. Since 
 
labels must appear "before and after a labelled statement and must be 
 used by the ESCAPE statement, a minimal level of documentation is auto- 
 matically forced on the coder. 
 
 The main features of the language which are essential to the 
 operating system codes are the generalized data access facility which 
 enhances system measurement and queue manipulation and the process facility 
 which allows asynchronous processes to be controlled, synchronized, and 
 layered. 
 
 The other features of OSL/2 are not essential but desirable. 
 These extra features make the description of algorithmic processes more 
 pleasant for the coder and frequently make a piece of code more readable. 
 Futhermore , these features not only help the systems programmer structure 
 and compress very complex codes, they also help him clarify his thoughts 
 and thus properly design and structure these arbitrarily complex systems. 
 
10 
 
 Chapter 2 
 An Introduction to the OSL/2 Syntax and Semantics 
 
 The heart of any operating system is its resource scheduling 
 and allocation facilities. Therefore, the highest design priority is 
 placed on the ability of the language to properly specify scheduling 
 algorithms. Secondary to this consideration but still of great import- 
 ance is the ease "with which the programmer can use the language. 
 
 Questions concerning paging, file organization, linking, and 
 addressing are not considered in the language. 
 
 This chapter is broken into two main sections - a description 
 of the data types and expressions allowed in the language followed by 
 a description of the statements and process control facilities. 
 
 The primitive data types allowed in the language are integers, 
 Booleans , strings, patterns, and pointers. Integers are used for arith- 
 metic and indexing. Booleans provide logical manipulation capabilities 
 and are used extensively when controlling program execution. Strings of 
 various character sizes and lengths are used with SNOBOL-like patterns 
 to scan text. Pointers are heavily used to build and process list data 
 or data structured as an arbitrary network. 
 
 These five primitive data types are used to form the three 
 composite data types: arrays, structures, and generalized access data. 
 OSL/2 arrays are identical to Algol arrays. Structures allow the 
 specification of tree structured data similar to PL/1 structures. 
 
11 
 
 Generalized access data are built up from the primitive data types 
 and the other composite data types. Special purpose procedures are 
 ■written to describe how this data will be manipulated. The combination 
 of the data specifications and the manipulation procedures allow one 
 to declare and manipulate complex queues and tables and to perform 
 complex I/O and data retrievals as if they were primitive constructs 
 in the language. 
 
 An OSL/2 program is composed of one or more nested or sequential 
 statement blocks. These blocks are identical to ALGOL 60 blocks. 
 Within the blocks, compound, iterative, conditional, and assignment 
 statements are allowed. In addition, procedure calls and case statements 
 are provided. The case statement allows one to index into a list of 
 statements and execute only one of them depending upon which index value 
 was used. 
 
 OSL/2 does not have a GO TO statement. The GO TO is replaced 
 by the escape statement. An escape statement allows one to leave the 
 range of any statement he is in. For example, he could leave an iteration 
 loop, or the block that contained the loop, or the block that contained 
 that block, etc. However, one cannot enter another statement via an 
 escape statement. The only way to enter a statement is to arrange for 
 it to be the next statement in the program sequence. In such an environ- 
 ment, a programmer depends heavily upon "infinite" loops, terminated by 
 executing an escape statement, to replace many GO TO statements. 
 
 In OSL/2, a process is a separately running program or asyn- 
 chronously running procedure attached to another process. Control 
 
12 
 
 primitives are available to initiate, stop, and restart processes. 
 Furthermore, it is possible to declare new primitives for processes 
 or to reroute calls on standard primitives to alternative procedures 
 declared by a supervisory process. These asynchronously running 
 processes may synchronize their actions using P and V operators on 
 semaphores. These provide a very convenient lock-out capability. 
 
 This brief, global introduction to the language facilities 
 provides the perspective for the detailed description that follows. 
 2.1. The Primitive Data Types 
 
 There are five primitive OSL/2 data types: integers, Booleans , 
 strings, patterns, and pointers. 
 2.1.1. Integer 
 
 The only arithmetic allowed in OSL/2 is performed on the 
 positive and negative integers. In an actual implementation of OSL/2 
 to solve more than just scheduling problems, it may be desirable to 
 include real numbers or even complex numbers as primitive data. Since 
 these are generally machine dependent and extremely rarely used, if 
 ever, in operating system work, they are not included in the OSL/2 
 
 description. 
 
 The operations that may be performed on integers include 
 addition, subtraction, multiplication, a variety of divisions, and 
 exponentiation. When performing division on integers, one may produce 
 a rounded or truncated answer. He may further truncate up or down in 
 value. Therefore, division operators are provided to describe each of 
 these operations. 
 
13 
 
 2.1.2. Boolean 
 
 Booleans are single valued data that take on the value true 
 or false. They may not be considered to he multivalued or bit strings 
 as they are in most languages . String data and string operators must 
 be used to perform logical operations on bit strings. 
 
 The logical functions and, or, not, exclusive or, equivalence, 
 and implication are allowed on Booleans. In the evaluation of Boolean 
 expressions two additional special purpose operations are allowed: 
 andif and or if . The use of these operations is best illustrated with 
 an example. 
 
 Assumed that operation X is to be performed if the Boolean 
 variables A, B, and C are all true. An OSL/2 program to do this would 
 be written if A andif B andif C then X fi 
 
 A conditional OSL/2 expression or statement begins with an if and is 
 terminated by a fi_. Thus if. . fi is actually a bracket pair. In thi.s 
 and all following examples the special OSL/2 words are underlined for 
 illustrative purposes only. In the language itself, words like if , 
 and , etc. are reserved words and may not be used for purposes other 
 than indicating specific OSL/2 constructs. In the above example, one 
 need not test the variables B or C if A is false. The andif caused the 
 evaluation of B and C to be skipped if the expression is already 
 determined to be false. The operator orif causes a similar termination 
 of an expression or subexpression if the value is already determined to 
 be true. These operators are provided for efficiency and to avoid 
 unpleasant side effects. For example, it may happen, particularly in 
 
Ik 
 
 operating systems codes, that the quantity B may not exist if A is false. 
 Thus the testing of B might cause an error. The way around this situation 
 in conventional languages has been to write nested conditional state- 
 ments , e.g. , 
 
 if A then if B then X fi f i 
 In OSL this is written as , 
 
 if A andif B then X fi 
 2.1.3. String 
 
 String data has a character size and a length. The character 
 size is measured in bits and the length in characters. Strings may be 
 of a fixed length or may be variable within some maximum length. 
 
 A string may be bit-wise anded ( sand ) , ored ( sor ) , exclusive- 
 ored ( sxor ) , or complemented ( snot ) . A string may also be tested for a 
 pattern match or for equality or inequality with some other string. 
 
 For example, the following Boolean expression is true if the 
 string S contains an "A", "B", or "C M . 
 
 S { "A" | "B" | "C" } 
 The pattern is contained within the braces. The following statement 
 tests if the string A is not equal to the string B and, if not, conca- 
 tenates it to the string X. 
 
 if A ^= B then X .+ X & A fi 
 
 String inequality is judged by the bit representations of 
 each character. No collating sequences are assumed by OSL/2. However, 
 one may specify standard character sets such as ASCII and EBCDIC when 
 writing string constants. For example, the string constant E"XYZ" is 
 
15 
 
 a three character string. Each character is eight "bits long and contains 
 the EBCDIC representation of respectively "X" , "Y" , and "Z". 
 
 Substrings may be specified by following a string expression 
 with a field. 
 Examples : 
 
 S.[0:10j 
 
 (S -*- S&B).[n:k+2] 
 The first example specifies the first ten characters of S. The second 
 example specifies k+2 characters beginning at character n in the new 
 value of S. Characters are numbered left to right beginning at zero. 
 2.1. U. Patterns 
 
 Patterns are used in pattern matching statements. Pattern 
 matching statements are also Boolean expressions. The OSL/2 pattern 
 is based on the SNOBOL k pattern. 
 
 All patterns are enclosed within patterns to any depth. 
 Patterns may be assigned to pattern variables and saved for later use 
 or passed to procedures. Patterns may also specify that intermediate 
 results in a pattern match should be assigned to some string variable. 
 
 The basic form of a pattern expression is 
 •TA I A i i A \ 
 
 where each A is an alternative. Patterns are matched from left to right. 
 The result of the match is true if one alternative matches and false if 
 no alternative matches. The evaluation of a pattern expression stops at 
 the first match. 
 
 Each alternative has the general form 
 
 S -*- P.&P_&P_&. . ,&P 
 12 3 n 
 
16 
 
 where S is an optional string variable and P . . .P are pattern primaries. 
 In order to match this alternative, a string must contain the pattern P 
 followed immediately by the pattern P , followed immediately by the 
 pattern P , etc. If a successful match is made, a copy of the part of 
 the string which matches the concatenated patterns is placed in S. 
 
 Since a pattern variable may have as its value an embedded assign- 
 ment to a string variable, one must be sure that the string variable 
 exists so that the embedded string assignment is always legal. Therefore 
 pattern variables or string variables may not appear in a pattern expression 
 on the right hand side of a pattern assignment if the pattern variable 
 on the left is global to them. Furthermore, a formal parameter pattern 
 variable may not be assigned a pattern which contains pattern or string 
 variables. In the example 
 
 Patt «■ {"A" | Str ■*■ "B" & Patt | {Str 2 | Patt }} 
 the following must be true: 
 
 1) Patt , Patt.., Str , and Str p must be declared global to 
 Patt or they must be declared in the same block as Patt . 
 
 2) Patt is not a formal parameter. 
 
 Pattern primaries are string constants, string variables, 
 pattern variables, pattern functions, and pattern expressions. 
 
 Refer to pattern matching statements for more pattern examples . 
 2.1.5- Pointers 
 
 Pointers specify or "point to" any OSL/2 data. If P is a 
 pointer and X some data, then P.X. is the X pointed to by P. This is 
 of special use when list processing. The OSL/2 coder will normally 
 
17 
 
 have only one identifier used to denote a list element. The pointer then 
 denotes "which list item is being specified. Pointers may point to node, 
 own, or normal data although they are primarily intended for use with 
 node data (node data may "be explicitly allocated and deallocated by 
 the programmer) . 
 
 Pointers may point to other pointers. For example, "P1.P2.X" 
 is the X pointed to by the P2 which is pointed to by PI. 
 
 Pointers may have a null value or may be assigned values via 
 allocate statements and pointer functions. P <- ptr (N) creates a pointer 
 to the variable N and assigns it to P. 
 2.1.6. Conditional and Case Expressions 
 
 In the previous five data types, the following primaries are 
 allowed in all expressions. 
 
 if Boolean expression then expression else expression fi 
 
 and 
 
 case integer expression of 
 
 expression^ , 
 
 expression , 
 
 expression esac 
 n 
 
 In the above constructs, expression, is an integer, Boolean, string, 
 pattern, or pointer expression. 
 
 In the first construct, the if primary, the Boolean expression 
 is evaluated, if it is true, then the value of the primary is expression 
 If it is false, the value of the primary is expression . 
 Examples : 
 
 if x=0 then a else b fi 
 
 n ■*■ if n=0 then h else n+1 fi 
 
18 
 
 The case primary has as its value expression, where i is the 
 value of the integer expression. If the integer expression is less 
 than zero or greater than n then the default expression is the value 
 of the primary. 
 2.2. Composite Data Types 
 
 There are three composite data types, arrays, structures, 
 and generalized access data. 
 
 OSL/2 allows any of the primitive or composite data types 
 to "be subscripted. The subscript list follows the data identifier and 
 is enclosed in "brackets. 
 Examples : 
 
 A[0] 
 
 B[10, 23*2+7] 
 
 C23[if X_is_even then X else 2*X fi] 
 Data structures, similar to the structures allowed in PL/1, 
 are used in OSL/2. An example of a list element declaration is given 
 below. 
 
 node structure list_element 
 
 ( structure data ( integer age, weight, height; 
 
 Boolean sex_is_male) ; 
 pointer forward, backward) 
 Note that structures may be nested within structures. Also 
 note the use of an underscore to make identifiers more readable. The 
 underscore is a null character. Thus the identifiers "a_b_c" and "abc" 
 are the same identifier. 
 
19 
 
 The data within a structure must always be completely 
 addressed "by all identifiers in the hierarchy above the desired data. 
 The list of identifiers is in hierarchial order and is separated by 
 ".". For example, the pointer forward is addressed as 
 
 list_element . forward 
 and the integer weight is addressed as 
 
 list_element . data. weight 
 "list_element .weight" , "weight", "data. weight" , and "forward" would not 
 be legal syntax in any construct. 
 
 If desired, for example when passing data to a procedure, one 
 may specify a whole structure or substructure by addressing down to the 
 level desired. For example, "list_element" or "list_element .data". 
 
 The generalized data access facilities allow the programmer to 
 specify the action that is to be taken when data is fetched from (variable 
 appears on the right hand side of an assignment statement) or stored into 
 (variable appears on the left hand side of an assignment statement) the 
 variable. In addition, numerous side actions may be specified. This facil- 
 ity is of greatest use when manipulating tables, queues, and stacks which 
 have complex data structures and access algorithms. In access declarations 
 and definitions, the key words access , stack , table , and q ueue may all be 
 used interchangeably. 
 
 For a simple example consider a queue consisting of integers 
 which are accessed in a first in first out manner such that storing into the 
 queue causes a new entry to be made and fetching causes the oldest entry to 
 be deleted. 
 
 Two constructs are required: the definition of the data type and 
 a declaration of an identifier which is this type. First the definition: 
 
20 
 
 1. queue fifo; 
 
 2. "begin 
 
 3. integer (number_of_entries , oldest_entry, newest_entry) ■*• 0, 
 h. entry__list[0:99]; 
 
 5 . integer f i f o procedure f et ch ; 
 
 6. begin 
 
 7. fetch «- entry_list[oldest_entry «- (*+l)mod 100]; 
 
 8. number_of_entries «- *-l 
 
 9. end fetch; 
 
 10. fifo procedure store (X); integer X; 
 
 11. begin 
 
 12. entry_list[newest_entry «- (*+l) mod 100] ■♦■ X; 
 
 13. number_of_entries •<- *+l 
 lk. end store; 
 
 15. end 
 
 A line by line description of this definition "will provide 
 insight into many 0SL/2 constructs. 
 
 1) On this line the new access type "fifo" is declared. Within the scope 
 of this definition, the identifier "fifo" will be used to declare "fifo" 
 queues . 
 
 2) All the information concerning an access type is local to the access 
 variable. This prevents tampering with access variables through any 
 means other than the access procedures declared in the access definition. 
 Thus the definition block is a true block enclosed in a begin and end 
 (lines 2 and 15) that restricts the use of internal access variables. 
 
 
21 
 
 The access procedures declared within the definition are pseudo local 
 to the type fifo. That is, it is possible to write the OSL/2 code 
 "length (X)" in one place and have it represent a call to one of many 
 procedures called length depending on the declaration of "X" . "length(X)" 
 might refer to a standard procedure call with one actual parameter. 
 If "X" is an access variable and an access procedure, "length", is declared 
 for that access type, then the appropriate access procedure will be 
 invoked. If several access types are available each with its own proce- 
 dure named "length", the particular procedure "length" declared to be 
 part of the access type of the access variable will be invoked. 
 3) Three integers are declared and are initialized to zero. 
 k) An integer array indexed from zero to 99 is declared. 
 
 5) This line declares the fetch procedure. The fetch procedure will 
 automatically be invoked whenever a fetch is made on a variable declared 
 to be fifo. The result will be an integer. 
 
 6) The fifo procedure fetch has a compound statement as a body. Thus, 
 it is enclosed in a begin end pair. 
 
 7) The return value of the function "fetch" is set here. The value 
 returned is in the array "entry_list". The index of "entry_list" is 
 an imbedded integer assignment statement. The index will be the value 
 of "oldest_entry" after the assignment is performed. Notice the use of 
 the asterisk in the right hand side of the assignment statement. This 
 is a shorthand for the variable used on the left hand side of the 
 assignment statement. Only one such asterisk is allowed and it must 
 
 be the first integer quantity (primary) encountered on the right hand 
 
22 
 
 side. Thus 
 
 A ■*- * + 1 
 
 is the same as 
 
 A * A + 1 
 
 but 
 
 A -<- 1 + * is not allowed. Note that this expression increments "oldest_ 
 entry" and uses the mod operator to map its values cyclically over the 
 range zero to 99 • 
 
 8) This line is unnecessary now but will be used later. It maintains 
 
 a count of the number of entries currently in the fifo queue. The use of 
 the asterisk convention is illustrated here to decrement the number of 
 entries in the queue. 
 
 9) This end closes the fetch procedure compound statement. Note that 
 comments consisting of letters and digits are allowed following an 
 end . 
 
 10) The store procedure is declared on this line. A store procedure is 
 automatically invoked when an assignment is made to an access variable. 
 Store procedures have one parameter which is the type of the data which 
 may be stored into the access variable. The type of data fetched from 
 and the type of data stored into an access variable need not be the same 
 type. The identifiers "fetch" and "store" indicate that the fifo proce- 
 dures with those names have special restrictions as to their automatic 
 invocation and number of parameters. In this case the data stored into 
 the fifo access variable is integer data. 
 
 11) This begin starts the compound statement which is the body of the 
 procedure "store". 
 
23 
 
 12) In this case, an entry -will "be made in "entry_list". Otherwise, 
 this is similar to line 7. Note that, as in line 7, an embedded assign- 
 ment is used to compute the subscript of "entry_list" . This position 
 
 in the array receives the value to be stored. 
 
 13) In a manner similar to line 8, the "number_of_entries" variable is 
 incremented. 
 
 ik) As in line 9, this line terminates the procedure store and also 
 
 contains a comment. . 
 
 15) This line terminates the fifo definition. 
 
 In order to use fifo variables, one must declare them. For 
 example : 
 
 fifo queue X, Y, Z 
 declares three fifo variables X, Y, and Z. 
 Some examples of use follow: 
 
 X -*- puts a zero on the tail of X. 
 
 Y ■*- Y removes the head of Y and puts it 
 
 at the tail of Y. 
 
 Y ■*- Y ■■*• Y ■*• 1 puts 3 ones into Y. 
 
 Y ■*■ Z ■*■ X removes the head of X and puts it on 
 
 the tail of Z and Y. 
 I + I + Y_+ I is equivalent to Y «- (Y «- (Y «- Y) ) . 
 Note that subscripts and all other explicitly stated operations in an 
 assignment statement are evaluated from left to right. However, assign- 
 ments are made right to left. Thus the invocations of access store 
 procedures, which occur at assignment time, are right to left. 
 
2k 
 
 Now that the basic access data type has "been demonstrated, 
 assume that the coder wishes to be able to add a facility to his fifo 
 queues to enable him to find the length of the queue. The following 
 access procedure declaration may then be added to the definition between 
 lines h and 5, 9 and 10, or ik and 15. 
 
 integer fifo procedure QSIZE; 
 QSIZE «- number_of_entries ; 
 With this addition, the coder can write QSIZE(x) and know the number of 
 entries in X. Note that the parameter "X" ("X" is a fifo queue variable) does 
 not appear in the declaration of "QSIZE". All access procedures are called 
 with one more parameter than is declared. By convention, this additional 
 parameter is the first parameter and indicates which access variable is to 
 be operated upon. 
 
 Some additional features of the access facility are demonstrated 
 by this example: 
 
 1. stack simple (S) ; integer S -«- 0; 
 
 2. begin 
 
 3. integer number ■*■ 0, default_value ■«- S; 
 k. pointer head «- null ; 
 
 5. node structure entry( 
 
 6. integer item; 
 
 7. pointer next ■*■ head); 
 
 8. integer simple procedure fetch; 
 
 9 . begin 
 
 10. pointer temp; 
 
 11. if_ head = null 
 
 12. then leave fetch (default_value) 
 
 13. else 
 
25 
 
 Ik. 
 
 
 
 fetch ■*• head. entry. item; 
 
 15. 
 
 
 
 temp ■«- head; 
 
 16. 
 
 
 
 head •*- head. entry. next ; 
 
 IT. 
 
 
 
 release (temp. entry) 
 
 18. 
 
 
 
 fi 
 
 19. 
 
 
 
 end fetch; 
 
 20. 
 
 
 
 simple procedure store(X) ; integer X; 
 
 21. 
 
 
 
 begin 
 
 22. 
 
 
 
 head -«- allocate( entry) ; 
 
 23. 
 
 
 
 head. entry. item ■*- X 
 
 2U. 
 
 
 
 end store 
 
 25- 
 
 end 
 
 9 
 
 26. 
 
 simple stack X, Y(A*B) ; 
 
 27. 
 
 X 
 
 -«- 
 
 l; 
 
 28. 
 
 Y 
 
 ■«- 
 
 X «• A+B; 
 
 29. 
 
 X 
 
 ■«- 
 
 X; 
 
 30. 
 
 X 
 
 ■*- 
 
 X «• X; 
 
 Note that in line 1 the access type "simple" has a formal para- 
 meter which is used on lines 3 and 12 to return a default value if the 
 simple stack is empty. 
 
 Note also that on line 5 a node structure is declared to hold 
 the entries in the stack. Node structures, like PL/1 controlled storage, 
 may he allocated and deallocated by explicit programmer command (cf. the 
 allocate and release statements on lines IT and 22) . 
 
 On line 7 of this definition, the substructure pointer "next" 
 will be initialized to the value of "head" each time the structure entry 
 is allocated. 
 
26 
 
 Lines 12 and lU illustrate the two ways to return values for 
 
 a function. One line 12, the escape statement " leave fetch (default_value)" 
 sets the function value and exits. On line lk, the function value 
 is set but computation continues. 
 
 When specifying a node variable, if a pointer to the variable 
 is not given, the last allocated instance of that variable is assumed. 
 Thus on lines lU , l6 and 23, the phrase "head" need not appear before the 
 phrase "entry". 
 
 On line 26, the simple stacks "X" and "Y" with respective defaults 
 of zero and A*B are declared. In the definition of simple stacks on 
 line 1, the parameter "S" was given a value of zero which was to be used 
 if the parameter was not supplied at declaration time. Since the para- 
 meter was omitted in the declaration of "X", zero was assumed. 
 
 One might add the following access procedure and internal 
 procedure between lines 19 and 20. 
 
 19.1 integer procedure glorp(n,p) ; value n,p; integer n, pointer p; 
 
 19.2 begin 
 
 19-3 if. P = nu ll then leave glorp ( de f ault_value ) 
 
 19.^ else if n=0 then leave glorp (p. entry .item) 
 
 19 • 5 else leave glorp ( glorp ( n-1 , p . entry . next ) ) fi_ 
 
 19.6 fi 
 
 19. T end glorp; 
 
 19.8 integer simple procedure scan(n); value n; 
 
 19.9 integer n «- 0; 
 
 19.10 scan ■*■ glorp(n,head) 
 
 This declares the procedure "scan" which may be used to non 
 destructively access any item in the stack. Note that procedure "scan" 
 
 
27 
 
 has an optional parameter "n" "which is assumed to be zero, the top of 
 the stack, if it is not supplied "by the coder (lines 19. 8 and 19.9). 
 
 The recursive procedure "glorp" is local to the "simple" stack 
 definition block and may only be used by the procedures within the 
 definition block. The procedure glorp does the actual search through the 
 stack for procedure "scan". 
 
 "scan(x)" and "scan(X,0) n will both return a value equal to the 
 top element on the stack X. "scan(X,n) u will return element "n" or the 
 default value (zero in this case) of the stack if the stack does not 
 contain an nth entry. 
 
 Access definitions and procedures may redefine the interpre- 
 tation of subscripts. One may follow the formal parameters of an access 
 definition with array parameters . The parameters that appear in the array 
 part need not be arithmetic - they are handled the same as any formal parameter, 
 Example 
 
 access formatted_file (A,B,C) [XL :X2,X3,XU :X5:X6] ; 
 integer A,B,C,(X1,X2,X3,XU,X5,X6) <- 0; 
 
 The array parameters in the access definition define the interpretation 
 and format of the array part of an access declaration. The array para- 
 meters may be declared and defaulted in the same manner that other formal 
 parameters are. The array part parameters are then input in the same 
 fashion as in any other declaration. 
 Example 
 
 formatted_file ■ access (F1,F2) ( 30,30 ,150) , 
 
 F3(30 ,150 ,150) [0:10], 
 
 (Fl+,F5,F6)( 30, 30, 150) [0:2, 13, 10:2:20], 
 
 FA( 30,150 ,150) 
 
28 
 
 Subscripted access variables may appear in OSL/2 code. In 
 each case the appropriate fetch, store, or special access function must 
 have a subscript specification. 
 Example 
 
 definition: 
 
 integer A[0:N,0:N]; 
 access transpose 
 begin 
 
 integer transpose procedure fetch [B,C]; integer B,C; 
 fetch + A[C,B]; 
 
 transpose procedure store (D)[B,C]; integer B,C,D; 
 A[C,B] * D; 
 end 
 declaration: 
 
 transpose X 
 use : 
 
 X[N,M] «- A[N,M] 
 The above access example produces a variable X which, when used as an 
 array, produces the transpose of the matrix A. 
 
 The array facilities in access declarations and definitions 
 allow one to interpret an array subscript as a particular queue or table 
 entry or to imply virtually any other interpretation. Since the number 
 of subscripts in the declaration and the format of the definition need 
 not agree and can be defaulted, a maximum amount of freedom is allowed. 
 
29 
 
 For example, one could declare a special array that took advantage 
 of a subscript declaration with this form: "A:B:C" where an array would 
 he created with indices from "A" to "B" in steps of "C". 
 
 A fifo fetch procedure with the following heading could he 
 written. 
 
 integer fifo procedure fetch [N]; integer N •«- -1; 
 
 One could use the array subscript to specify a destructive or non-destructive 
 
 fetch from the queue if N were -1 (no subscript) then a destructive fetch 
 
 th 
 of the oldest element would proceed. Otherwise, the N element would be 
 
 non-destructively fetched. 
 
 In general the access procedure heading 
 
 Pr(A ,A ,A ...A )[N ,N . . . ,N ; ] 
 d 3 n . d m 
 
 would be called as 
 
 Pr( Vr[N lS N 2 , . . . ,Nj ^A^ . . . ,A n ) 
 where defaults may arbitrarily trim the actual number of N's or A's that 
 appear and Vr is a particular access variable name. The actual parameters, 
 both N's and A's, may be integers, booleans, strings, etc. In particular, 
 the subscripts (N's) need not be arithmetic and need not be interpreted 
 as normal subscripts. 
 
 Access variables can be declared to make complicated table 
 entries, perform formatted i nput/ output , and monitor variables. 
 
 Perhaps one of the greatest advantages of the access mechanism 
 is the ease with which the coder can use it to measure a system. If one 
 uses the access mechanism to perform all stack, queue, and input /output 
 operations, a centralized place is provided to insert instrumentation. 
 One merely adds to the access definition that code which. is desired. It 
 is then easy to keep statistics on virtually every access variable. 
 
30 
 
 Furthermore, it is easy to delete any measurement code once it has served 
 its purpose. 
 2.3. Statements 
 
 2.3.1. Blocks, Compound Statements and Conditional Statements Are 
 Recursively Defined. 
 
 That is, a single statement may contain one or more statements 
 embedded within it. Each of these embedded statements may in turn contain 
 further embedded statements, etc. 
 
 This happens in one of two ways. First, assignment statement 
 may be embedded in expressions which are themselves parts of statement. 
 Second, many statements may be grouped together within a block, compound 
 statement, case statement, or conditional statement. 
 
 If one places several statements end to end, separates them 
 with semicolons and then puts a begin in front and an end at the rear 
 he has a single compound statement. This compound statement is then 
 treated as one statement, not the several of which it is composed. This 
 is especially important when parsing case statements and procedure declara- 
 tions. The compound statement has the following basic form: 
 begin S; S; S; S; S; S;...S; S; S end 
 
 If one takes the statement list previously described, precedes 
 it with a list of declarations separated "by semicolons, and then wraps it 
 in a begin end pair, he has a single block — which is also a single statement, 
 The basic form of a block is 
 
 begin D; D; D; S; S; S;...S; S end 
 
 A case statement and a conditional statement take the same forms 
 as case and conditional expressions (cf. 1.1.6.) except that they select 
 from a choice of statements rather than expressions. Conditional and case 
 statements have the following forms : 
 
31 
 
 if Boolean expression then S ; S ; . . . ; S else S ; . . . ; S f i 
 
 case integer expression of S A ;...S n ; S esac 
 — n-1 n 
 
 2.3.2. Iterative Statements 
 
 Iterative statements take many forms. They are used to 
 control loops. One may step through a loop until some condition is 
 satisfied, incrementing some index, or choosing items from a list. The 
 forms of the iterative statement are generally self-explanatory. In 
 the following forms several abbreviations are used. V is a variable, 
 S a statement, I an integer, B a Boolean, Str a string, Ptr a pointer, 
 Pat a pattern, and E an expression. For example, B.E. is a Boolean 
 expression and I.V. an integer variable. 
 Iterative Statement Forms : 
 
 1) while B.E. do S 
 
 2) do S until B.E. 
 
 3) for I.E. times do S 
 
 k) for V + E Q , E 1 ,..., E g , do S 
 
 In form 1, the Boolean Expression is evaluated and tested. 
 If it is true, the statement following the do is executed and the whole 
 process begins again with a reevaluation of the Boolean expression. 
 If it is false, the statement is skipped and control continues after 
 the iterative statement. 
 
 Form 2 is similar to form 1 except that the statement is 
 executed first. Then the Boolean expression is evaluated. In this case, 
 a false result continues the loop and a true result terminates the loop. 
 
 Form 3 simply specifies that a statement is to be unconditionally 
 executed a fixed number of times. 
 Examples : 
 
 while i < j do 
 
32 
 
 begin 
 
 i +■ i+1; 
 
 some__f unction (i,j) 
 
 end 
 
 do A[i -<- *+l] «- until i = n 
 
 for n times do factorial ««- *#(i ■* *+l) 
 
 Form k actually has many variations. The variable V may "be 
 
 integer, Boolean, string, pointer, or pattern. The types of the expressions 
 
 E_....,E are the same type as the variable V. In the basic form k, the 
 On ' 
 
 variable V is first assigned the value E . Then statement S is executed. 
 Then V is assigned the value E . Then statement S is executed again. 
 This continues through all of the E's. 
 
 If the variable in form k is an integer, some interesting 
 variations are allowed in the E's. In this case the form of the E's 
 may be 
 k.l), I.E. 
 k.2). I.E. to I.E. 
 k.3). I.E. X to I.E.g by_ I.E. 
 k.k). I.E. step I.E. until B.E. 
 k.5). I.E. while B.E. 
 
 Form k.l is identical with a standard form k interaction. Form 
 k.2 specifies that the variable will be stepped from I.E. to I.E. by 
 the increment +1. If I.E. > I.E. no statement will be executed and 
 the next E in the form k iteration expression list will be executed. 
 Form U.3 is the same as k.2 except that an increment is specified. In 
 this case I.E. may be positive or negative and the test for the end of 
 this iteration expression is then made respectively on V > I.E.- or V < I.E.- 
 
33 
 
 Form k.h specifies that V is to be set to I.E. . The Boolean expression 
 is then tested. If it is true this iteration expression is finished. If 
 it is false then the statement S is executed; V ■*- V+I.E. ; and the Boolean 
 expression tested again. Form U.5 specifies that V ■*- I.E. If the Boolean 
 expression is false, no statement is executed — the iteration expression 
 is finished. If the Boolean expression is true, the statement S is executed; 
 V «- I.E.; and a new test is made. 
 
 In the evaluation of the integer expressions above, bad side 
 effects can present themselves. For example, the loop end, I.E. , in 
 form k.2 may be a complex expression that takes significant time to compute 
 each time through the loop. Often times, systems coders desire these 
 effects. However, it is necessary to carefully evaluate each expression 
 and assign it to a separate variable outside the loop if extra computations 
 are to be avoided. Therefore, in each of the forms k.l to U.5 one may 
 write value (I.E.) instead of I.E. If this is written, the I.E. is 
 evaluated only once, at the beginning of each iterative expression, rather 
 than many times (i.e. once for each iteration) for each iteration expression. 
 Examples : 
 
 1. for S [I] + "IF", "NOT", "MAYBE" do S2 +■ *&S[l] 
 
 2. for x +- 1, 2, 3, n step 1 until sqrt (x) < 100*n, 15, l6, 
 
 i t_o value ( j*f (n) ) bv_ 11, x+1 while x<n do print (x,y ,z) 
 
 3. for x ■«- x+1 while x<10 do 
 begin 
 
 if even (x) then x -*- x+1 f i ; 
 test (x) 
 end 
 
3^ 
 
 2.3.3. Assignment Statement 
 
 The assignment statement assigns a value to a variable. These 
 variables may be integers, Booleans , strings, pointers and patterns. 
 Furthermore whole structures and substructures can be assigned new values 
 from another structure or substructure. 
 
 The basic assignment statement has the form 
 variable ■*- expression 
 or 
 
 structure ■+■ structure expression. 
 
 The assignment arrow may be either the symbol "■*■" or ":=". 
 Since expressions can also be assignment statements, the general form of 
 the assignment statement is 
 
 V «- V «e V V «- V «- E 
 
 The evaluation of primaries and subscripts is made from left to right 
 subject to the conventional precedence of operators. The order of 
 assignment is right to left. The order of assignment should normally 
 only be important if access variables appear on the left hand side of an 
 assignment arrow. 
 
 In the case of integer, Boolean, and string assignments, an 
 asterisk convention is allowed. That is, the presence of an asterisk 
 as the very first primary to appear on the right of an assignment arrow 
 denotes the same variable as the variable to the immediate left of the 
 assignment arrow. For example, let x and n be integers and A an array, 
 x ■«- * + 1 is equivalent to x ■*- x + 1 
 x -*- ((**n)...is equivalent to x -*- ((x*n)... 
 
35 
 
 A [x] -*- *+n is equivalent to A[x] ■«- A[x] + n 
 
 n + x-*-* + nis equivalent ton«e-x-«-x + n 
 
 A [x+* + l] -f-* + nis NOT equivalent to A [x <- x+l] «- A [x «e x+l] + n 
 
 it IS. equivalent to A [x + x'+ l] .* A[x] + n 
 
 Note in this last example that the side effect of incrementing 
 x when evaluating the subscript of A is not duplicated on the right. The 
 asterisk notation refers to the identical variable as appears on the left 
 of the arrow not to the same variable expression as appears on the left. 
 
 When assigning values to pointers, the values so assigned 
 must be at the same or higher level as the pointer receiving the value. 
 Thus, if P is a pointer declared in a block that is global to the block 
 in which P is declared, P ■«- P is not allowed but P ■*-?-, is. All 
 formal procedure parameters are considered global to any parameters declared 
 in the outermost block. 
 
 Patterns must also obey the same rules of assignment as pointers. 
 Structures or substructures may receive the values of other 
 structures or substructures provided that there is a complete match of 
 all data types in the respective structures or substructures. 
 Example : 
 
 begin 
 
 structure A ( integer B,C; structure D ( integer A)) ; 
 structure B ( integer X,Y; structure Z ( integer L)); 
 structure C ( integer A) ; 
 A ■*• B; 
 A.D «- B.Z; 
 A.D -e- C; 
 C «■ B.Z 
 end 
 
36 
 
 This is a correct program. Note that A -«- C would not be allowed 
 since A and C have different type structures. 
 2.3.^. Pattern Matching Statement 
 
 The pattern matching statement is the "basic SNOBOL string 
 replacement statement. 
 
 Form: S[ fixed ] P [■*- string expression] 
 
 S is a string variable, P a pattern expression and optional items are 
 enclosed in the metalinguistic square brackets. A pattern matching state- 
 ment is also a Boolean expression which is true if a match is made. 
 
 Several examples would give a quick feel for the power and 
 use of pattern matching statements. 
 
 1. Does the string S contain the letter "A", "B" , or "C"? 
 
 S {"A" I "B" I "C"} 
 
 2. Does S begin with "A", "B" , or "C"? 
 
 S fixed {"A" I "B" I "C"} 
 Note that the reserved word fixed specifies that the patterns must 
 match beginning at the very first character. 
 
 3. Does S contain two "A'"s? 
 
 S {"A" &any& "A"} 
 This pattern match is true if the string S contains the letter "A" 
 followed by any pattern followed by another "A" . 
 k. Replace all occurances of the letter "A" in string S with the digit "l" 
 
 while S {"A"} «- "1" do 
 This uses an iteration statement with a dummy statement. The intent 
 is to repetitively execute the pattern matching statement until a 
 match is no longer made. When a match is made, that part of the 
 
37 
 
 string matched is replaced by the string expression to the right of 
 the arrow. 
 
 5. Some strings "begin with the character "("• If the character ")" 
 occurs later in the string, replace the "(" and ")" by "[" and "]". 
 
 s fixed {"("&{Stemp *■ any }&")"} <- "["& Stemp & "]" 
 In this case a string variable, "Stemp", has been used to store the 
 string matched by the pattern any . "Stemp" thus saves the characters 
 between the parentheses for later use in the string assignment to 
 the matched pattern. 
 
 6. Replace the first occurance of "A", "B", or "C" in "S" followed by 
 any single character with the same "A", "B", or "C" followed by a 
 period. 
 
 S {SI <- {"A" I "B" I "C"} & any(l)} +■ SI & "." 
 This is another instance of saving a partial string for use later 
 in the assignment. Note the optional parameter on the any pattern. 
 This is a pattern that matches any string of characters of length "l". 
 
 7. The following pattern assignment creates a pattern that will recognize 
 an identifier. 
 
 ID <r { span ("ABCDEFGHIJKLMNOPQRSTUWXYZ") 
 
 &{ span ("ABCDEFGHIJKLMOPQRSTUWXYZ0123U 56789") I MT}} 
 The pattern variable "ID" may now be used to scan the string "CARD" to 
 find the first identifier and store the identifier into string "S". 
 
 CARD {S «- ID} 
 Assume that the string "CARD" contains a list of identifiers that 
 should be placed in the array "x" . The following codes would all 
 assign the successive identifiers beginning at "x[l]". 
 
 integer I ■*- 1; 
 
 while CARD { any & {x[l] «- ID}} «- MT do I -e I +1 
 
38 
 
 or 
 
 integer I ■*- ; 
 
 for I ■<- 1+1 while CARD {any_ & {x[l] + ID}} ■<- MT do 
 
 or 
 
 integer I ; 
 
 for I «- 1 step 1 while CARD {any_ & {x[l] «• ID}} + MT do 
 In the above examples, note that a pattern match is attempted 
 on the first part of the string — anything followed by an identifier. 
 If a match is made, the statement is true and the matched part of the 
 string "CARD" is replaced by the empty string. Thus the first identifier 
 is removed from the string so that further tests are not made on 
 previously recognized identifiers. The assignment to the array "x" is 
 performed as a side effect of the pattern match. It is common when using 
 pattern matching statements as the termination condition of a loop, that 
 the statement following the do_ is empty. 
 2.3-5. Procedure Statements 
 
 Procedure statements specify that certain, previously declared, 
 portions of code are to be executed. The OSL/2 procedure statement is 
 similar to the ALGOL 60 procedure statement and similar to the FORTRAN 
 subroutine call. 
 
 The procedure statement consists of the procedure identifier 
 followed by an optional parameter list enclosed in parenthesis . 
 Examples : 
 
 X 
 
 Resequence 
 Call_Subr (A,B,C) 
 Rewind (tape_9) 
 
39 
 
 2.k. Procedures and Functions 
 
 OSL/2 procedures are declared and used in a manner very similar 
 to ALGOL 60 procedures. The primary difference is that default para- 
 meters are allowed in procedure and function calls . 
 
 A procedure declaration consists of a procedure heading 
 followed by a statement. For example, a simple procedure called 
 "add_one_to_A" might have the following declaration. 
 
 procedure add_one_to_A; 
 
 A + * + 1 
 The later occurrence of the statement "add_one_to_A" in the OSL/2 
 program will cause the statement "A -<- * + l" to he invoked. 
 
 The procedure heading may specify some formal parameters to 
 the procedure body (the statement following the procedure heading). 
 Example : 
 
 procedure add_one (x); 
 
 integer x; 
 
 x -*- * + 1 
 In this example the formal parameter "x" is provided for use 
 in the procedure body "x •«- *+l". "x" must be declared in the procedure 
 heading. The procedure heading lists all the formal parameter identifiers 
 This list is enclosed in parentheses and follows the procedure name. 
 Each formal parameter must be declared in the formal parameter specifi- 
 cation. The formal parameter specification is part of the procedure 
 heading and precedes the procedure body. 
 
 The occurrence of the statement "add_one(A) M later in the 
 OSL/2 program will now invoke this procedure with "A" substituted for 
 
ko 
 
 "x" in the procedure body. Thus "add_one(A) n -will cause the statement 
 "A -e *+l" to be invoked. 
 
 Formal parameters may be called by name , by value , or by 
 reference. If they are called by value, their identifiers must appear 
 in the value part of the procedure heading. The value part precedes 
 the formal parameter specification. Formal parameters which are called 
 by name must have their identifiers appear in a name part in the 
 procedure heading. The name part may take the place of, immediately 
 precede, or immediately follow the value part. Parameters which are 
 neither called by name nor called by value are called by reference. The 
 general form of a procedure heading is 
 
 procedure <procedure id>[(<id ,..., id>)]; 
 
 [ value <id> , . . . ,<id> , ; ] 
 
 [ name <id> , . . . ,<id> ; ] 
 
 [ <declaration> ; . . . <declaration> ; ] 
 Where the square brackets are metalinguistic and indicate optional syntax. 
 The positions of the name and value parts may be interchanged. 
 Example : 
 
 procedure add_3(A,B,C,N) ; 
 
 value N; integer A, B,C,N; 
 
 begin 
 
 A «- *+N; 
 B -*- *+N; 
 C ■*■ *+N 
 
 end 
 In this example, the formal parameters "a" , "B", and "C" are called by 
 
Ill 
 
 reference and "N" is called "by value. The statement "Add_3(X,Y,Z ,L+M+Q)" 
 
 is equivalent to 
 
 begin 
 
 int eger N. , n 
 B — internal; 
 
 N. , - + L+M+Q 
 internal 
 
 X +- *+N. , _ 
 internal; 
 
 Y -<- *+N. , 
 
 internal; 
 
 Z «- *+N. . 
 
 internal 
 
 end 
 If the formal parameter "N" was called "by name the statement " add_3(X,Y,X, L+M+Q) " 
 would be equivalent to 
 
 begin 
 
 X «- *+L+M+Q; 
 
 Y -*- *+L+M+Q; 
 Z -t- *+L+M+Q 
 
 end 
 When one calls an actual parameter by name inside the procedure body, 
 the entire actual parameter, with parenthesis around it if necessary, 
 replaces the formal parameter. When one calls an actual parameter by 
 value, the actual parameter expression is calculated once upon entry 
 to the procedure. This calculated value is stored in a variable local 
 to the procedure and all references to the formal parameter are made 
 from and to this local variable. 
 
 Call by value allows one to increase efficiency by eliminating 
 many evaluations of the identical expression and allows one to avoid 
 undesireable side effects. For example, if the actual parameter "N" was 
 
1*2 
 
 "L •*- L+M+Q" in the above example and if "N" was called by name, the 
 equivalent statement to "add_3(X,Y,Z,L «- L+M+Q)" would be 
 
 begin 
 
 X +■ *+(L «■ L+M+Q); 
 Y +■ *+(L +■ L+M+Q) ; 
 Z «- *+(L «- L+M+Q) 
 
 end 
 Note that the value of "L" is continually changed. This may be a bad 
 side effect if unexpected. 
 
 Call by value may be used to keep an external variable from 
 being changed by a procedure call. 
 Example : 
 
 procedure Add_N(A,N) ; 
 
 value N; integer N,A; 
 
 while N «- N-l >= do A ■<- A+l 
 While this may be the hard way to add M N M to "A", it does illustrate how 
 one would protect the value of "X" in the statement "Add_W(X,X) ■". If 
 "N" is called by value, this will double "N" (assuming "N" is positive). 
 If "N" is called by name, this statement would be equivalent to " while 
 X «- X-l = doX + X+l" which is an infinite loop. 
 
 The procedure "Add_N" also demonstrates the illegal statement 
 side effect. "Add_N( X,23+l6 )" is legal if "N" is called by value. If "N" 
 is called by name, this is equivalent to " while (23+l6) <- (23+l6)-l >= 
 do X <- X+l". This clearly has an illegal assignment to "(23+16)" which 
 is not a variable. 
 
^3 
 
 If a parameter is not specified to be called by name or 
 called by value, then it is called by reference. Parameters called 
 by reference are similar to FORTRAN subroutine parameters. If possible 
 a "reference" is a pointer to or an address of a single variable, a 
 structure, an array, a substructure, or a single element of a 
 structure or an array. This "reference" (pointer or address) is 
 calculated once, just before procedure entry. If it is not possible 
 to generate such a "reference" then the actual parameter will be called 
 by value. This is generally the case when a complex expression or 
 procedure call is used as a parameter. 
 Example : 
 
 Assume the following global declarations 
 structure S ( integer X,Y); 
 integer I,L,M,N; 
 integer A[0:10] ; 
 
 structure Big ( integer X,Y [0:10]); 
 procedure P (l,A,S); 
 integer I,A[0:10]; 
 structure S ( integer A,B) ; 
 begin 
 end P 
 Let us call the procedure "P" with the following actual parameters 
 for "I". 
 
kk 
 
 s.x 
 
 ^ 
 
 A[I] 
 
 
 A[I 4- 
 
 1+1] ^ 
 
 Big.S 
 
 .Y 
 
 L 
 
 
 N 
 
 > 
 
 These parameters will have references 
 calculated. Note that each subscript 
 will he computed only once. 
 
 J 
 
 These parameters will be reduced to 
 call by value parameters. 
 
 L+N+M 
 
 I «t- 1+1 
 
 A[I]+A[I+1] 
 
 S.X*N 
 Let us call "P" with the following actual parameters for the 
 
 formal parameter "A 
 A 
 
 References will be calculated 
 
 Let us call 
 formal parameter S 
 S 
 Big.S 
 
 Big.Y for these arrays. 
 
 'P" with the following actual parameters for the 
 
 References will be calculated 
 for these structures . 
 
 if I<L then S else Big.S fi 
 
 These structure expressions 
 will be called by value. 
 
 case I of S, Big.S, Big.S esac 
 
 In systems programming, one frequently calls a procedure with 
 
 many parameters such that one or two of these parameters are varied and 
 
 the others are usually the same. OSL/2 allows one to specify a default 
 
h5 
 
 parameter for a formal parameter by initializing the formal parameter 
 in the formal parameter specification. 
 Example : 
 
 integer standardjpriority ■*- 25, 
 
 standard_core -*- 15000, 
 
 standard_time «- 36OO, 
 
 standard_lines -*- 10000; 
 
 « 
 • 
 
 procedure insert_in_job_Q ( Job , priority, core , time , lines ) ; 
 value Job , priority , core, time, lines , 
 structure Job ( integer type, steps__completed; 
 
 Boolean TTY_Job ) ; 
 integer priority ■*■ standard_priority , 
 core *- standard_core, 
 time ■*- standard_time , 
 lines ■*- standard__lines ; , 
 begin 
 end 
 When one calls a procedure, he may specify default values 
 by leaving the actual parameter position empty, inserting an asterisk, 
 "*", or by eliminating the parameter position if it is the last part of 
 the parameter list. The following calls are then all equivalent: 
 insert_in_job_Q (J[23]) 
 insert_in_Job_Q ( J [23 ],*,,) 
 insert_in_job_Q ( J [23] , ,standard_core,*,*) 
 insert_in_job_Qn(j[23] ,standard_priority , standard_core, 
 
 standard_time, standard_lines) 
 
k6 
 
 When an initialization appears in a formal parameter specification, an 
 actual parameter equal to the initialization is constructed. This is 
 saved and inserted at any later procedure statement when a default 
 value for this parameter is desired. The specification of a default 
 parameter is a flag to the compiler. It does not generate any additional 
 code in the procedure "body. 
 
 To further aid the specification of parameters, a key word 
 facility is provided. A particular actual parameter may be input to 
 a procedure by default, by placement in the appropriate position of the 
 ordered actual parameter list or by specifying the formal parameter 
 identifier followed by a colon and the actual parameter. Keyword actual 
 parameters need not appear in any particular order. They do however, 
 occupy one position each in the ordered actual parameter list. There- 
 fore, if a keyword actual parameter is used, the parameter position it 
 occupies must be specified elsewhere as a keyword actual parameter or 
 it must be defaulted. 
 Examples based on the previous procedure "insert_in_Job_Q" : 
 
 insert_in_job_Q (j[23], Time: standard_time, standard_core) 
 insert_in_job_Q (core: standard_core, standard__priority , 
 
 Job:J[23]) 
 insert_in_job_Q (j[23], priority: standard_priority) 
 All OSL/2 procedures are reentrant. In order to allow one pass 
 compilation, all procedures and data must be declared before they are used. 
 This would cause a significant problem if one had a procedure A which 
 invoked procedure B and B could also invoke A recursively. The forward 
 procedure declaration is used to provide the information the compiler 
 
hi 
 
 needs to compile calls on a procedure without compiling the procedure 
 
 body of A which contains the call on the as yet undeclared procedure B. 
 
 In the forward procedure declaration, the procedure heading is complete, 
 
 but the procedure body is replaced by the reserved word " forward" . 
 
 The complete declaration of the forward procedure must follow later with 
 
 a statement for the procedure body. 
 
 Example : 
 
 procedure A(N) ; value N; integer N; forward ; 
 
 procedure B(M,N) ; integer N S M; 
 
 begin 
 
 A(M); 
 
 end ; 
 
 procedure A(n) ; value N; integer N; 
 
 begin 
 
 B(Q,R) 
 
 end ; 
 
 9 
 
 Occasionally, a procedure is a formal parameter to a procedure. 
 In this case, the complete procedure heading must be provided in the 
 formal parameter specification. However, the reserved word " formal" 
 will be used as the procedure body. 
 Example : 
 
 procedure add (A,B,C) ; integer A,B,C; A * B+C; 
 procedure sub (A,B,C) ; integer A,B,C; A ■*■ B-C; 
 procedure either (operation, X,Y,Z); 
 integer X,Y,Z; 
 procedure operation (X,M,A); integer X,M,A; formal : 
 
U8 
 
 operation (X,Y,Z); 
 integer (L,M,N) «- 0; 
 
 either (add, L,L,l); 
 either (sub, L,M,N) ; 
 
 A function is a procedure that can return an integer, Boolean, 
 string, pointer, pattern, or structure value. Functions may thus he 
 used as primaries in expressions. 
 
 A function declaration has a type designation preceding a 
 procedure declaration. Any substructure information or string parameter 
 information must be part of this type designation. 
 Example : 
 
 integer procedure a(X,Y,Z);... 
 Boolean procedure b(X,Y) ; . . . 
 string procedure c(x) ; . . . 
 string (N,M) procedure d(X,y); 
 string (lengthl) procedure e(x) ; . . . 
 pointer procedure f(x,y);... 
 pattern procedure g; . . . 
 structure (integer A,B; 
 
 structure X( pointer left, right; string name) ; 
 structure Y( integer A,B,C) ; 
 Boolean bl,b 2) procedure Svalue (x,y);... 
 To leave a procedure body, one either executes the entire 
 body and exits at the last statement, or he executes an escape statement, 
 In a procedure the escape statement is simply the reserved word leave 
 
h9 
 
 followed by the procedure name. When leaving a function, the escape 
 statement may have an expression enclosed in parentheses following it. 
 Examples : 
 
 leave sqrt(23) 
 
 leave sfl("ABC") 
 
 leave Calc (A+B/16) 
 These escape statements return a value for the function as they exit 
 the procedure body. 
 
 It is possible to have the procedure identifier appear on the 
 left hand side of an assignment statement within the procedure body. 
 This assignment statement assigns an interim value to the function. 
 If, later, an exit is made via the end of the procedure body or with a 
 simple escape statement (not followed by an expression) then the last 
 such interim value assigned is returned as the function value. 
 Example : 
 
 integer procedure add (A,B) ; integer A,B; 
 
 add -*■ A+B; 
 2.5- Control Concepts 
 2.5.1. Escape Statements 
 
 The go to statement has been excluded from OSL/2. In its 
 place is the escape statement "leave", which exits one or more statements. 
 
 The escape statement used to exit a procedure body has already 
 been described. 
 
 The labelled leave statement is used to exit a statement. In 
 order to leave a statement, a label must be provided in front of and after 
 the statement. A colon separates the label from the statement. 
 
 form: label: statement : label 
 
50 
 
 The leave statement is the reserved word leave followed "by a label. 
 Example : 
 
 outter: while a<b do 
 
 inner : begin 
 
 leave outter; 
 
 leave inner; 
 
 end : inner : outter 
 The occurrence of a label after a statement is required for documentation 
 purposes only. The first label determines the parse. 
 
 The label in a leave statement may be global to the block or 
 procedure body in which the escape statement appears. 
 2.5.2. Semaphores 
 
 Semaphores were introduced by Dijkstra [xh] for the synchroni- 
 zation of parallel processes. Habermann [15] has proven that P and V 
 operators on semaphores are sufficient to safeguard any critical sections 
 of system code. 
 
 A semaphore is a special purpose integer variable. Semaphores 
 are declared analogously to integers. The reserved word semaphore replaces 
 the reserved word integer . 
 Example : 
 
 s emaphore a,b ,c ,(d,e,f ) ■*■ l,x,y,z ■<- 0,q,r,s 
 Semaphores are normally initialized to zero unless otherwise specified 
 in their declaration. 
 
 The only operations that may be performed on semaphores are 
 P and V (written "P(s) M and "V(s) n where s is a semaphore). 
 
51 
 
 When a process performs the operation P(s), the semaphore s is 
 decremented by one (s -«- s-l) . If the decremented value of s is negative (s<0) 
 then the process is blocked and is booked on a waiting list. 
 
 When a process performs the operation V(s), the semaphore s is 
 incremented by one (s <- s+l). If the value of s is positive (s>0) then 
 no further action is taken. If the value of s is non-positive (s_<0) then 
 one or more processes were blocked and are booked on a waiting list. In 
 this case one process is removed from the waiting list and may now proceed. 
 
 P and V operators can be used to implement complex waiting 
 queues and priorities. Therefore, the primitive queuing algorithm is not 
 specified. Eegardless of the original queuing algorithm on a single 
 semaphore, a new one can be built through the use of one or more semaphores. 
 
 P and V provide access to critical code or some system resource. 
 To implement any scheduling scheme on x, one could introduce a process X 
 which schedules x. A process which desires x would then use one sema- 
 phore to pass this request to X and another to block its continuation until 
 x was available. 
 Example : 
 
 P(msg) ; seize message path to X 
 
 ! send message to X requesting x 
 
 V(msg) ; release message path to X 
 
 P(x i ) 
 
 seize x 
 
 use x 
 
 P(msg) ; seize message path to X 
 
 send message to X releasing x 
 V(msg) ; release message path to X 
 
52 
 
 Note in the above example that each process would use the "msg" semaphore 
 to communicate with X but each process would use a different semaphore 
 (indicated by x. ) to block its access to x. The process X would perform 
 any necessary V(x. ) to permit a particular process (the i process to 
 which semaphore x. refers) to have access to x. Clearly, X can implement 
 an arbitrary booking and dispatching algorithm for x. 
 2. 5.3. Processes 
 
 OSL/2 processes are separately running, asynchronous procedures 
 or programs. Six primitives control these processes: spawn , append , 
 initiate , suspend , restart , and terminate . 
 
 The spawn primitive allows one to spawn, from inside a process, 
 another process which will run at the same level as the spawning program. 
 The spawning program and spawned program have no special relationship. 
 If the already executing process A of operating system OS spawned 
 process B the relationships would be diagrammed as follows. 
 
 A B 
 OS 
 Any parameters passed to the spawned process are called by value if they 
 are defined within the spawning process. 
 Examples : 
 
 spawn (program) 
 
 spawn (routine (x,y,z)) 
 
 A process may append a procedure. An appended procedure has 
 access to all normally addressable constructs. A process may not leave 
 a block until all procedures appended in that block have returned. 
 Appended procedures run asynchronously with the appending process. 
 
53 
 
 Example : 
 
 "begin 
 
 integer (A,B,C) [0 :9] , X,Y,Z,N «- 9; 
 procedure innerjproduct (A,S) \ integer AlOjN] ,S \ 
 begin 
 
 integer sum ■*- ,i ; 
 
 for i to N do sum *■ sum + A[i]*A[iJ; 
 
 S •*• sum 
 end ; 
 
 append (inner_product(A,X) ) ; 
 append (inner product(B,Y) ) ; 
 inner-product ( C , Z ) ; 
 end 
 In this example three processes would be running simultaneously. 
 Two new processes would be created to perform the procedure "inner product" on 
 arrays "A" and "B" , and the original process would calculate "inner_product" 
 of "C". All three processes have access to the same global variable "N" 
 but each inner product procedure has its own local variables "i" and 
 "sum" which are not addressable by the other processes. 
 
 Initiate creates a new process that is to be monitored by 
 the initiating process. The new process may not directly address constructs 
 within the initiating process. All communication to the initiating process 
 must take place through the primitives defined by the initiating process 
 and any parameters passed to the process. A process variable is attached 
 to each such process. The process variable is used to "suspend", "restart", 
 and "terminate" the initiated process . 
 
5h 
 
 Example : 
 
 process pl,p2,p3; 
 
 initiate (program, pi); 
 
 initiate (program, p2); 
 
 initiate (user job (l0,file_23) ,p3) ; 
 
 suspend (pi) ; 
 
 suspend (p2) ; 
 
 restart (p2) ; 
 
 terminate (p3) ; 
 
 If a terminate statement appears in a process without a process variable 
 for a parameter, then the process in which the statement is executed is 
 terminated. 
 Example : 
 
 terminate 
 2.5- 1 +. Traps 
 
 Traps are special conditions that arise in the course of 
 executing an operator. For example, divide by zero or index out of 
 range. If desired a procedure may be executed to handle the special 
 condition. 
 Examples : 
 
 on index terminate 
 
 on overflow leave overflow (99999) 
 
 on divide_by_zero (Numerator) leave divide_by_zero (Numerator' 
 Traps vary from machine to machine. Therefore, each OSL/2 implementation 
 must define reserved or key words for each such trap. The trap declaration 
 
55 
 
 consists of the reserved word on followed by the trap condition followed 
 by an optional set of parameters followed by a statement. The parameters 
 contain pertinent information about the environment. For example, an 
 implementation might return the value of an index causing an index fault 
 and also the array bounds involved. While index out of range, integer 
 overflow, and divide by zero are clearly required in OSL/2, the definition 
 of the trap environment (i.e. trap parameters) is left to each implementation, 
 
 The trap facility allows a way of specifying special operators 
 for a microcoded machine or perhaps a way of changing the semantics 
 of existing operators. For example, one implementation might allow a 
 trap on all integer divides so that the coder could define the semantics 
 of divide. 
 2.5-5- Primitives 
 
 The reinterpretation of the primitives between system layers 
 is frequently implementation dependent. While OSL/2 specifies the manner 
 in which reinterpretation will be performed the actual specification of 
 a primitive may vary from installation to installation. 
 
 In general, the scope of primitive declarations is the same 
 as for normal procedure declarations with the following extensions. 
 Within the declarations at the head of a block, all access to a primitive 
 made lexicographically prior to the new declaration of a primitive are 
 valid and will access the old primitive. Furthermore, the types of 
 primitive functions must be maintained. Therefore, it is not permitted 
 to change ptr (x) from a pointer primitive to a string primitive. 
 
% 
 
 Example : 
 
 begin 
 
 integer X[0:10000]; 
 
 pointer primitive allocate ( ) ; 
 
 integer A[0:100] 
 end 
 In this example, an implicit call on the old primitive " allocate" is 
 performed to allocate the array "X". Note that the reserved word 
 primitive is used in place of the reserved word procedure when 
 redefining a primitive. Once "allocate" is redefined, all allocation 
 will be performed by the new primitive. Thus the array "A" will be 
 allocated by the new primitive. Since the only space addressable 
 by the primitive "allocate" is the array "X", "A" must be allocated 
 inside of "X" . Furthermore, any processes which are appended or 
 initiated (but not spawned) within the scope of the new allocate must 
 use the new allocate. 
 
 The number and type of the parameters into which a compiler 
 will map an allocate statement is not defined. OSL/2 originally had a 
 data type "core" into which allocations could be made. This facility 
 was deleted because it restricted the class of addressing schemes allowed 
 in the hardware. In order to permit the maximum flexibility for future 
 technological developments, such as cheap content addressed memories, the 
 manner of allocation and the format of the parameters are left undefined. 
 
 Most of the arithmetic function primitives will not be changed. 
 The allocate, release, and terminate primitives might be in a normal 
 system. The primary use of the primitive construct will be to define 
 
57 
 
 additional primitives for use at higher levels in a multi-layer operating 
 
 system. 
 
 2.6. Compile Time Facilities 
 
 Operating system codes have a strong need for a parameterized 
 macro facility and some conditional compilation. These facilities allow 
 a significant isolation of changeable parameters and they also allow a 
 programmer to write and document a single system that has several, 
 possibly conflicting, portions that are conditionally inserted on an 
 installation by installation basis. 
 
 The define facility used in Burroughs B5500 [23] and B65OO [2k] ALGOL 
 is used in a slightly modified form in OSL/2. One may define a string 
 value for an identifier. 
 Examples : 
 
 define ABC = begin 
 
 A + 0; 
 B •*- N; 
 C «- M 
 end #; 
 define Xsize = 100#,Ysize = 37#; 
 The "=" and "#" bracket the string. The appearance of the defined 
 identifier later in the block in which it is defined will cause the 
 identifier to be replaced by the characters enclosed in the "=" "#" 
 brackets. 
 
 In the above example, A -<- Xsize is equivalent to A* 100. 
 Defined identifiers may appear in defines nested to any level. 
 Furthermore, defines may appear within defines, " define identifiers . .#" 
 is considered a bracket construct that may appear in a define. 
 
58 
 
 Defines may have parameters. 
 Examples : 
 
 define add (A,B) = ($A)+($B)#; 
 
 define concat (A,B) = "$A$B"#; 
 In the above cases, add (lO*L,13) is equivalent to (lO*L)+(l3) and 
 concat (ABCjDEF) is equivalent to "ABCDEF". 
 
 The dollar sign ($) denotes compile time facilities. One 
 may declare compile time Booleans , integers, and strings. 
 Example : 
 
 $ integer A,B,C,D +■ 10 ,E; 
 
 $string (S1,S2) <- MT; 
 These variables must be preceeded by the dollar sign when they are 
 used. An assignment to a compile time variable is made at the time 
 it is scanned. The expression assigned must therefore be calculable 
 at compile time. A compile time variable which appears in an expression 
 is replaced by a constant whose value is the same as the current value 
 of the variable. 
 Examples : 
 
 $A «- $D+1; 
 
 X + 10 + $A*$D; is equivalent to X <- 10 + 11*10; 
 Most 0SL/2 statements may be compile time statements. 
 Examples : 
 
 $if $A<10 
 
 then . . . 
 
 else . . . 
 
 fi 
 
 $for $A «- 1,13,2 do X[P(QRZ),$A] «- L*13 
 
59 
 
 In both of the above examples , the $ if and $for did not require the 
 "$". In the if case, the expression being tested "was a constant, 
 therefore, a good compiler would only have compiled one branch of the 
 conditional anyway. In the case of the for statement, the use of 
 a compile time variable as the iteration control variable indicated 
 that the statement was a compile time statement. The for statement 
 is equivalent to: 
 
 X[P(QHZ),1] «• L*13; 
 
 X[P(QRZ),13] «■ L*13; 
 
 X[P(QRZ),2] *■ L*13 
 while . . .do. . . , do . . . until . . . , and for . . . times do . . . always must be 
 preceded by a dollar sign if they are compile time statements. 
 
60 
 
 Chapter 3 
 System Measurement, Modification, and Debugging in an OSL/2 Environment 
 
 Operating systems are not static. They are constantly being 
 changed. These changes either improve the efficiency of the system, 
 add features to it, or correct errors. , 
 
 When new systems are coded, the most significnat question 
 facing the implementor is: "How well does it run?" This question is 
 answered predictively by a closed form analysis of the system or by 
 simulation. Once implemented, the question is answered by measuring the 
 system. 
 
 Due to the complex interaction of system modules, and the 
 stochastic nature of the inputs a closed form prediction of the perform- 
 ance of an entire operating system is usually not possible. However, 
 many individual modules in a system may be amenable to some greater or 
 lesser degree of analysis. 
 
 Simulation is more commonly used when predictive estimates of 
 an entire system's performance are desired. Unfortunately, it is usually 
 very difficult to accurately estimate the loads on a system. If one 
 assumes, however, that an accurate model of the system is available, then 
 it is certainly reasonable to run this model in a variety of modes and 
 under a variety of loads. In this manner, the areas of competence and 
 incompetence of the system can be discovered a priori. This information 
 can then be used by the managers of an installation to make the loads placed 
 on a system fall in the area of the operating system's greatest competence. 
 
 The strict isolation of processes and the nature of the synch- 
 ronizing primitives P and V in OSL/2 make OSL/2 a reasonable simulation 
 
6l 
 
 language. Therefore, it is possible to avoid a separate simulation step 
 by using OSL/2 for both the simulation and the final system code. 
 
 OSL/2 has no concept of an interrupt. Systems coded in OSL/2 
 are command driven. That is, they consist of separate processes for 
 each task to be performed. Each task uses the P and V operators to get 
 and dispatch •work. Therefore, each process is either waiting for a 
 command to begin work (P operation), issuing a command to another task 
 to begin work (V operation), or performing its function. 
 
 Since OSL/2 systems have well defined interfaces to both the 
 outside world and internal processes, it is a relatively straight- 
 forward (although frequently tedious) procedure to simulate an OSL/2 
 coded system in total or in part by appropriately setting global variables 
 and issuing P and V operations to the various semaphores of the system. 
 
 The generalized data access facilities of OSL/2 allow access 
 to every transaction performed on any data declared with this facility. 
 Therefore, one may specify virtually any information he wants recorded 
 on access data, the manner of recording, and the manner of read out. Since 
 this is done only once, in the access definition, a single place is pro- 
 vided where all measurements of queues, stacks, tables, etc. may be 
 inserted and deleted. This facility allows the system designer, subject 
 only to the constraint of the Heisenberg Uncertainty Principle, to readily 
 measure an OSL/2 coded system a priori during simulation or a posteriori 
 after implementation. 
 
 Changes to an OSL/2 coded operating system may take place in 
 several ways. The generalized data access facilities provide an easy 
 way to change queuing algorithms and add special features to complex data 
 
62 
 
 structures. One may add new facilities "by adding a new primitive to an 
 existing system or "by introducing a new layer to the system and adding 
 the additional feature in the new layer. This latter technique is 
 especially desirable if one has a well functioning piece of code which he 
 does not want disturbed. Adding the new layer to the system, leaves 
 the original system undisturbed. Furthermore, the new layer is trans- 
 parent to layers above which are using the primitives in the older, 
 lower system. 
 
 Since OSL/2 code can express only nested loops and procedures 
 and cannot express interlocking loops with deliberate transfers to 
 various portions of code and returns via indexed and non indexed go to ' s , 
 the code tends to be more clearly structured and therefore easier to 
 debug. However, it is still possible to write bad code and design bad 
 logic. OSL/2 does not attempt to solve the coding or logic error problem. 
 The generalized data access facilities provide a sophisticated data moni- 
 toring tool of considerable power. However, no special debugging facili- 
 ties have been added to the language. 
 
 Balzar has done some excellent work with EXDAMS [20] on a 360 
 PL/l system. EXDAMS provides a method of keeping a history of a program's 
 execution. After a run is completed, this history is coupled to a graphic 
 display which is used to selectively examine variables and run the program 
 backwards as well as forwards to discover where errors lie. This history 
 has links between the execution variable and time space and the source 
 program space. These links are used to immediately see which program 
 statements caused the actions indicated on the graphic display. OSL/2 
 is amenable to this treatment as are most higher level languages. 
 
63 
 
 In general OSL/2 appears to be a powerful language for coding, 
 expanding, and measuring an operating system, While OSL/2 tends to be 
 cleaner and thus easier to debug, special debugging features have not 
 been provided. 
 
6k 
 
 Chapter U 
 The Hardware Requirements of OSL/2 
 
 It was the original intention of the author to design and 
 simulate an OSL/2 machine. That is, a machine especially suited to 
 executing OSL/2 code. This project was not completed for three reasons. 
 First, the amount of machine time required to build and run a simulator 
 was not available. In fact, the author was requested to sharply reduce 
 the machine time spent building an OSL/2 compiler. Second, the human 
 time required to design the OSL/2 machine in detail and to code a simu- 
 lator was significantly underestimated by the author. Third, since the 
 author had gone through the exercise of designing the language with an 
 actual implementation in mind, it is doubtful that the completion of an 
 implementation would significantly alter the concepts in OSL/2. 
 
 The author actually wrote OSL/2 code, wrote an OSL/2 compiler, 
 and designed the language with a particular hardware implementation in 
 mind. The coding of a compiler and the resulting object machine consider- 
 ations had their primary impact on the syntactic description of the lan- 
 guage. Similarly, the production of OSL/2 code changed the syntax again. 
 The only concept significantly altered was the ability to pass whole 
 declarations into access definitions as parameters to be supplied at 
 access variable declaration time. The intent was to allow the programmer 
 to describe a data independent access technique and introduce the actual 
 types of data after the definition of the access type. For example, this 
 would enable a programmer to define a first in first out queue and at 
 declaration time describe the data being entered and removed from the queue, 
 
65 
 
 This proved to be quite difficult to implement. Later codes showed that 
 this feature was still desirable but the language was not badly hurt by- 
 its absence. 
 
 The author had had experience with a large number of machines 
 of first through fourth generation architecture. The ease with which 
 one could compile code for Burroughs machines and the similarity between 
 higher level language constructs and the machine operations in the B5500 
 and B65OO originally prejudiced the author toward those designs. 
 
 The OSL/2 compiler assumed that the object machine, like a 
 B65OO, was a zero address stack machine with each word in memory tagged 
 to indicate the type of its contents. Furthermore, a block level relative 
 addressing scheme with arrays indexed via B6500-like descriptors was 
 assumed [21]. This made the object code relatively easy to produce. 
 However, the author soon discovered that the isolation of types (i.e. 
 they could not be mixed in expressions) and the explicit coding of type 
 transfer functions made the use of tagged words to distinguish types 
 unnecessary. Furthermore, since OSL/2 procedure declarations require 
 the complete specification of all parameters, the compiler can check 
 at compile time for the erroneous passing of parameters and procedures 
 to procedures. Thus the compiler knows at all times exactly which types 
 it is working with. In this case, most of the type tags on words were 
 necessary only to protect the system from compiler errors and not to 
 aid the compiler. 
 
 Virtually all of the OSL/2 constructs can be implemented on any 
 machine upon which FORTRAN may be implemented. The exceptions are call 
 by name procedure parameters and the process control primitives. 
 
66 
 
 With the exception of the Burroughs compilers , call by name 
 has been a problem since it was first introduced in ALGOL 60. The normal 
 solution has been the "thunk". Since call by name parameters are evaluated 
 each time they are referenced in a procedure, a procedure call, or "thunk", 
 is substituted for the reference. Then each time a store or fetch is to 
 be made, this procedure is executed to produce an address or value. On 
 the B5500 and B65OO a hardware operand call is made. The tag bits of the 
 operand tell the computer whether a simple fetch or procedure entry and 
 complex expression analysis must be performed to produce a value. The 
 operand call instruction is much more complex than the most intricate 
 instructions on conventional machines. It does, however, replace a "thunk" 
 with a single hardware operator of much greater efficiency. 
 
 Call by name is a concept absent from most languages. It is 
 included in OSL/2 for two strong reasons. It allows the use of side 
 effect processes in a simple way. The concept of a continuously evaluating 
 expression for use in calculating process priorities is an example of how 
 this feature could be well used in operating system codes. Also, it is 
 the nature of access data that they produce complex side effects when 
 they appear in expressions. A call by name concept is required if expres- 
 sions containing access variables are to be passed to procedures. 
 
 In order to produce an efficiently running OSL/2 machine it is 
 considered essential that the hardware provide a call by name facility. 
 Such a facility seems to be easier to implement on a stack machine than 
 a normal multiregister machine. This is because of the ease with which 
 evaluation procedures may be automatically entered and the process environ- 
 ment saved in the stack. To enter a procedure and save the process 
 
61 
 
 environment is a more difficult matter in a register machine where the 
 process environment may be determined by an arbitrary number of the 
 registers. 
 
 The problem of inter layer communication is severe. No hard- 
 ware known to the author is capable of both allowing access to variables 
 in the system at all levels, yet rigorously assuring that variables are 
 not inadvertently altered by an erroneous compiler or operating system. 
 Ordinary relocation and bounds protect or virtual memory addressing 
 will not work. 
 
 If some layer of the operating system makes a mistake while 
 setting the bounds register or relocation register — all is lost. In a 
 similar manner, a virtual memory system might have an error made while 
 its segment table was set up. However, a few extraordinary techniques 
 help solve these problems. For example, the register loading or segment 
 address loading instruction could be made a special operator that worked 
 only with an already set relocation and bounds register or an existing 
 segment table. The operator could be designed to not create any segment 
 address or register setting that would violate the existing settings. 
 Thus one could guarantee that higher layers of the system would not 
 inadvertently bomb lower layers if the lower layers properly initiated 
 the upper layers. Techniques like these can be used to remove the concept 
 of priviledged instructions from a machine. Each operator is constructed 
 so it has a built in check that prevents it from violating its own 
 environment. Thus any operator (instruction) in the machine can be allowed 
 at any level. 
 
 Where this scheme falls on hard times is in the passing of para- 
 meters between system layers. How does system layer three pass a file 
 
68 
 
 and an integer to system layer ten for its use without allowing access to 
 all of layer three's variables? The setting of protection bits clearly 
 gets immediately out of hand if layer 3 frequently gets control of layer 
 10. Then the setting and resetting of protection bits becomes a very 
 significant overhead. 
 
 The author feels that the solution to these problems lies in a 
 suitably defined addressing scheme. An addressing scheme where it is 
 simply not possible to generate an address outside of one's allowed space. 
 
 The addressing scheme will be described in several steps. First 
 in terms of a single program, then in terms of a program with several 
 asynchronous processes, and finally in terms of a multilayered operating 
 system. 
 
 A stack machine is assumed with several level registers. Each 
 level register points to the base address of a block level in an OSL/2 
 program. 
 Example : 
 
 
 1 — begin 
 
 
 integer a,b,c; 
 
 
 Boolean X; 
 
 o 
 
 
 o 
 o 
 
 H 
 
 H 
 
 M 
 o 
 o 
 
 H 
 
 — enc 
 
 1 — begin 
 
 string s,m,y 
 
 — end; 
 L 
 
69 
 
 BASE OF STACK 
 RELATIVE ADDRESS 
 
 6 
 
 5 
 
 4 
 
 3 
 
 2 
 
 I 
 
 
 
 LEVEL REGISTER, 
 DISPLACEMENT COUPLE 
 
 (1,2) 
 
 (1,1) 
 
 (1,0) 
 
 (0,3) 
 
 (0,2) 
 
 (0,1) 
 
 (0,0) ( 
 
 STACK 
 
 LEVEL REGISTER 
 
 BASE OF STACK POINTER 
 
 y 
 
 
 m 
 
 
 s 
 
 
 
 X 
 
 
 c 
 
 
 
 b 
 
 
 LEVEL 1 = BASE + 4 
 
 
 
 a 
 
 
 LEVEL = BASE+O 
 
 
 
 
 Figure 1. Variable stack "while in block 1, 
 
 In order to address the variable "a" in block the address 
 couple (0,0) "would be used - level 0, displacement 0. To address the 
 variable "c", the address couple (0,2) is used - level 0, displacement 
 2. Similarly, the variable "m" in block 1 is (l,l) - level 1, displace- 
 ment 1. One could even put bounds on each level register to prevent 
 inadvertent addressing into the next higher level. Then one would have 
 
TO 
 
 a set of miniature relocate and bounds registers. Actually, this is not 
 necessary but desirable. In fact, the entire program stack is an array 
 with bounds protect and a base of stack pointer. Furthermore, the 
 distinction between levels is made more clear by inserting special data 
 into the stack at each break in a level to indicate the old value of a 
 level register. This is necessary when doing recursion. This additional 
 data is used to pass parameters to procedures. 
 Example : 
 
 — begin 
 
 integer a,b ,c; 
 
 procedure addl (x,y) ; integer x,y; 
 — begin 
 
 integer Z; 
 Z ■*- 1; 
 x ■«- y+Z 
 •— end addl: 
 
 — begin 
 
 integer m 
 — begin 
 
 integer n 
 
 i— begin 
 
 m 
 
 integer r,s 
 
 addl (r,m) ; 
 
 en< 3- 
 
 •— end 
 
 •— end 
 
 1 — end 
 
71 
 
 or 
 
 u 
 
 i- 
 co 
 
 C9 
 
 UJ 
 
 hi 
 > 
 hi 
 
 -J 
 
 CO 
 M 
 
 JO 
 
 -J 
 
 hi 
 
 > 
 UJ 
 
 to 
 
 N 
 
 CVJ 
 
 -1 
 
 UJ 
 
 > 
 
 UJ 
 
 UJ 
 
 > 
 
 UJ 
 
 -J 
 
 o 
 
 II 
 
 o 
 
 -J 
 
 UJ 
 
 > 
 
 UJ 
 
 5C 
 o 
 
 CO 
 
 UJ 
 
 _l 
 
 0. 
 OC => 
 UJ O 
 
 r- O 
 
 ro cj 
 
 c\j_ — 
 ro ro 
 
 cvt 
 
 ro 
 
 o" 
 
 CVJ — 
 
 o cT 
 
 UJ 
 
 UJ 
 
 > 
 
 UJ 
 
 0. 
 
 to 
 
 CO 
 
 vr CO 
 
 CO 9 
 
 u. 
 
 o UJ 
 
 > 
 
 UJ 
 
 o 
 
 o 
 
 < 
 
 r- 
 co 
 
 UJ 
 CO 
 
 < 
 
 CO 
 
 ro 
 
 CVJ — 
 
 CD CD 
 
 h- 
 
 m <t 
 
 ro 
 
 cm 
 
 H 
 
 03 
 
 <u 
 o 
 o 
 
 fn 
 
 0) 
 
 -p 
 
 a 
 
 •H 
 
 a; 
 
 -p 
 
 U 
 0) 
 
 p 
 
 a3 
 
 M 
 
 o 
 
 a? 
 -p 
 
 W 
 
 ■s 
 
 •H 
 
 CD 
 
 •H 
 
 CO 
 
 CO 
 
 UJ 
 
72 
 
 CO 
 co 
 
 UJ 
 
 o 
 o 
 or 
 o. 
 
 o 
 
 UJ 
 
 Q 
 
 o. 
 
 0. 
 
 co 
 
 QC 
 UJ 
 
 I- 
 
 CO 
 
 <3 
 
 UJ 
 
 or 
 
 _J 
 
 UJ 
 
 > 
 
 UJ 
 
 CO 
 CO 
 UJ 
 
 o 
 Oct 
 
 % 
 
 UJ o 
 
 §2 
 
 UJ CO 
 
 0. 
 
 0_ 
 
 < 
 
 CO 
 
 CO — . 
 Ul O 
 
 o 3 
 
 0T ^ 
 
 a. 5 
 
 ?? 
 
 < to 
 
 
 CO 
 
 CO 
 CO 
 
 or 
 
 Ul 
 
 M 
 
 t- 
 
 o 
 
 O 
 
 CO 
 
 o 
 
 C£ 
 
 UJ 
 
 O. 
 
 or 
 
 2 
 
 _i 
 
 < 
 
 UJ 
 
 2 
 
 > 
 
 UJ 
 
 E 
 t- 
 
 UJ 
 
 2 
 
 CO UJ 
 
 uj o 
 to < 
 
 CO 
 Ul 
 
 or 
 
 o 
 o 
 
 < 
 
 0. 
 CO 
 
 E c 
 
 c t- 
 
 = Ul 
 
 -• 2 
 
 uj e> 
 
 i- < 
 
 o or 
 
 r— ' 
 
 t— » 
 
 O 
 
 o 
 
 
 
 _ 
 
 o 
 
 L_J 
 
 ' -» 
 
 II 
 
 n 
 
 — 
 
 O 
 
 -I 
 
 -1 
 
 UJ 
 
 Ul 
 
 > 
 
 > 
 
 UJ 
 
 Ul 
 
 -J 
 
 -1 
 
 CO 
 
 CO CO 
 
 Ul I- 
 
 O Z 
 
 O Ul 
 
 £ 2 
 0. o 
 
 Ul u. 
 
 o 
 
 Z X 
 
 Ul o 
 0. ft 
 
 
 o 
 
 1- 
 
 \- 
 
 z 
 
 z 
 
 Ul 
 
 Ul 
 
 2 
 
 o 
 
 5 
 
 < 
 
 < 
 
 or 
 
 or 
 
 u. 
 
 u. 
 
 \ \ 
 \ \ 
 
 
 
 
 i 
 
 
 r— i 
 
 r— i 
 
 r— i 
 
 
 m 
 
 o> 
 
 * 
 
 
 
 
 
 
 O 
 
 o 
 
 o 
 
 
 l—J 
 
 1 1 
 
 ii 
 
 
 <& 
 
 & 
 
 ^~ 
 
 hi 
 
 >s 
 
 X 
 
 -J 
 Ul 
 
 > 
 
 
 -J 
 
 -J 
 
 UJ 
 
 
 < 
 
 < 
 
 -J 
 
 
 2 
 or 
 
 2 
 or 
 
 Q 
 
 _l 
 O 
 
 
 o 
 
 u> 
 
 £ 
 
 
 
 C- 
 
 
 o— 
 
 
 o- 
 
 
 — — — 
 
 
 C-- 
 
 
 
 II 
 
 
 II 
 
 
 it 
 
 
 
 
 11 
 
 
 
 rO 
 
 
 CSI 
 
 
 
 
 
 O 
 
 
 
 _J 
 
 
 or 
 
 
 or 
 
 
 
 
 -J 
 
 
 
 Ul 
 
 
 Ul 
 
 
 Ul 
 
 
 
 
 Ul 
 
 to 
 
 w 
 
 > 
 UJ 
 
 _l 
 
 Q 
 
 -I 
 O 
 
 C 
 
 > 
 
 Ul 
 
 _j 
 
 Q 
 
 _J 
 O 
 
 E 
 
 > 
 
 UJ 
 
 _i 
 
 Q 
 
 -I 
 O 
 
 u 
 
 .Q 
 
 o 
 
 > 
 
 Ul 
 
 _J 
 
 o 
 
 -1 
 o 
 
 
 
 "-% 
 
 
 % 
 
 
 V 
 
 
 
 
 kl 
 
 k* 
 
 
 *» 
 
 
 
 r~~i 
 
 r— i 
 
 r— I 
 
 r— i 
 
 CO 
 
 CO 
 
 * 
 
 O 
 
 
 
 
 
 o 
 
 O 
 
 O 
 
 O 
 
 « — • 
 
 L— J 
 
 
 i— J 
 
 ii 
 
 II 
 
 M 
 
 ii 
 
 IO 
 
 CM 
 
 — 
 
 o 
 
 _l 
 
 -J 
 
 -J 
 
 _l 
 
 Ul 
 
 UJ 
 
 Ul 
 
 Ul 
 
 > 
 
 > 
 
 > 
 
 > 
 
 Ul 
 
 Ul 
 
 Ul 
 
 UJ 
 
 -J 
 
 -J 
 
 _l 
 
 -J 
 
 n 
 
 CO 
 
 
 1- 
 
 
 co z 
 
 
 CO u 
 
 O 
 
 PROCE 
 FRA6M 
 
 l- 
 
 z 
 
 Ul 
 
 2 
 
 
 o 
 
 
 < 
 or 
 
 »f 
 
 u. 
 
 CO 
 
 
 
 «H 
 
 o 
 
 n3 
 
 0) 
 
 -p 
 
 W 
 
 CI 
 •H 
 
 (U 
 
 -p 
 •p 
 
 •H 
 > 
 
 W 
 •H 
 
73 
 
 In this example the "block levels have "been numbered. The 
 procedure "addl" creates variables at level 1, hut it is passed variables 
 from level 3 and level 1. It is not possible for a procedure running at 
 level n to use level n+1 or higher level registers. Furthermore, it is 
 not possible for the procedure "addl" to maintain two level 1 registers 
 - one to address its own variable "Z" and one to address the actual 
 parameter "m" . To bypass these problems, base of stack relative address- 
 ing is used to pass the parameters. 
 
 By using base of stack relative addressing it is possible to 
 create indirect reference words that can be used through any number of 
 recursions. To enter the procedure in the above example an operator was 
 executed to leave space to save level register 1. Then another operator 
 was executed to create an indirect reference word to "r". This was repeated 
 for "m". Finally the procedure entry operator was executed to relink the 
 level register and enter a new code segment. So far this is very similar 
 to the B6500 manner of addressing and procedure entry. 
 
 Things start to get sticky when procedures are appended as sep- 
 arate asynchronous processes rather than executed in line. In this case 
 there must be several stacks (one for each appended process) each with the 
 same base stack. If the procedure "addl" had been appended in the last 
 example there would have been two processes running--each with its own 
 set of level registers to define its environment. 
 
 Note in Figure 3 that the level register in the appended process 
 points to level in the main process . Therefore the main program and 
 the appended procedure both reference the same level zero variables "a", 
 "b" , "c". However the level 1 registers in each process are different and 
 reference different variables. 
 
Ik 
 
 In addition to the array of level registers, an array of stack 
 fragment registers is introduced. Now the operator that translates level 
 displacement addresses into stack displacement indirect reference words 
 not only produces a stack displacement but also produces a stack frag- 
 ment index in the indirect reference word. If yet another "addl" were 
 appended at this point, it would also receive separate arrays of level 
 registers and stack fragment registers. The level and stack registers 
 would point to the same place in both processes but each of the appended 
 processes would have different level 1 and stack 1 pointers. 
 
 If a process now develops a level displacement address, it 
 must point to a legitimate address for the process. There is no way a 
 variable in another appended process or separate program can be addressed 
 with a level displacement address. 
 
 Similarly stack displacement addresses used for formal para- 
 meters, cannot be created that point to illegal variables since they 
 were all created at some time from a legitimate level displacement address 
 Clearly stack fragment 1 of the appended procedure "addl" provides no way 
 of referencing a stack fragment of another appended "addl" or another 
 program. The level registers and stack registers can be initialized 
 using the environment checking techniques discussed earlier. Therefore 
 the basic integrity of the values in the registers can be assured. 
 
 This is all fine for assuring a proper addressing space for a 
 single multiprocess program or several running together. The problem now 
 is to insure the integrity of the addressing space between operating 
 system layers . 
 
75 
 
 LAYER POINTERS 
 
 STACK FRAGMENT POINTERS 
 
 h 
 
 STACK 
 FRAGMENTS 
 
 INDIRECT REFERENCE WORDS USE THE ADDRESS 
 TRIPLE (LAYER, STACK, DISPLACEMENT) 
 
 LEVEL POINTERS 
 
 STACK FRAGMENTS 
 
 HE STANDARD ADDRESSING TECHNIQUE USES LEVEL DISPLACEMENT COUPLES. 
 THE LEVEL POINTER CONTAINS ALL REQUIRED STACK FRAGMENT REFERENCES. 
 
 Figure k. Final addressing scheme. 
 
76 
 
 To do this another array is introduced, the layer array. 
 Futhermore , the processor is given the knowledge of the layer at "which 
 it is operating (This is just part of the initiate or restart operator.). 
 When an indirect reference word is created, the operator also inserts 
 the current system layer as well as the stack fragment and stack 
 displacement into the word. 
 
 A complete set of layer, stack fragment, and level pointers 
 defines the process environment (cf. Figure k) . Since higher layers 
 of the operating system cannot create indirect reference words that point 
 into lower layers, the higher layers have access only to the data in the 
 lower layers that were passed to the higher layers as actual parameters. 
 But to those variables they have direct access as if they were in their 
 own layer. If one makes the final requirement that indirect reference 
 words are tagged so that only special operators may access them, the 
 integrity of the entire system is assured. Furthermore, foreign programs, 
 appended processes, and layers are so arranged that no possible address 
 can be created to reference them. Thus they are removed from the address 
 space. 
 
 It should be noted that this scheme is not unreasonable. The 
 idea of the stack fragment array, stack fragments, and level registers 
 are used on the B6500. However the stack fragment array is a single 
 array 102U long which contains every process in the machine. Thus the 
 addressing spaces of programs are not disjoint. In order to address a 
 second program a stuffed indirect reference word specifying its stack 
 number would suffice. The OSL/2 concept makes this array part of the 
 environment of each process thus separating the address spaces. The 
 further addition of the layer array is straight forward. 
 
77 
 
 The passing of information between layers is demonstrated to 
 be feasible. The communication of semaphores as formal parameters is 
 an obvious use of this interlayer communication. The problem of the 
 addition and changing of primitives does not require esoteric hardware. 
 Once interlayer addressability is defined, this problem falls under 
 standard linkage editor techniques. 
 
 In conclusion, OSL/2 algorithmic techniques do not make severe 
 requirements on the hardware architecture. However, the access variables 
 imply a call by name facility which does require specialize hardware for 
 efficient processing. The layering facilities do place severe 
 restrictions on the hardware and require careful attention to the address- 
 ing problem. 
 
78 
 
 Chapter 5 
 Conclusions 
 
 The data access techniques and process control concepts provide 
 OSL/2 with the ability to create and manipulate queues and tables and to 
 control multiple processes in a multilayered, hierarchial operating 
 system. The procedure parameter specification facilities (keywords 
 and defaults) are an integral part of these facilities and considerably 
 enhance the readability of the language. 
 
 A system measurement capability is provided as a side effect 
 of the data access facilities. The strong concepts of environment plus 
 the measurement capability makes OSL/2 a language suitable for predictive 
 system simulation as will as implemented system measurement. 
 
 OSL/2 implies a command driven operating system. That is, a 
 system with multiple processes each either executing or else waiting 
 for a command (P operation) to continue. There is no interrupt concept 
 in OSL/2. In general, command driven systems (e.g., the "THE" system [10] 
 and the ILLIAC IV system [11,12]) must have well defined structures in 
 order to work in the command driven environment. Such systems are there- 
 fore more amenable to analysis, modification, and debugging. 
 
 The power of the general data access facilities is enormous. 
 They allow the specification and manipulation of complex concepts as if 
 they were primitive in the language. They further isolate the manipulation 
 of special purpose constructs like queues and tables to a single declaration 
 where access algorithms can be readily changed without touching any other 
 portions of code. This facility specifies an access technique. The inter- 
 
79 
 
 pretation of parameters and array information in the declaration and 
 subscripts in statements and expressions are subject to programmer 
 control. This allows a programmer to write his own semantics for variable 
 accessing and control. Simple queues, complex tables, switch files, 
 and even formatted I/O have been generated using this facility. It will 
 take a significant amount of actual use before the range and power of 
 this technique is well established. 
 
 The data access concepts can be added to existing languages 
 like ALGOL, ESPOL, and PL/l. Furthermore, the concepts can be restricted 
 and implemented in such a way that call by name hardware is not essential 
 for their use. The structure definition in BLISS [22] is an example of 
 a language with such a facility. However, adding such a capability to an 
 assembly language is not reasonable. Assembly language does not have the 
 richness of structure and concepts of scope that permit a clean implemen- 
 tation. 
 
 The layered system concept provided by OSL/2 is the most diffi- 
 cult feature to implement. Special hardware is certainly required. It 
 is not recommended for implementation on current machines. 
 
 There may be one desirable concept left out of OSL/2. There 
 is no primitive concept of a list in the syntax. Most lists are easy to 
 build and maintain via the access techniques. However the concept of a 
 written list is not available. This was important when writing formatted 
 I/O. The desirable form of a read statement appeared to be read 
 (<file> ,<format string> ,<list>) where <list> could be a list of identifiers, 
 or expressions separated by commas. Instead of doing work this way, 
 separate "readO", "readl" , . . . ,"readn" procedures would be required to 
 
80 
 
 read 0, l,...,n variables with "read" reserved for handling a list 
 manipulated via the access facility. The author had used such a 
 scheme in ALGOL 60 on the GE 635- In general, it was messy and one 
 would continually change a "readk" to a "readn" to reflect a change 
 in his list. Eventually, he gave up and went to the list form and 
 declared many, many lists. 
 
 While the list is not incompatible with OSL/2, it was left 
 out in an effort to keep an already large language from getting com- 
 pletely unmanageable. Lists can be added later if really needed. The 
 author feels that data types like pattern also fall into this category. 
 They were included only to document the compatibility of the SNOBOL 
 pattern matching statement with an ALGOL-like block structured language 
 
81 
 
 Appendix A 
 A Reference to OSL/2 Syntax and Semantics 
 
 I . Introduction 
 
 OSL/2 is a block structured, Algol-based language designed for 
 the specification of operating systems. OSL/2 is a follow-on language 
 to OSL (Operating System Language) -which was designed and documented by 
 Alsberg and Wells [ll]. 
 
 OSL/2 is not designed for an existing machine, nor is it machine 
 independent. Rather, OSL/2 is designed to make coding easy for the system's 
 programmer, and it is also designed to be its own job control language. 
 That is, a user in an OSL/2 system may use OSL/2 to control his job flow. 
 To this extent OSL/2 is recursive in the system sense. One may describe 
 new operating systems that exist on top of many layers of other operating 
 systems . 
 
 It is expected that OSL/2 will be best implemented on a machine 
 specifically designed to mirror the language itself. This machine will be 
 called the OSL machine. 
 
 In the syntactic description of the language, the ALGOL 60 report 
 is followed as closely as possible. Furthermore, every attempt is made not 
 to arbitrarily introduce new terminology for concepts and entities available 
 in, or similar to, other languages like ALGOL 60 and PL/1. 
 
 OSL differs sharply from ALGOL 60 in the following points. OSL 
 includes list processing and generalized data access techniques. The 
 programmer may specify special action to be taken when a fetch or store is 
 performed on data declared with the general access facilities. These 
 
82 
 
 facilities allow the ready specification of simple and complex queues, 
 tables, and stacks. 
 
 Semaphores replace the notion of interrupts. Semaphores are 
 used to synchronize processes. 
 
 Strings of various character sizes and varying lengths can be 
 easily manipulated with facilities similar to those offered by SNOBOL. 
 
 In OSL/2 a process is any program or procedure that is capable 
 of running asynchronously with any other process. Processes are created 
 in one of three ways. Any currently running OSL process can "initiate" 
 a new process. Initiated processes expect the initiating process to act 
 as their operating system. The initiating process must explicitly 
 indicate those procedure (primitives) within itself which the initiated 
 process has access to. All other procedures and all data in the initiating 
 process are not addressable by the initiated process. The initiating 
 process may elect to default some or all existing operating system 
 facilities to a lower level and choose only to add new facilities for 
 the initiated process. 
 
 New processes may be "spawned" by an initiated process. This 
 facility allows a running program to notify the operating system that 
 another program (process) should be initiated by the operating system. 
 
 Finally, asynchronously running procedures (processes) may 
 be "appended" to currently running processes. These appended procedures 
 have access to all data and all procedures that they would have if they 
 were executed sequentially. After appending a procedure, the appending 
 process continues execution at the next executable statement and the 
 appended process begins and continues execution at the same time. 
 
83 
 
 II. OSL/2 Syntax and Semantics 
 
 Table of Contents 
 
 1. The Purpose and Extent of the Language 
 
 2. Basic Symbols, Identifiers, and Constants 
 
 2.1. Letters 
 
 2.2. Digits 
 
 2.3. Constant Values 
 2.k. Delimiters 
 
 2.5. Special Symbols 
 
 2.6. Identifiers 
 2.7- Constants 
 
 3. Expressions 
 
 3.1. Variables 
 
 3.2. Function Designators 
 
 3.3. Integer Expressions 
 3.^. Boolean Expressions 
 3«5« String Expressions 
 
 3.6. Pointer Expressions 
 
 3.7. Pattern Expressions 
 3-8. Structure Expressions 
 
 k. Statements 
 
 U.l. Compound Statements and Blocks 
 k.2. Assignment Statements 
 k.3* Dummy Statements 
 
8U 
 
 k.h. Case Statements 
 
 4.5. Procedure Statements 
 
 k.6. Process Statements 
 
 ^.7^ Iterative Statements 
 
 k.Q. Escape Statements 
 
 4.9. Pattern Matching Statements 
 U.10. Synchronization Statements 
 U.ll. Conditional Statements 
 
 5. Declarations 
 
 5.1. Integer Declarations 
 
 5.2. Boolean Declarations 
 
 5.3. String Declarations 
 5.^. Semaphore Declarations 
 
 5.5. Process Declarations 
 
 5.6. Pointer Declarations 
 5.7- Structure Declarations 
 5.8. Trap Declarations 
 5.9- Pattern Declarations 
 
 5.10. Access Definitions 
 5-11. Access Declarations 
 5.12. Procedure Declarations 
 5-13. File Declarations 
 
 6. Compile Time Facilities 
 
 6.1 Compile Time Declarations 
 
85 
 
 1. The Purpose and Extent of the Language 
 
 OSL/2 is designed to describe the flow of control and manipu- 
 lation of data required in an operating system. The term operating 
 system refers primarily to supervisory and monitor systems. However, 
 the string manipulation facilities make OSL/2 a powerful compiler writing 
 language. OSL/2 is designed with the deliberate intent to make the 
 generation of well structured and readable codes the natural coding mode. 
 To this end the "GO TO" statement has been eliminated and the use of 
 labels had been restricted to encourage self -documenting code. 
 
 A simple macro facility is specified. 
 
 The data base includes integers, Booleans , strings, semaphores, 
 patterns, and pointers. Furthermore, structures, in the PL/1 sense, 
 are available and extendible data access facilities have been provided. 
 
86 
 
 2. Basic Symbols, Identifiers, and Constants 
 Basic Concepts. 
 
 The reference langauge is "built up from the following basic 
 
 symbols : 
 
 <basic symbol> : := <letter> : <digit> I <logical value> i <delimiter> 
 <special symbol> 
 
87 
 
 2.1. Letters 
 
 <letter> : := A|B| C| D|E|F| G|H| l| J|k|l| m|n| 0|P| Q| R| S|t|u| V|w| X| Y| Z| a|"b| c| d| e 
 
 f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z 
 This alphabet may he arbitrarily restricted, or extended with any other . 
 distinctive character (i.e., character not coinciding with any digit, 
 logical value, or delimiter). Letters do not have individual meaning. 
 They are used for forming constants and identifiers. 
 
88 
 
 2.2. Digits 
 
 <digit> ::= 0|l|2|3|U|5|6|7|8|9 
 
 <decimal digit> : := <digit> 
 
 <binary digit> ::= 0|1 
 
 <quarternary digit> : := 1 1 1 2 j 3 
 
 <octal digit> : := 0| l|2| 3| ^| 5|6| 7 
 
 <hexadecimal digit> : := 0| l| 2 | 3| U| 5| 6\ l\ 8|9| A|b| c| d|e| F 
 
 Digits are used for forming integers, constants, and identifiers. 
 
89 
 
 2.3. Constant Values 
 
 <logical value> : := TRUE| FALSE 
 
 <string value> : := MT 
 
 <pointer value> : := NULL 
 
 Logical values are the values of Boolean quantities. 
 
 The string value MT denotes the empty string of length zero. 
 
 The pointer value NULL denotes the null pointer. 
 
90 
 
 2.U. Delimiters 
 
 <delimiter> ::= <operator> <separator> <bracket> | <declarator> 
 
 <specificator> 
 <operator> : := <integer operator> relational operator> | <pattern operators 
 
 I <logical operator> <sequential operator> <string operator> 
 <integer operator : := + | - | * | / | + | RDIV | CDIV | M0D 
 relational operator> : := < | <= | = | >= | > | %= | LSS | LEQ | EQL 
 
 | GEQ | GTR | NEQ 
 <logical operator : := EQV | IMP | 0R | AND | N0I | X0R | * | ANDIF | 0RIF 
 <pattern operator> : := <vertical bar> 
 <sequential operator : := IF | THEN | ELSE | FI | D0 | SPAWN | APPEND 
 
 | INITIATE | TERMINATE | SUSPEND | RESTART | STEP | T0 | BY 
 
 | UNTIL | WHILE | F0R | P | V | LEAVE | CASE | 0F | ESAC 
 <string operator> : := & | SAND | S0R | SN0T | SX0R 
 <separator> : := , | . | : | i | <■ | == | C0MMENT | TIMES | $ " 
 
 { 
 
 I % i ! | <"blank> 
 <blank> : := <single space> ; <blank> <single space> 
 <bracket> : := ( | ) | [ | ] | BEGIN | END | ' | " | { | } | # 
 <declarator> : := B00LEAN | INTEGER | STRING | P0INTER | ACCESS 
 
 | 0N | STRUCTURE | PR0CEDURE | N0DE | PR0CESS | FILE | PATTERN 
 I QUEUE | STACK | 0WN | DEFINE | PRIMITIVE | SEMAPH0RE 
 <specificator> : := VALUE | NAME | FIXED | F0RMAL | F0RWARD 
 
 <vertical bar> : := | 
 
 Delimiters separate the various entities of the language. In 
 order to accept input from common restricted alphabets, the following 
 symbols and combinations of symbols are equivalent: 
 
91 
 
 Standard Symbols Alternatives 
 
 < LSS 
 
 <= LEQ 
 
 EQL 
 
 >= GEQ 
 
 > GTR 
 
 *u= NEQ 
 
 -«- : = 
 
 % N0T 
 
 In what follows, only the left hand standard symbols are used. 
 
 Delimiters have fixed meanings which will be explained as they 
 occur in various constructs. Delimiters and logical values are considered 
 basic symbols of the language and have no relation to the individual 
 letters of which they are composed. Therefore, the words which constitute 
 basic symbols are reserved for specific use in the language. 
 Z.h.l. Spacing 
 
 No space may appear between the letters of a reserved word. At 
 least one space must separate a multicharacter delimiter from any adjacent 
 letter or digit. That is, any two basic components of the following form 
 must be separated by <blank>. 
 
 1. Multicharacter delimiter 
 
 2. Identifier 
 
 3. Logical value 
 h. String value 
 
 5. Pointer value 
 
 6. Unsigned integer 
 
92 
 
 2.U.2. Comments 
 
 Comments may "be inserted in the program without effect on the 
 program structure. The following conventions hold: 
 
 1) {terminal symbol }C0MMENT {any sequence of symbols except;} ; 
 is equivalent to {terminal symbol} 
 
 2) % {any sequence of symbols except %} % is equivalent to 
 <blank> 
 
 3) ! {any sequence of symbols} {end of line} is equivalent 
 to <blank> 
 
 k) END {any sequence of letters digits and blanks} is equiva- 
 lent to END 
 
 The % convention has precedence over all other comment conventions 
 No comment conventions are recognized inside strings. 
 
 The metalinguistic notation {...} is used to denote the terminal 
 symbol or group of terminal symbols indicated by the english phrase 
 enclosed in the metalinguistic braces. 
 
93 
 
 2.5. Special Symbols 
 <special symbol> : := _ 
 
 The underscore is completely ignored in the language except 
 when it appears within a string. The underscore is used in identifiers 
 and constants to improve readability. 
 
9b 
 
 2.6. Identifiers 
 
 2.6.1. Syntax 
 
 <identifier> : := <letter> i <identifier> <letter> <identifier> <digit> 
 
 2.6.2. Examples 
 
 Al 
 
 PR0CESS0R_NUMBER 
 
 TIME_LIMIT 
 
 J0B23 
 
 X 
 
 2.6.3. Semantics 
 
 No spaces may appear within identifiers. The underscore "_" 
 is used to improve readability, but is not part of the identifier. Thus 
 "A_B", "AB", and "A B" are all the same identifier. . 
 
 Identifiers are used to identify pointers, events, procedures, 
 variables, etc. 
 
 Reserved words may not be used as identifiers. Otherwise, 
 identifiers may be chosen freely. 
 
 Identifiers may be of any length. However, finite implementations 
 are envisioned. In no case will the maximum identifier size be less 
 than fifteen characters. When reduction of an oversized identifier is 
 required, the identifier shall be reduced by the following algorithm: 
 
 1) n is the maximum identifier length 
 
 2) if n is even, choose n/2 characters from the front and n/2 
 characters from the rear of the identifier 
 
 3) if n is odd, choose (n+l)/2 characters from the front and 
 (n-l)/2 characters from the rear of the identifier. 
 
95 
 
 2. J. Constants 
 2.7.1. Integers 
 
 2.7.1.1. Syntax 
 
 <unsigned integer> : := <digit> \ <unsigned integer> <digit> 
 
 <integer> : := <unsigned integer> j + <unsigned integer> j - <unsigned integer> 
 
 2.7.1.2. Examples 
 1 
 
 123j*56_789_012 
 +17 
 
 -35_702 
 2.7-1.3. Semantics 
 
 The underscore is used to improve readability and does not 
 alter the value of the integer. The value of the integer is its decimal 
 based value. 
 2.7-2. Strings 
 2.7-2.1. Syntax 
 <binary string> : := 2'<binary digit string> ' 
 
 I 2"<binary digit string>" 
 <quaternary string> : := k ' <quaternary digit string> ' 
 
 j h"< quaternary digit string>" 
 <octal string> : := 8'<octal digit string> ' 
 
 1 8"<octal digit string>" 
 <decimal string> : := 10'<unsigned integer> ' 
 
 j 10"<unsigned integer>" 
 <hexadecimal string> : := l6 ' <hexadecimal digit string> ' 
 
 I l6"<hexadecimal digit string>" 
 
96 
 
 <binary digit string> : := <binary digit> 
 
 <binary digit string> <binary digit> 
 <quaternary digit string> : := <quaternary digit> 
 
 <quaternary digit string> <quaternary digit> 
 <octal digit string> : := <octal digit> 
 
 <octal digit string> <octal digit> 
 <hexadecimal digit string> : := <hexadecimal digit> 
 
 <hexadecimal digit string> <hexadecimal digit> 
 <character string> : := <symbol string> | A <symbol string> 
 
 E <symbol string> | B <symbol string> 
 <symbol string> : := "{any string of symbols}" '{any string of symbols}' 
 
 <string> : := <binary string> <quaternary string> i <octal string> 
 
 <decimal string> <hexadecimal string> <character string> MT 
 Each quote, identical to the opening quote, which is placed 
 within the string, must be presented by two juxtaposed quotes of the same 
 type as the opening quote. 
 2.7-2.2. Examples 
 
 2*011001101' 
 l6'FAEC0628F' 
 
 8 '73107777' 
 
 "N0WS THE TIME" 
 
 'WHAT ' ' S Y0UE PR0BLEM? ' 
 
 »T0 QU0TE: "G0 H0ME!"' 
 
 E" ( $ # § ""?" 
 2.7.2.3. Semantics 
 
 The number strings described are used as masks and can take the 
 positive value of their binary representation when used in arithmetic 
 
97 
 
 expressions. A decimal string is semantic ally equivalent to a hexadecimal 
 string. 
 
 MT is the universal null string — it is empty. 
 
 Character strings are, by default, eight bit' ASCII code. The 
 prefix A denotes seven bit ASCII, E denotes eight bit EBCDIC, and B denotes 
 6 bit IBM BCD. Either double or single quotes may open a string. A string 
 is closed by the same type of quote which opened it. 
 
98 
 
 3. Expressions 
 
 In the language , the primary constituents of the program 
 which describe algorithmic processes are integer, Boolean, string, pointer, 
 pattern, and structure expressions. 
 
 <expression> : := <integer expression> <Boolean expression> 
 <string expression> <pointer expression> 
 <structure expression> <pattern expression> 
 
99 
 
 3.1. Variables 
 
 3.1.1. Syntax 
 
 < subscript list> : := <subscript expression> 
 
 I <subscript list> ,<subscript expression> 
 <subscript expression> : := <integer expression> <actual parameter> 
 <substring specification> : := [<first position> :<number of positions;*] 
 
 j [<first position> :<number of positions> :<size> ] 
 < first position> : := <integer expression> 
 <number of positions> : := <integer expression> 
 <size> : := <integer expression> 
 <name> : := <identifier> j <structure first part> .<identifier> 
 
 J <identifier> [<subscript list>] 
 
 | <structure first part> .<identifier> [<subscript list>] 
 <structure first part> : := <structure name> 
 
 | <structure first part> .<structure name> 
 <structure name> : := <identifier> \ <identifier> [<subscript list>] 
 <pointer name> : := <name> 
 
 <pointer specifier> ::= <pointer name> . | <pointer-specifier> <pointer name> . 
 <variable> ::= <name> ! <pointer specifier> <name> 
 
 <string variable> : := <variable> j <variable> .<substring specification 
 <structure variable> : := <structure first part> 
 
 | <pointer specifier> <structure first part> 
 
 3.1.2. Examples 
 
 A 
 
 A[23] 
 
 USER NAME. [1:20] 
 
1Q0 
 
 STUDENT_MTRY[N*2+K] .ID_N0 
 
 P.LIST_ELEMENT 
 
 X.[2T:3] 
 3.1.3. Semantics 
 
 Variables name data quantities. A variable may specify single 
 quantities, multidimensional arrays, or whole data structures. 
 
 When a variable specifies an array, each subscription expression 
 is evaluated and used to determine which array element is specified. The 
 value of a subscripted variable, one or more of whose subscripts are out 
 of bounds, is undefined. If an out of range subscript is calculated, an 
 "index" trap occurs. Access variables may have actual parameters passed 
 through the subscript list. In this case, the interpretation of the 
 subscripts is given by the associated access definition. 
 
 A variable which specifies a string quantity, may be followed 
 by a substring specification. The substring specification indicates 
 what is the first character desired in the string and how many contiguous 
 characters to the right of the first character (including the first 
 character) are desired. The character positions in a string are numbered 
 from left to right beginning at zero. If a size parameter is specified, 
 the new character size is used instead of what was declared for the 
 string. 
 
 The symbol "." is used in variables to exactly define which 
 quantity is desired when a pointer is specified. If P is a pointer, 
 then "P" denotes the pointer P and "P." denotes the quantity pointed 
 to by P. This use of the "." is consistent with structure addressing. 
 
101 
 
 Each higher level identifier used in a structure, that is each identifier 
 that does not identify a primitive data item, may he viewed as a pointer, 
 e.g. 
 
 STRUCTURE J0B (INTEGER ID, TIME0N, TIME0FF; ■ 
 
 STRING NAME ( 30 ) ; 
 
 STRUCTURE IDCARD_PARMS( INTEGER TIME, LINES) ) ; 
 "J0B" and "IDCARD_PARMS" are higher level identifiers in this structure. 
 Thus one would address "LINES" as follows: 
 
 J0B . IDCARD_PARMS . LINES 
 If "J0B" were a structure which was repeated many times in a list and "P" 
 were a pointer which pointed into this list then the "J0B" structure 
 pointed to by "P" would be expressed as "P.J0B". 
 
102 
 
 3.2. Function Designators 
 
 3.2.1. Syntax 
 
 <procedure identifiers : := <identifier> 
 
 < actual parameters : := <keyword parameter> <parameter> 
 
 <keyword parameter> : := <formal parameter identifier> : <parameter> 
 
 <parameter> : := <expression> <procedure identifier> 
 
 | <variable> * | < empty > 
 <actual parameter list> : := <actual parameter> 
 
 <actual parameter list> ,<actual parameter> 
 <function designator> : := <procedure identifier> 
 
 <procedure identifier> (<actual parameter list>) 
 The variables which appear as actual parameters may be semaphores, files, 
 access variables, or process variables. 
 
 3.2.2. Examples 
 
 GETSPACE (1OO*J0B_SIZE) 
 ELAPSEDJTIME (A,B,C,D) 
 GL0RPSOT0TT ( MEEKLE_JAMMER ) 
 
 3.2.3. Semantics 
 
 Function designators may define any data type value available 
 in OSL/2. This data is returned by the function after it executes a 
 given set of rules defined by a procedure declaration. 
 
 3.2.4. Standard Functions 
 
 The following functions (primitives) are predefined and 
 implemented for the user. 
 
103 
 
 Functions 
 Asses) 
 
 SIGN(E) 
 
 decimal(e) 
 
 binary(e) 
 cofvert(a,b,c) 
 
 or 
 CONVERT (A,B,C,N) 
 
 Arguments 
 
 integer expression 
 
 integer expression 
 integer expression 
 decimal string 
 
 strings A,B,C and 
 expression N 
 
 LENGTH(E) 
 CHARSIZE(E) 
 
 string 
 string 
 
 Action 
 
 absolute value of E is 
 returned. 
 
 if E>0 return +1, 
 if E=0- return 0, 
 if E<0 return -1. 
 
 returns a decimal string 
 ■which represents the decimal 
 value of ABS(E). 
 
 returns the binary integer 
 value of the string E. 
 
 convert N characters in 
 string A into a new string 
 using truncated values of 
 the characters in string C. 
 Each character in A. is used 
 to index into string C. The 
 first character in C is 
 selected if the character in 
 A has value 0, the second if 
 it has value 1, etc. The 
 Character in C is truncated 
 on the left or padded with 
 zeroes on the left to match 
 the character size of B. The 
 selected character is then 
 placed in B and the process 
 continues at the next position 
 in A and B until N characters 
 have been processed. If the 
 character position beyond the 
 end of the string C, or if N 
 exceeds the size of A or B then 
 a convert failure trap is 
 caused. If N<0 then no charac- 
 ters are converted. 
 
 returns the number of characters 
 in string E. 
 
 returns the number of bits per 
 character in string E. 
 
ioU 
 
 Functions 
 
 PTR(E) 
 
 SPAN(E) 
 
 or 
 SPAN(E,N) 
 
 except(e) 
 
 or 
 EXCEPT (E,N) 
 
 Arguments 
 
 any single variable 
 or array element 
 or character 
 
 E=string 
 
 N=integer expression 
 
 E=string 
 
 N=integer expression 
 
 Action 
 
 A pointer to the variable, 
 array element, or character 
 is returned. 
 
 A pattern is returned which 
 represents a string of length 
 N consisting of any of the 
 characters in E. If N is 
 absent, a string of arbitrary 
 length is matched. 
 
 Same as SPAN except that a 
 string which consists of any 
 characters except those in E 
 is matched. 
 
 ANY 
 or 
 ANY(N) 
 
 RELEASE^) 
 
 UPPER(E) 
 
 L0WER(e) 
 
 STRING(E) 
 
 or 
 STRING(E,N) 
 
 ALLOCATE (E) 
 
 N=integer expression 
 
 variable 
 
 array row 
 specification 
 
 array row 
 specification 
 
 integer expression 
 
 identifier 
 
 ANY is a pattern which matches 
 any string. If N is specified 
 then ANY matches any string of 
 length N. 
 
 The specified variable is 
 deallocated. 
 
 The upper bound of the speci- 
 fied array row is returned. 
 
 The lower bound of the speci- 
 fied array row is returned. 
 
 E is converted to a bit string 
 of length N. Two's complement, 
 arithmetic is assumed. If N i: 
 not provided, the current 
 default length of an integer ■ 
 is assumed. 
 
 A pointer is returned with the 
 location of E in it. This 
 primitive is used at block 
 entry and block exit. If 
 it is redefined by the user, 
 the user may do his own 
 allocation. However, the 
 user may only allocate space 
 in arrays declared lexico- 
 graphically prior to the 
 redefinition of primitive 
 ALL0CATE. This function may 
 also be used as a procedure 
 statement . 
 
105 
 
 Functions 
 
 B00L(E) 
 
 INTGR(E) 
 
 Arguments 
 
 integer expression 
 
 decimal string 
 
 Action 
 
 Allows E to be used as a 
 Boolean with Boolean opera- 
 tors. B00L(E) is true if E 
 is odd or has a right -most 
 bit equal to 1. Otherwise 
 it is false. 
 
 Allows E to be used as an 
 integer. 
 
106 
 
 3.3. Integer Expressions 
 
 3.3.1. Syntax 
 
 <unary operator> : := + ' - 
 
 <adding operator> : := + j - 
 
 multiplying operator> : := * / | RDIV CDIV | M0D 
 
 <primary> : := <unsigned integer> <variable> j <function designator> 
 
 CASE <integer expression> 0F <integer expression list> ESAC 
 
 ( <integer expression>) 
 | IF <Boolean expression> THEN <integer expression> ELSE 
 
 <integer expression> FI 
 <f actor > : := <primary> <unary operator> <primary> j <factor> + <primary> 
 
 <factor> t <unary operator> <primary> 
 <term> : := <factor> \ <term> <multiplying operator> <factor> 
 <simple integer expression> : := <term> 
 
 <simple integer expression> <adding operator> <term> 
 <integer expression> : := <simple integer expression> ! <integer assignment> 
 <integer expression list> : := <integer expression> 
 
 <integer expression list> ,<integer expression> 
 
 3.3.2. Examples 
 
 Integer expressions : 
 A+B+C 
 X+-3 
 
 -h * (A+INTGR (16'OAFFF 1 ) M0D 3) 
 18+ IF J0BTIME MAXTIME>THEN A/B 
 ELSE IF A * B M0D C = X 
 
 THEN R0UNDER (Q) 
 
 ELSE A/B FI FI 
 
107 
 
 Terms 
 
 -(Q «- B+C) 
 A + -G * 30 
 Q+INTGR (X. [17:5]) 
 X -*■ A+B * (C «- 10*L) 
 
 Z [17, A * B] * TEST_N0 
 
 A * B * X [11, IF A = B THEN 3 ELSE k Fl] * Q 
 
 Factors 
 
 -A 
 
 B 
 
 C t D t -E t 10 
 
 +(30 * A) 
 
 -(A+ (10+J)) 
 Primaries : 
 
 73 
 
 IF Q = R ANDIF B00L (X + l) IMP B THEN 17 ELSE Q FI 
 
 LENGTH (P) 
 
 BASE (PTRl) 
 
 (X + IF P THEN 2 ELSE C * Q Fl) 
 3.3.3. Semantics 
 
 An integer expression is a rule for computing a numerical 
 value. This value is obtained by executing the indicated arithmetic 
 operations on the actual numerical value of a primary. The value is 
 obvious in the case of constants. For variables, it is the current 
 value (assigned last in the dynamic sense), and for function designators 
 it is the value returned "when the computing rules defining the proce- 
 
108 
 
 dure are applied to the current values of the procedure parameters 
 given in the expression. For integer expressions enclosed in paren- 
 theses, the value must, through a recursive analysis, be expressed in 
 terms of values of primaries of the other three kinds. 
 
 The value of a primary of the form IF <Boolean expression> 
 THEN <integer expression 1> ELSE <integer expression 2> FI is computed 
 as follows. The Boolean expression is evaluated. If it is true, 
 integer expression 1 is evaluated and is the value of the primary. If 
 the value of the Boolean expression is false, then integer expression 2 
 is evaluated and is the value of the primary. 
 
 The value of a primary of the form CASE <integer expression> 
 OF <integer expression_> , <integer expression >,.. .<integer expression > 
 ESAC is computed as follows. The integer expression following the case 
 is evaluated. Assume it has value i. If < i <n then integer 
 expression, is calculated and is the value of the primary. If i < or 
 n < i, then integer expression is calculated and is the value of the 
 primary. 
 
 If an assignment statement appears as an arithmetic expression, 
 the arithmetic assignment statement is executed and the value of the 
 expression is the value assigned by the assignment statement. 
 
 If side effects in a function designator will cause ambiguity 
 of result, expressions are evaluated in the order specified by the syntax. 
 3.3.3.1. Operators and Types 
 
 The values used in evaluating integer expressions are always 
 integers. The resulting value of the integer expression is an integer. 
 
109 
 
 3.3.3.1.1. The operators +,-, and * hare the conventional meanings of 
 addition, subtraction and multiplication. + denotes exponentiation. 
 
 3.3.3.1.2. The operators /, RDIV, CDIV, and M0D have special meanings. 
 Let t denote normal division of arbitrary real numbers, and let Entier(x) 
 denote the largest integer less than or equal to x. Then 
 
 A/B is a lower value divide = Entier (A * B) 
 
 A RDIV is a rounded divide = Entier (A * B + .5) 
 
 A CDIV is a ceiling value divide = -Entier (- (A f B)) 
 
 A M0D B is the remainder after dividing A by B = (A - (A/B) * B) 
 
 If A or B are expressions, then they are called by value before executing 
 
 the above algorithms . 
 
 3.3.3.1.3. The levels of precedence as defined by the syntax are as 
 follows : 
 
 first : unary +,- 
 
 second: + 
 
 third: *, /, RDIV, CDIV, M0D 
 
 fourth: binary +, - 
 
110 
 
 3.U. Boolean Expressions 
 3.U.I. Syntax 
 
 <relational operator> : := < | <= | = | >= | > I %= 
 <equality operator> : := = | ^= 
 
 <relation> : := <integer expression <relational operator <integer expression 
 | <string expression Relational operator> <string expression 
 | <pointer expression <equality operator> <pointer expression 
 <Boolean primary> : := <logical value> | <variable> 
 
 | <function designator | <relation> | (<Boolean expression) 
 | IF <Boolean expression THEN <Boolean expression ELSE 
 
 <Boolean expression FI 
 | CASE <integer expression 0F <Boolean expression list> ESAC 
 <Boolean secondary> : := <Boolean primary> | <Boolean primary> 
 <Boolean factor> : := <Boolean secondary> 
 
 | <Boolean factor> AND <Boolean secondary> 
 | <Boolean factor> ANDIF <Boolean secondary> 
 <Boolean term> : := <Boolean factor> | <Boolean term> X0R <Boolean factor> 
 | <Boolean term> 0R <Boolean factor> 
 | <Boolean term> 0RIF <Boolean factor> 
 <implication> : := <Boolean term> | <implication> IMP <Boolean term> 
 <simple Boolean> : := <implication> | <simple Boolean EQV <implication> 1 
 <Boolean expression : := <simple Boolean> | pattern matching statement 
 
 I <Boolean assignments 
 <Boolean expression list> : := <Boolean expression 
 
 | <Boolean expression list> ,<Boolean expression 
 Variables and function designators used as Boolean primaries must be declared 
 of type B00LEAN. 
 
Ill 
 
 3.^.2. Examples 
 
 A = B 
 
 "HI THERE!" = ACKN0WLEDGEMENT 
 
 IF S0MEJ300LEAN THEN TRUE ELSE F(G * T)FI 
 
 IF IF A = B THEN Q ELSE R(P3)FI THEN TRUE ELSE X = R FI 
 
 (A = B X0R C) AND D EQV L IMP Z23 
 
 B00L1 «- INT1 = INT2 «- 2*INT3 
 3.^.3. Semantics 
 
 A Boolean expression is a rule for computing a logical value. The 
 rules of evaluation are completely analogous to rules for evaluating 
 integer expressions. 
 
 Relations take the value true if the relation is satisfied for 
 the expressions involved. If the relation is not satisfied, then the value 
 of the relation is false. Only strings of identical character size may "be 
 used in a relation. When strings are being compared, the comparison takes 
 place from left to right character by character until an inequality is 
 determined or the two strings prove to be equal in content and length. 
 Characters are compared by the arithmetic value of their binary representations 
 If two strings of unequal length are compared and the entire shorter string 
 is identical to the first part of the longer string, then the shorter string 
 is by definition less than the longer string. Two pointers are equal if 
 they point to the same data. 
 3.^.3.1. Operators 
 
 The meaning of the logical operators is defined in the following 
 table: 
 
112 
 
 OPERANDS 
 
 OPERATIONS 
 
 bl 
 
 b2 
 
 •xfcl 
 
 bl AND b2 
 
 bl X0R b2 
 
 bl 0R b2 
 
 bl IMP b2 
 
 bl EQV b2 
 
 false 
 
 false 
 
 true 
 
 false 
 
 false 
 
 false 
 
 true 
 
 true 
 
 false 
 
 true 
 
 true 
 
 false 
 
 true 
 
 true 
 
 true 
 
 false 
 
 true 
 
 false 
 
 false 
 
 false 
 
 true 
 
 true 
 
 false 
 
 false 
 
 true 
 
 true 
 
 false 
 
 true 
 
 false 
 
 true 
 
 true 
 
 true 
 
 The sequence of operations -within one expression is left to right 
 with the following rules of precedence : 
 
 first: integer, string, and pointer expressions 
 
 second: 
 
 <> <=, = , >=, 
 
 third: 
 
 % 
 
 fourth : 
 
 AND, ANDIF 
 
 fifth: 
 
 X0R, 0R, 0RIF 
 
 sixth: 
 
 IMP 
 
 seventh: 
 
 EQV 
 
 The operators ANDIF and 0RIF have the same meaning as AND and 
 0R except that they may alter the evaluation rules of the Boolean expression 
 and may thereby drastically change any side effects. If the logical value 
 computed to the left of an ANDIF in the current Boolean factor is false, 
 then no further calculation is made to the right in the current Boolean 
 factor containing the ANDIF. The value of the Boolean factor is false. 
 If the logical value computed to the left of an 0RIF in the current Boolean 
 term is true, then no further calculation is made to the right in the current 
 Boolean term containing the 0RIF. The value of the Boolean term is true. If 
 the above conditions do not hold, the action is identical to AND and 0R. 
 
113 
 
 Strings and integers may be used as Booleans when indicated by the 
 B00L function. In this case the string is treated as true if the right-most 
 bit is 1 and false if it is 0. An integer becomes true if it is odd and false 
 if it is even. 
 
Ill* 
 
 3.5« String Expressions 
 3 . 5 • 1 • Syntax 
 
 <string primary> : := <string constant> <function designator> <variable> 
 |(<string expression>) 
 
 IF <Boolean expression> THEN <string expression> 
 
 ELSE <string expression> FI 
 
 CASE <integer expression> 0F <string expression list> ESAC 
 <string secondary> : := <string primary> SN0T <string primary> 
 <string factor> : := <string secondary> <string factor> SAND <string secondary 
 <string term> : := <string factor> <string term> S0R <string factor> 
 
 I <string term> SX0R <string f actor> 
 <simple string expression> ::= <string term> 
 
 I Simple string expression 5 * & <string term> 
 <string expression> ::= <simple string expression> <string assignment> 
 <string expression list> : := <string expression> 
 
 I <string expression list> ,<string expression> 
 Variables and functions are used as string primaries must be declared to be 
 type STRING. Only strings of the same character size may be concatenated. 
 3.5.2. Examples 
 
 "THIS" & "IS A C0N CATENATED STRING" 
 
 DECIMAL (SALARY) & (IF CENTS THEN 10"00" ELSE MT Fl) 
 
 A SAND 2 '110000111100' 
 3.5-3. Semantics 
 
 A string expression is a rule for computing a string value. The 
 rules for evaluating a string expression are analogous to the rules for 
 evaluating an integer expression. 
 
115 
 
 The string operators SAND, S0R, SX0R, and SN0T correspond respectively 
 to bit wise and, or, exclusive or, and not operations. These operators work 
 left to right on any strings. The operators SAND, S0R, and SX0R may operate 
 on strings of inequal length. The result is the same as if the operations 
 were performed on the full length of the shorter operand and the first part 
 of the longer operand (which is the same length as the shorter operand) 
 concatenated with the rest of the longer operand. 
 
 The string constant MT is the empty string. 
 
 The value of a string expression is the concatenated string whose 
 length is equal to the sum of its concatenated components. 
 
116 
 
 3.6. Pointer Expressions 
 
 3.6.1. Syntax 
 
 <pointer expression> : := <pointer variable> 
 
 < function designator> INTJLL 
 
 IF <Boolean expression> THEN <pointer expression> 
 
 ELSE <pointer expression> FI 
 
 CASE <integer expression> OF <pointer expression list> ESAC 
 
 <pointer assignment> 
 <pointer expression list> : := <pointer expression> 
 
 <pointer expression list> ,<pointer expression> 
 The pointer variables and function designator in pointer expressions 
 must be of type POINTER. 
 
 3.6.2. Examples 
 
 P.A.PTR1 
 
 P. A 
 
 P «- PTR(B) 
 
 IF Rl = P2 THEN PI ELSE Pl.P FI 
 
 P[23] 
 
 P[A*B+C] 
 3.6.3- Semantics 
 
 A pointer expression is a rule for computing a pointer value. A 
 pointer value points to a particular piece of data whether it be an individual 
 character, integer, array, event, structure, etc. The pointer operator "." 
 may be read right to left as "pointed to by the pointer". Thus "P. A" is A 
 pointed to by the pointer P. 
 
117 
 
 3.7. Pattern Expressions 
 
 3.7-1. Syntax 
 
 <pattern primary> : := <string> <variable> < function designator> 
 
 ! <pattern expression> 
 
 I IF <Boolean expression> THEN <pattern expression> 
 ELSE <pattern expression> FI 
 
 I CASE <integer expression> 0F <pattern expression list> ESAC 
 <pattern secondary> : := <pattern primary> 
 
 I <pattern secondary> & <pattern primary> 
 <pattern factor> : := <pattern secondary> ! <string variable> 
 
 J <pattern secondary> 
 <pattern alternative list> : := <pattern factor> 
 
 J <pattern alternative list> <vertical bar> <pattern factor> 
 <pattern expression> : := {<pattern alternative list>} 
 <pattern expression list> : := <pattern expression> 
 
 i <pattern expression list> ,<pattern expression> 
 
 3.7.2. Examples 
 
 "A" 
 
 {B +■ {"A" I "B" & SPAN ("012376")} | B -e- X & C} 
 
 {"LMQ" I "CAT" I "D0G"} 
 
 3.7.3. Semantics 
 
 Pattern expressions define a rule for scanning strings. Patterns 
 are used in string matching statements and their semantic interpretation 
 is discussed there. 
 
118 
 
 3.8. Structure Expressions 
 
 3.8.1. Syntax 
 
 <structure expression> : := <structure variable> 
 
 <function designator> 
 
 IF <Boolean expression> THEN <structure expression> 
 
 ELSE <structure expression> FI 
 i CASE <integer expression> #F <structure expression list> ESAC 
 <structure expression list> : := <structure expression> 
 
 <structure expression list> ,<structure expression> 
 Variables and functions used as structure expressions must be declared to be 
 structures. All structures in one expression must have the same hierarchy 
 and types in each position. 
 
 3.8.2. Examples 
 
 A 
 
 A.B 
 
 IF A=B THEN S ELSE B.S FI 
 
 3.8.3. Semantics 
 
 The rules for evaluating a structure expression are analogous to 
 the rules for evaluating an integer expression. 
 
119 
 
 h. Statements 
 
 The "basic unit of calculation is the statement. Statements are 
 normally executed sequentially in the order in which they are written. This 
 sequence may he shortened by conditional or escape statements which may 
 cause some statements to he skipped, or process statements may create 
 new processes that will run in parallel with the current code. 
 
 Statements may be grouped into compound statements and "blocks 
 which are themselves statements. Therefore the definition of statement is 
 necessarily recursive. 
 k.l. Compound Statements and Blocks 
 ll-.l.l. Syntax 
 <hasic statements : := <assignment statement> | <dummy statement> 
 
 | <case statement> j <procedure statements <process statement> 
 
 i <iterative statement> \ <escape statement> 
 
 ; <pattern matching statement> < synchronization statement> 
 <unconditional statement> : := <basic statement> <compound statement> 
 
 | <hlock> 
 <statement> : := <unconditional statement> <conditional statement> 
 <statement list> : := <statement> <statement list> ;<statement> 
 <declaration list> : := <declaration> <declaration list> ;<declaration> 
 <compound statement> : := BEGIN <statement list> END 
 
 i <lahel> : <compound statement> : <lahel> 
 <hlock head> : := BEGIN declaration list> 
 <hlock> : := <hlock head> ;<statement list> END 
 
 | <lahel> : <hlock> : <lahel> 
 <program> : := <hlock> j <compound statement> <procedure declaration> 
 
120 
 
 All labels are used as brackets. If a label is used before a 
 statement, the same label must be used after the statement. 
 1*.1.2. Examples 
 
 Let S, D, and L denote arbitrary statements, declarations and 
 labels . 
 
 Basic statements: 
 form: S 
 A i-B+C 
 P.D «■ Q 
 
 LEAVE OUIERBL0CK 
 Compound statements: 
 
 form: L:L. . .L:BEGIN S;S;S;...;S END:L ... L:L 
 CD: BEGIN 
 
 P(23,17,A*B); 
 X «- P+D ; 
 REWIND(TAPE9); 
 TERMINATE 
 END : CD 
 
 Blocks : 
 
 BLOCK : 
 
 form: L:L. . .L:BEGIN D;D; . . . ;D;S ; . . . ;S END : L:L ...L 
 BEGIN 
 
 INTEGER X,Y,Z; 
 
 STRING (A,B,C) (30); 
 
 A ■«- "N0¥ IS THE TIME" ; 
 
 B ■<- A & "23 SKID00"; 
 
121 
 
 X + 2*(Y +■ 30); 
 
 Z + X+Y; 
 
 IF X = INTGR(l0"37") THEN LEAVE BL0CK ELSE TERMINATE FI 
 END: BL0CK 
 ^.1.3. Semantics 
 
 Every block introduces a new level of nomenclature. Any identifier 
 occuring within the block is local to the block if it is defined in the 
 blockhead. Identifiers defined outside the present block but within a block 
 containing the present block are global to the present block. Only entities 
 represented by local and global identifiers have any existence within a block, 
 When an identifier is declared within a block, any entity represented by 
 this identifier outside the block is completely inaccessible inside the block, 
 
122 
 
 k.2. Assignment Statements 
 U.2.1. Syntax 
 
 <assignment statement> ::= <integer assignments | <Boolean assignment> 
 <string assignment> <pointer assignment> 
 <pattern assignment> <structure assignment> 
 <left part list> : := <variable> «- | <left part list> <variable> -<- 
 <integer assignment> ::= <variable> -<- <integer expression> 
 <Boolean assignment> : := <variable> -<- <Boolean expression> 
 <string assignment> : := <variable> -<- <string expression> 
 <pointer assignment> ::= <left part list> <pointer expression> 
 <structure assignment> ::= <left part list> <structure expression> 
 <pattern assignments : := <left part list> <pattern expression> 
 All variables on the left of the assignment arrow must be the same type 
 as the expression on the right. An asterisk may be used as the first 
 primary in the expression on the right of the assignment arrow. Any 
 pointer or pattern variable appearing on the left of an assignment arrow 
 must be at the same or lower nested block level of any variables appearing 
 to the right of the arrow. If the variable on the left of an assignment 
 is a function identifier, then the expression value is saved to be 
 returned at the end of the procedure. 
 k . 2 . 2 . Examples 
 
 A +- B+C 
 
 X + *+l 
 
 B «- X = Y 
 
 S + "TEST" 
 
 P <- PTE(A[0]) 
 
 SI «- S2 
 
 <-tf.fl I *»-,,!• I II -. „ , 
 
123 
 
 U.2.3. Semantics 
 
 Assignment statements assign the value of an expression to one or 
 more variables in a left part list. The types of the entities on the left 
 and right of the assignment must agree. No type transfers are automatically 
 invoked. 
 
 An asterisk in place of the first primary after an assignment 
 arrow means that the variable to the immediate left of the assignment arrow- 
 is to be used in place of the asterisk without further evaluation of sub- 
 scripts, etc. that may cause side effects. An access variable may not be 
 this variable if the asterisk convention is used. 
 
 The presence of an access identifier on the left or right of an 
 assignment automatically invokes the appropriate fetch or store procedure 
 specified in the access declaration to generate or save an expression value. 
 
 Assignment statements are executed in the order specified by the 
 following algorithm: 
 first: Any subscript or substring specifications occuring in the left part 
 
 list are evaluated in sequence from left to right, 
 second: The expression of the statement is evaluated, 
 third: The value of the expression is assigned to all the left part variables, 
 
 and all access variable stores are performed from right to left. 
 
12U 
 
 U.3. Dummy Statements 
 U.3.1. Syntax 
 
 < dummy statement> : := <empty> 
 U.3.2. Examples 
 
 BEGIN . . . ; END 
 
 U.3.3. Semantics 
 
 A dummy statement executes no rules and performs no calculations 
 It is completely null. Dummy statements may serve as markers in unused 
 indices of a case statement. 
 
125 
 
 k.h. Case Statements 
 
 U.U.I. Syntax 
 
 <case statement> : := CASE <integer expression> 0F <statement list> ESAC 
 
 | <label> : <case statement> : <label> 
 h . k . 2 . Examples 
 
 CASE N 0F 
 
 PO(A,B); 
 P1(A,B 5 ); 
 P2(A,B) 
 ESAC 
 RESET: CASE GL0RP 0F 
 
 PX + PTR (A[K]); 
 PX «- PTR (B[K]) ; 
 PX -*■ PTR (C[K]) 
 ESAC : RESET 
 k.k.3. Semantics 
 
 Case statements allow one statement to be selectively executed from 
 a list of statements. The statements in the statement list are numbered 
 0,l,2,...,n. The integer expression is evaluated. If the value of the 
 arithmetic expression is k then the k statement is executed. If k is 
 out of range - i.e., k < or k > n then the n statement is executed. 
 Control proceeds to the statement immediately following the ESAC after the 
 appropriate statement is executed. 
 
126 
 
 1+.5. Procedure Statements 
 
 k . 5 • 1 • Syntax 
 
 <procedure statement> : := <procedure identifier> 
 
 <procedure identifier> (<actual parameter list>) 
 h . 5 . 2 . Example 
 
 SIN(X) 
 
 IOTER_PRODUCT ( A ,B ) 
 k.5'3. Semantics 
 
 A procedure statement serves to invoke (call for) the execution 
 of a procedure body (cf. procedure declarations). The effect of this 
 execution will be equivalent to the effect of performing the following 
 operations on the program at the time of execution of the procedure 
 statement . 
 U.5.3.1. Call by Value 
 
 All formal parameters quoted in the value part of the procedure 
 declaration heading are assigned the values of the corresponding actual 
 parameters, these assignments being considered as being performed explicitly 
 before entering the procedure body in the order in which the parameter 
 appears in the formal parameter list. The effect is as though an additional 
 block embracing the procedure body were created in which these assignments 
 were made to variable local to this fictitious block with types as given in 
 the corresponding specifications. As a consequence, variables called by 
 value are to be considered as nonlocal to the body of the procedure, but 
 local to the fictitious block. 
 1+.5.3.2. Call by Name 
 
 Any formal parameter quoted in the name list is replaced, through- 
 out the procedure body, by the corresponding actual parameter after enclosing 
 
127 
 
 this latter in parenthesis wherever syntactically possible. Possible 
 conflicts between identifiers inserted through this process and other 
 identifiers already present within the procedure body will be avoided by 
 suitable systematic changes of the formal or local identifiers involved. 
 
 4.5.3.3. Call by Reference 
 
 Any formal parameter not quoted in the name or value list is 
 called by reference. References which consist of a single variable, array, 
 structure, substructure, or element of an array are called by name after 
 having all subscripts of such variables called by value. Any pattern 
 variables and structure variables containing patterns and all other variables 
 and expressions will be called by value. 
 
 4.5.3.4. Body Replacement and Execution 
 
 The procedure body, modified as above, is inserted in place of 
 the procedure statement and executed. If the procedure is called from a 
 place outside the scope of any nonlocal quantity of the procedure body 
 the conflicts between the identifiers inserted through this process of 
 body replacement and the identifiers whose declarations are valid at the 
 place of the procedure statement or function designator will be avoided 
 through suitable systematic changes of the latter identifiers. 
 4.5-4. Syntactic Restrictions 
 4.5.4.1. Actual-Formal Correspondence 
 
 Actual parameters must normally correspond in number and type 
 to formal parameters in the procedure declaration in the order in which they 
 appear in both the actual and formal parameter lists unless the actual para- 
 meters are keyword parameters (cf. §3.2.1. & §4.5-4.2.) or default parameters 
 (cf. §5.12.3. & §4.5.4.3.). Furthermore, subscript ranges, string lengths, 
 and bases must agree with the actual parameters as they are defined in the 
 procedure declaration heading. 
 
128 
 
 U.5.^.2. Keyvord Specifications 
 
 Actual parameters which are predeceded by a keyvord (formal 
 parameter identifier followed by a colon) take one position in the ordered 
 list but are linked to the indicated formal parameter. 
 U.5.U.3. Defaults 
 
 Actual parameters that have default values may be indicated by an 
 asterisk, no expression - just the next comma, or by deleting all reference 
 to such parameters that appear at the end of the ordered parameter list. 
 k.J.k.k. Call by Value Restrictions 
 
 Procedure identifiers may not be called by value. 
 
129 
 
 k.6. Process Statements 
 k.6.1. Syntax 
 
 <process statement> : := SPAWN (<procedure statement>) 
 APPEND (<procedure statement;*) 
 INITIATE (<procedure statement> ,<process>) 
 TERMINATE 
 
 TERMINATE (<process>) 
 SUSPEND (<process>) 
 RESTART (<process>) 
 k.6. 2. Examples 
 
 APPEND (PQ(l)) 
 INITIATE (USER_JJZ>B S P[N]) 
 SUSPEND (P[kJ) 
 RESTART (PR0CESS_23) 
 TERMINATE 
 k.6. 3. Semantics 
 
 Process statements allow one to execute and monitor several asyn- 
 chronous processes. 
 
 In order to understand the process statements, one must understand 
 the OSL/2 philosophy. The current program in execution is an operating system 
 that exists on top of one or more other operating systems and is capable of 
 initiating new programs for which it may be the operating system. 
 
 The SPAWN command tells the operating system which supports the 
 current program to run a new and separate program in a manner identical to the 
 current program. SPAWN just enters a new job into the system. Any parameters 
 passed to a spawned procedure are called by value. 
 
130 
 
 APPEND initiates a procedure that is part of the current program. 
 This procedure can address any variahles global to it simultaneously with the 
 current program. Control cannot leave the "block that appended the procedure 
 until all such appended procedures in that block have returned. 
 
 INITIATE initiates a new program but allows the current program to 
 create new primitives and handle the existing operating system functions for 
 the new program. Each such program is identified by a process variable. If 
 the initiating program chooses not to redefine storage allocation, or any 
 other primitive for the initiated process, then those functions are by default 
 handled by the operating systems which support the initiating program. 
 
 SUSPEND and RESTABT perform the obvious functions for their specified 
 processes . 
 
 TERMINATE terminates the current program if no process is specified. 
 Otherwise, the specified process will be terminated. 
 
131 
 
 k.T. Iterative Statements 
 
 U.T.I. Syntax 
 
 <iterative statement> : := WHILE <Boolean expression> D0 <statement> 
 | D0 <statement> UNTIL <Boolean expression> 
 j F0R <integer expression> TIMES Dp <statement> 
 | F0R <integer variable> <- <integer for list> D0 <statement> 
 | F0R <variable> -*- <expression list> D0 <statement> 
 | <label> : <iterative statement> : <label> 
 
 <integer for list> : := <for list element> \ <integer for list>,<for list element> 
 
 <for list element> : := <integer expression> 
 
 | <integer expression> T0 <integer value> 
 
 i <integer expression> T0 <integer value> BY <integer value> 
 
 j <integer expression> STEP <integer value> WHILE <Boolean expression> 
 
 [ <integer expression> STEP <integer value> UNTIL <Boolean expression> 
 
 i <integer value> WHILE <Boolean expression> 
 
 [ <integer value> UNTIL <Boolean expression> 
 
 <integer value> : := <integer expression> VALUE ( <integer expression>) 
 
 1+.T.2. Examples 
 
 WHILE P = B D0 
 BEGIN 
 
 UI + 1; 
 B «- PIT (A[I]); 
 END 
 
 F0R A + "CAT", "D0G", "PE0PLE" D0 MATCH (A) 
 F0R B «- TO N BY 1 D0 A[B] + "NULL" 
 D0 A +- A + 1 UNTIL S.[A:l] = "A" 
 
132 
 
 J+.7-3. Semantics 
 
 Iterative statements will cause a statement to "be executed zero, one 
 or more times. Let S be a statement, B, a Boolean expression, I, an integer 
 expression, V, a variable, and E, any expression. Then the form and semantic 
 action associated with each iterative statement is as follows: 
 form 1: WHILE B D0 S 
 
 1 ) evaluate B . 
 
 2) if B is false, skip S and continue execution at the next 
 sequential statement. 
 
 3) if B is true, execute S and repeat this sequence starting 
 at 1). 
 
 form 2: D0 S UNTIL B 
 
 1) execute S. 
 
 2) evaluate B. 
 
 3) if B is false, repeat this sequence starting at l). 
 
 h) if B is true, continue execution at the next sequential 
 statement, 
 form 3: F0R I TIMES D0 S 
 
 1) evaluate I. 
 
 2) execute S I times, 
 form k: F0R V -e 
 
 a) I, 
 
 b) I ± T0 I 2 , 
 
 c) I 1 T0 I 2 BY I 3 , 
 
 d) I STEP I WHILE B, 
 
 e) I STEP I UNTIL B, 
 
133 
 
 lib 
 
 I WHILE B 5 
 I UNTIL B 
 D0 S 
 
 V ■*- I. 
 execute S. 
 
 continue execution with the next for list element. 
 
 if V > I skip S and continue execution "with the next for list 
 execute S. 
 
 V -e V + 1. 
 
 repeat sequence k~b starting at 2). 
 
 if I 3 > 0. 
 
 2.1) if V > I then start executing with the next for list 
 element . 
 
 kd: 
 
 2.2) if V < I then execute S. 
 
 2.3) skip to k) . 
 3) if I < 0. 
 
 3.1) if V < I then start executing with the next for list 
 element. 
 
 3.2) if V > I then execute S. 
 1+) V «- V + I . 
 
 5) repeat sequence ^c starting at 2). 
 
 1) v«. i 1 . 
 
 2) if B then execute S otherwise continue execution with the next 
 for list element. 
 
13h 
 
 3) V ■*• V + I 2 . 
 
 k) repeat sequence ^d starting at 2). 
 ke : as in k& with B replaced "by 'vB. 
 kti 1) V «- I. 
 
 2) if B then execute S otherwise skip S and continue execution 
 with the next for list element. 
 
 3) repeat sequence kf starting at 1. 
 kg: as in kf with B replaced by B. 
 
 Once all for list elements have been exhausted control continues 
 with the statement following S. 
 
 If an expression is qualified by value, e.g., 
 
 F0R I «- A + B T0 VALUE (C * D/3) BY 10 
 then the integer expression qualified by value (in this case it is 
 C * D/3) is evaluated only once at the beginning of the loop. This value 
 is stored in a temporary location and used for loop calculations. 
 
135 
 
 k.8. Escape Statements 
 
 U.8.1. Syntax 
 
 <escape statement> : := LEAVE <scope> ' LEAVE <scope> (<expression>) 
 
 <scope> : := <label> j <procedure identifier> ■ <trap identifier> 
 
 i+. 8.2. Examples 
 
 LEAVE A 
 
 LEAVE FONT (A*2) 
 
 LEAVE INNERLOOP 
 U.8.3. Semantics 
 
 Escape statements allow control to leave a procedure, trap condition, 
 or one or more nested blocks, compound statements, conditionals, or iteration 
 statements without executing all the statements following in the particular 
 construct being executed. 
 
 A procedure identifier following a leave causes control to leave 
 the indicated procedure body. If the procedure is used as a function, a 
 value may be returned. 
 
 The label following a LEAVE indicates that control is to escape 
 the range of the statement with that label. The escape expression must be 
 contained within the statement whose label is specified. One may use a 
 labelled LEAVE to escape one or more iterations, blocks, compounds, or 
 conditional statements. 
 
 If a trap identifier follows a leave then the indicate trap 
 condition is left and control continues where it left off. A value may be 
 returned. 
 
136 
 
 U.9. Pattern Matching Statement^ 
 
 U.9.1. Syntax 
 
 <pattern matching statement> : := <string> <pattern part> 
 
 ! <variable> <pattern part> 
 
 i <variable> <pattern part> «- <string expression> 
 <pattern part> : := <pattern expression> FIXED <pattern expression> 
 k . 9 . 2 . Examples 
 
 "ABCD" PATT 
 
 "ABCD" {"C"} 
 
 STRING FIXED PATT 
 
 VAR {{X <- {"A" I "B" I "CAT" | PATT}} & "L"} ■+- MT 
 i+ - 9 • 3- Semantics 
 
 A pattern statement matches a pattern against a string or string 
 variable. If a match is made, the value of the statement is true. Other- 
 wise the statement is false. A pattern statement may be used as a Boolean 
 expression. 
 
 If a successful match is made, that part of the string matched by 
 the pattern may be replaced by the value of the optional string expression 
 in the syntax above (U.lO.l). 
 
 The pattern matching algorithm proceeds from left to right and 
 attempts to match the innermost and leftmost patterns first. If two 
 patterns are concatenated ("&") then that defines one pattern which consists 
 of the first pattern immediately followed by the second pattern. For 
 example, the pattern "A" & "B" is equivalent to the pattern "AB". 
 
 If a pattern alternative list is specified the pattern alternatives 
 are tried one by one from left to right until one matches or the list is 
 exhausted. 
 
137 
 
 If at any time a match is made to a pattern secondary, the 
 value of the matched part of the string may be immediately assigned to 
 a string variable. For example, the pattern {S <- { "A" I "B" j "12"}}, 
 
 if it matches at any time during the execution of the pattern matching 
 algorithm, will necessarily assign the value "A", "B" , or "12" to string 
 variable S. Note: since subpatterns may match even if an entire 
 pattern does not match, this may lead to serious side effects. 
 
 Normally, a pattern match is made at the left most possible 
 position anywhere in a string. If a word FIXED preceeds the pattern in 
 the pattern statement, then the pattern must match beginning at the first 
 character in the string. 
 
 Within these constraints, pattern matching is recursively defined 
 and proceeds generally left to right and from inner-most to outer-most 
 nested patterns . 
 
138 
 
 U.10. Synchronization Statements 
 
 U.10.1. Syntax 
 
 <synchronization statement> : := P( <semaphore>) 
 
 ! V( <semaphore>) 
 <semaphore> : := <identifier> <identifier> <subscript> 
 U.10.2 Examples 
 
 P(sem) 
 
 V(sem) 
 It. 10. 3. 
 
 Semaphores are used to synchronize processes. All semaphores 
 are initialized at declaration time - normally to zero or one. When a 
 process performs a P operation, the indicated semaphore is decremented 
 by one. If the value of the semaphore is greater than or equal to zero, 
 then the process continues. If the semaphore is negative, then the process 
 is blocked and is booked on a waiting list for that semaphore. 
 
 A V operation adds one to a semaphore. If the semaphore is 
 greater than zero no other action is taken. If the semaphore is less than 
 or equal to zero then one process is removed from the waiting list for 
 that semaphore. The removed process is no longer blocked and will continue 
 execution at some time in the future. 
 
 
 
139 
 
 lj-.ll. Conditional Statements 
 
 4.11.1. Syntax 
 
 Conditional statement> : := IF <Boolean expression> THEN <statement list> FI 
 IF <Boolean expression> THEN <statement list> 
 ELSE statement list> FI 
 | <label> : Conditional statement> : <lahel> 
 
 4.11.2. Examples 
 
 IF A < B THEN R •«- R + 1 FI 
 0UTER: IF P THEN 
 BEGIN INNER: WHILE TRUE D0 
 BEGIN 
 
 X + X + 1; 
 
 IF A *■ X >= 3 THEN LEAVE 0UTER 
 
 ELSE A-*-X«-R*(X-«-X+l)FI; 
 
 IF A + X - 1 >= 3 THEN LEAVE INNER FI ; 
 
 X + X + 1 
 END : INNER 
 ELSE X ^ FI: 0UTER 
 
 4.11.3. Semantics 
 
 Conditional expressions may cause some statements to be skipped 
 depending upon the value of the Boolean expression in the if clause. 
 
 If the Boolean expression is true, the statement list immediately 
 following the THEN is executed. Control then skips over all remaining 
 portions of the conditional statement, if any, and resumes immediately 
 following the FI . 
 
 If the Boolean expression is false, the statement list immediate 
 following the THEN is skipped and control continues at the next sequential 
 
140 
 
 statement after the FI if no ELSE is present, or at the statement following 
 the ELSE if an ELSE is present. 
 
111! 
 
 5. Declarations 
 
 Declarations serve to define certain properties of the quant- 
 
 tities used in the program, and to associate them with identifiers . A 
 
 declaration of an identifier is valid for one block. Outside this block 
 
 the particular identifier may be used for other purposes. 
 
 Dynamically this implies the following: at the time of an entry 
 
 into a block (through the BEGIN) all identifiers declared for the block 
 
 assume the significance implied by the nature of the declarations given. 
 
 If these identifiers have already been defined by other declarations outside, 
 
 they are given a new significance for the time being. Identifiers which 
 
 are not declared for the block retain their old meaning. 
 
 At the time of exit from a block (through the END, or by an 
 
 escape statement) all identifiers which are declared for the block lose 
 
 their local significance. 
 
 A declaration may be marked with an additional declarator: 
 
 0WN or N0DE. 0WN and N0DE have the following effect: 
 
 0WN: The dimensions, sizes, and string lengths of quantities declared 
 to be own must be fixed value expressions - that is, they must 
 be calculable at compile time. Upon re-entry into a block, the 
 values of own quantities will be unchanged from their last exit. 
 In contrast, the values of declared variables that are not own, 
 and are not initialized in their declaration, are undefined. 
 
 N^DE: N0DE quantities are not available for use until allocated within 
 a block. They may be allocated or released an indefinite number 
 of times in any block. Whenever a node is released, the default 
 node (that is, one not specifically pointed to) is the most recently 
 
142 
 
 allocated node. Therefore, nodes may be used as stacks. When 
 used as stacks, push corresponds to allocate and pop to release, 
 
 Apart from the standard functions (cf. 3.2.1+., Standard 
 
 Functions) and labels, all identifiers of a program must be declared. 
 
 No identifier may be declared more than once in any block head. 
 
 Syntax 
 
 <declaration> : := <integer declaration j <Boolean declaration 
 | <string declaration j <semaphore declaration 
 | <process declaration i <pointer declaration 
 | <structure declaration \ <trap declaration 
 j <pattern declaration j <access definition 
 | <access declaration j <procedure declaration 
 J <file declaration j <define declaration 
 
 
Ik3 
 
 5.1. Integer Declarations 
 
 5.1.1. Syntax 
 
 <id part> : := <identifier> ; (<id list>) 
 
 <id list> : := <identifier> ; <id list> ,<identifier> 
 
 <number of bits> : := <integer expression> 
 
 <array part> : := <empty> [<bound pair list>] 
 
 <bound pair list> : := <bound pair> <bound pair list>,<bound pair> 
 
 <bound pair> : := <lower bound> : <upper bound> 
 
 <lo"wer bound> : := <integer expression> ■ 
 
 <upper bound> : := <integer expression> 
 
 <initialization> : := <id part> <array part> 
 
 \ <id part> <array part> ■*- <expression> 
 <initialization list> : := <initialization> 
 
 ! <initialization list> ,<initialization> 
 <storage class> : := <empty> j 0WN | N0DE 
 <integer declaration : := <storage class> INTEGER initialization list> 
 
 5.1.2. Examples 
 
 INTEGER A,B,C, (X,Y,Z) [0:10] + 
 INTEGER A -t-.q, B «- I," (C,D) «- 3 
 N0DE INTEGER X «- 3 , Y(32), Z(l6) 
 
 5.1.3. Semantics 
 
 Identifiers declared to be integer can only take on integer values 
 If a bound pair list is specified, then the corresponding identifiers all 
 have the specified number of array indices with the specified bounds. 
 
 Initialization is performed at allocation time if specified. Thus 
 each time node X is allocated in the above example, it is automatically 
 set to the value 3. 
 
lkk 
 
 5.2. Boolean Declarations 
 
 5.2.1. Syntax 
 
 <Boolean declaration : := <storage class> B00LEAN <initialization list> 
 
 5.2.2. Examples 
 
 B00LEAN A,B,C 
 
 0WTJ B00LEAN HAVE_I_C0ME_HEBE_BEFORE + FALSE 
 
 5.2.3. Semantics 
 
 Boolean identifiers can only take on Boolean values. Other than 
 that their declaration is analogous to integers. 
 
1^5 
 
 5.3. String Declarations 
 
 5.3.1. Syntax 
 
 <string parameter part> : := <empty> j (<length>) ( <length> ,<size>) 
 
 <length> : := * | * <integer expression> <integer expression> 
 
 <size> : := <integer expression> 
 
 <string specification> : := <id part> <string parameter part> <array part> 
 
 <string initialization> : := <string specification> 
 
 J <string specification> •*■ <string expression> 
 <string initialization list> : := <string initialization> 
 
 ; <string initialization list> ,<string initialization 
 <string declaration> : := <storage class> STRING <string initialization list> 
 
 5.3.2. Examples 
 
 STRING A,B,C" 
 
 STRING X(20,8),(Y,Z)(*10,3) + MS 
 
 5.3.3. Semantics 
 
 String variables take on string values. Their declaration is 
 analogous to integers. The default string parameters are maximum length 
 = 32 characters, size = 8 bits, and variable length. I.e., if size is 
 not specified, 8 is assumed, and if length is not specified, *32 is 
 assumed. An asterisk ("*") prior to the length indicates that the string 
 is variable length within the constraints of the maximum length specification, 
 
Ih6 
 
 5.U. Semaphore Declarations 
 
 5.1+.1. Syntax 
 
 <semaphore declaration : := SEMAPHORE initialization list> 
 
 5.1+.2. Examples 
 
 SEMAPHORE El , PRINTER-FINISHED «- 1, 
 
 SEMAPHORE E[20:25], P23 
 5 . U . 3 - Semantics 
 
 Semaphore declarations define semaphores for use in syncnroni- 
 zation statements. Unless otherwise initialized, all semaphores are set 
 to zero at declaration time. 
 
Ikl 
 
 5.5. Process Declarations 
 
 5. 5.1« Syntax 
 
 <process declaration> : := PR0CESS <id part> <array part> 
 
 j <process declaration ,<id part> <array part> 
 5.5*2. Examples 
 
 PR0CESS A,B 
 
 PROCESS P[0:15] 
 5.5.3. Semantics 
 
 Processes are declared analogous to integers. Process 
 identifiers are used to label processes for process statements. 
 
1U8 
 
 5.6. Pointer Declarations 
 
 5.6.1. Syntax 
 
 <pointer declaration : := <storage class> P0INTER <initialization list> 
 
 5.6.2. Examples 
 
 P0INTER P1,P2[0:3] 
 P0INTER PTR30 «- NULL 
 
 5.6.3. Semantics 
 
 Pointers take on pointer values and are declared in a manner 
 analogous to integers. Pointers may not be own. 
 
1^9 
 
 5.7- Structure Declarations 
 
 5.7.1. Syntax 
 
 declaration list> : := <declaration> j declaration list> ;<declaration> 
 <structure part> : := (< declaration list>) 
 
 <structure element> : := <id part> <structure part> <array part> 
 <structure element list> : := <structure element> 
 
 | <structure element list> ,<structure element> 
 <structure declaration> : := <storage class> STRUCTURE <structure element lict> 
 
 5.7.2. Examples 
 
 STRUCTURE PAYR0LL (STRING NAME; INTEGER SALARY) 
 N0DE STRUCTURE LISTELEMENT (STRING ENTRY; 
 
 STRUCTURE PTRS (P0TNTER BACK, LEFT, RIGHT)) 
 
 5.7.3. Semantics 
 
 Structure identifiers allow -whole data structures to be referred 
 to by one identifier. Each individual part of the structure may be used 
 in the manner that its data type indicates. 
 
150 
 
 5.8. Trap Declarations 
 
 5.8.1. Syntax 
 
 <trap declaration : := 0N <trap identifier> <formal parameter part> 
 
 D0 <statement> 
 
 5.8.2. Examples 
 
 0N INDEX D0 TERMINATE 
 
 0N DIVIDE-BY-ZER0 (NUMERAT0R) D0 
 
 LEAVE DIVIDE-BY-ZER0 (CASE NUMERAT0R 0F 0,1,99999) 
 
 5.8.3. Semantics 
 
 Trap declarations specify what action is to be taken when a 
 trap occurs. When the indicated trap is caused the statement following 
 the "D0" is executed. Upon leaving the trap, control is returned where 
 the trap occurred. Trap conditions and the parameters passed are 
 installation dependent. There are four traps that OSL/2 can inherently 
 generate: index out of range, divide by zero, integer overflow, and 
 convert failure. 
 
 
151 
 
 5-9« Pattern Declarations 
 
 5.9.1. Syntax 
 
 <pattern declaration : := <storage class> PATTERN <initialization list> 
 
 5.9.2. Examples 
 
 PATTERN ALPHABETIC <- SPAN ("ABC") 
 PATTERN X,Y,Z[1:3] 
 
 5.9.3. Semantics 
 
 Patterns are declared in a manner analogous to integers. Identifiers 
 declared to be patterns may only take on patterns as their values. 
 
152 
 
 5.10. Access Definitions 
 
 5.10.1. Syntax 
 
 <access definition : := <access> <access type> 
 
 <access formal parameter part>; <access definition t>ody> 
 <access> : := ACCESS | QUEUE | STACK | TABLE 
 <access type> : := <identifier> 
 <access formal parameter part> ::= <empty> 
 
 I <access formal parameters;- ;<access formal parameter specification 
 <access formal parameters> : := (<formal parameter list>) 
 
 (<formal parameter list> ) [<array parameter list>] 
 [< array parameter list>] 
 <formal parameter list> : := <id list> 
 <array parameter list> : := <array parameter> 
 
 I <array parameter list>,<array parameter> 
 <array parameter> : := <identifier> 
 
 <array parameter> :<identifier> 
 <access formal parameter specification : := <access formal parameter declarat: 
 <access formal parameter specification , 
 <access formal parameter declaration 
 <access formal parameter declaration> : := <integer declaration> 
 <Boolean declaration | <string declaration> 
 I <pointer declaration> <structure declaration> 
 <pattern declaration 
 <access definition body> ::= BEGIN <prefix declaration list> ; 
 <procedure declaration list> <access end> 
 
153 
 
 <access end> : := END | ; END 
 
 <prefix declaration list> : := <prefix declaration> 
 
 | <prefix declaration list> ;<prefix declaration> 
 
 <prefix declaration> : := <integer declaration 
 
 | <Boolean declaration> j <string declaration> 
 | <pointer declaration> j < structure declaration 
 I <pattern declaration> j <semaphore declaration> 
 
 <procedure declaration list> : := <procedure declaration 
 i <access procedure declaration> 
 
 j <procedure declaration list> ;<procedure declaration 
 | <procedure declaration list> ;<access procedure declaration 
 
 <access procedure declaration> : := <procedure type> <access type> 
 PROCEDURE <identifier> <formal parameter part> 
 <array parameter part>;<name or value> 
 <formal declaration list> <procedure "body> 
 
 <array parameter part> : := <empty> 1 [<id list>] 
 
154 
 
 5.10.2. Examples 
 
 QUEUE FIF0 (DEFAULT); INTEGER DEFAULT ■*- 0; 
 BEGIN 
 
 INTEGER DV + DEFAULT , QLENGTH +■ 0; 
 
 POINTER (HEAD, TAIL) «- NULL; 
 
 N0DE STRUCTURE ENTRY (INTEGER DATA; 
 
 POINTER NEXT) ; 
 FIF0 PR0CEDURE ST0RE(X) ; INTEGER X; 
 BEGIN 
 
 TAIL «- TAIL. ENTRY. NEXT «- ALLOCATE (ENTRY); 
 QLENGTH «- *+l; 
 ENTRY. DATA -e- X; 
 END ST0RE; 
 
 INTEGER FIF0 PROCEDURE FETCH [N]; INTEGER N «- 
 IF N<=0 
 THEN 
 
 IF QLENGTH=0 THEN FETCH «- DV 
 
 ELSE 
 
 BEGIN 
 
 P0INTER H + HEAD; 
 FETCH + HE AD. ENTRY. DATA; 
 HEAD +- HEAD. ENTRY. NEXT; 
 QLENGTH + *-l ; 
 RELEASE (H. ENTRY) 
 END FI 
 
155 
 
 ELSE 
 
 IF QLENGTH<N THEN FETCH «- DV 
 
 ELSE 
 
 BEGIN 
 
 POINTER T <- HEAD; 
 F0R N TIMES D0 
 BEGIN 
 
 FETCH + T. ENTRY. DATA; 
 T «- T. ENTRY. NEXT 
 END 
 END 
 PI; 
 
 INTEGER FIF0 PROCEDURE LENGTH; LENGTH «- QLENGTH; 
 END FIF0 
 
 QUEUE MESSAGE (MSIZE) [n] ; INTEGER MSIZE «- 1, N + 20; 
 BEGIN 
 
 STRING MESSAGES (MSIZE ,l) [0 :N-l] ; 
 
 SEMAPH0RE INPUT «- N, 0UTPUT «- 0; 
 
 INTEGER (IN,0UT) «- , MV «- N ; 
 
 STRING ( MSIZE, 1) MESSAGE PR0CEDURE FETCH; 
 
 BEGIN 
 
 P (0UTPUT); 
 
 FETCH «- MESSAGES [0UT -*- (*+l) M0D MV] ; 
 V (INPUT) 
 END FETCH; 
 MESSAGE PR0CEDURE ST0RE(X); STRING X (MSIZE, l); 
 
156 
 
 BEGIN 
 
 P ( INPUT ) ; 
 
 MESSAGES [IN •*• (*+l) M0D MV] «- X: 
 
 V (0UTPUT) 
 END ST0RE 
 END MESSAGE 
 
157 
 
 5.10.3. Semantics 
 
 Access definitions define new access types for later use in 
 access declarations. Access variables are declared by an access declara- 
 tion. Access definitions define the format of access declarations and 
 define the semantics associated with an appearance of an access variable 
 in an OSL/2 program. 
 
 The access definition declares those formal parameters which 
 may be used in a corresponding access declaration. Parameters may be 
 passed for use at declaration time via a normal parameter list enclosed 
 in parentheses or via a parameter list enclosed in square brackets (i.e. 
 array parameter list) or both. Normal procedure parameter defaults and 
 conventions are allowed with the exception that key word parameters may 
 not be used in the array part enclosed in square brackets. 
 
 Each new access type must have a corresponding access declaration. 
 All variables declared in the prefix declaration list may only be referenced 
 by procedures in the procedure declaration list. For each instance of an 
 access variable, a complete set of variables in the prefix declaration 
 list is allocated. This is equivalent to the insertion of the prefix 
 declaration list in place of the access variable declaration with suitable 
 systematic changes of the identifiers to insure that the prefix declaration 
 list identifiers do not conflict with existing identifiers and that they 
 may only be manipulated by the procedures in the procedure declaration 
 list. 
 
 Procedure declarations appearing within the procedure declaration 
 list are defined to only be within the scope of the other procedures in 
 the procedure declaration list. Access procedure declarations declare 
 
158 
 
 procedures which may be referenced external to the procedure declaration 
 list and within the scope of the corresponding access variable. Access 
 procedures are indicated in the access definition by repeating the 
 identifier of the access type being defined prior to the use of the 
 reserved word "PR0CEDURE" in the procedure declaration. 
 
 When access procedures are invoked, an additional parameter, 
 not present in the formal parameter list, is added to the actual para- 
 meter list. This parameter appears first in the actual parameter list 
 and must be an access variable of the same type as the access procedure. 
 Each access variable is thus matched only to the access procedure of the 
 same type. If the access variable is subscripted, the subscript list 
 is passed to the procedure through the array parameter part of the access 
 procedure declaration. The parameters passed through the subscript 
 list obey all rules of procedure actual parameters and may be passed by 
 key word. 
 
 Two access procedures for each access type have special semantic 
 interpretations. The procedure named "fetch" is invoked automatically 
 when an access variable is encountered in an expression evaluation such 
 as the right hand side of an assignment statement. The type of procedure 
 "fetch" defined the type of the access variable on the right hand side of 
 an assignment statement. If "fetch" has any parameters, they must all be 
 defaulted. The procedure "store" is not typed and is invoked when the 
 access variable appears on the left hand side of an assignment statement. 
 The first parameter in "store" defines the type of the value stored into 
 an access variable. All other parameters must be defaulted. Both "fetch" 
 and "store" may be explicitly invoked as a normal function or procedure 
 call in the OSL/2 code. 
 
159 
 
 5.11. Access Declarations 
 
 5.11.1. Syntax 
 
 <access declaration : := <access type> <access> <access specification list> 
 <access specification list> : := <access specif ication>' 
 
 <access specification list> ,<access specification 
 <access specification> : : = <id part> <access standard parameter part> 
 
 <access array parameter part> 
 <access standard parameter part> : := <empty> (<actual parameter list>) 
 <access array parameter part> : := <empty> 
 
 i [<access array parameter list>] 
 <access array parameter list> : := <access array parameter> 
 
 I <access array parameter list> ,<access array parameter> 
 <access array parameter> : := <parameter> 
 
 I <access array parameter> : <parameter> 
 
 5.11.2. Examples 
 
 FIF0 QUEUE A,B,C 
 
 C0MPLEX TABLE ( X , Y ) ( NUMBER_0F_P0INTERS : 22 ) 
 
 SPECIAL ACCESS X(l5 ,2k) [0 :2 :100 ,SQRT] 
 
 5.11.3. Semantics 
 
 For each identifier in the access declaration id part, an 
 instance of an access variable is declared. Parameters are processed as 
 described in Section 5.10.3. 
 
i6o 
 
 5.12. Procedure Declarations 
 
 5.12.1. Syntax 
 
 <formal parameter list> : := <id list> 
 
 <name or value> : := <value part> <name part> <name part> <value part> 
 
 <value part> : := VALUE <id list> ; | <empty> 
 
 <name part> : := NAME <id list> ; | <empty> 
 
 <formal parameter part> : := (<formal parameter list>) : <empty> 
 
 <formal parameter declaration> : := <integer declaration> 
 <Boolean declaration> <string declaration> 
 <semaphore declaration <process declaration> 
 <pointer declaration> <structure declaration> 
 <pattern declaration> <access declaration 
 1 <procedure declaration> 
 
 <formal declaration list> : := <empty> ! <formal parameter declaration> ; 
 <formal declaration list> <formal parameter declaration> ; 
 
 <primitive or procedure> : := PRIMITIVE j PR0CEDURE 
 
 <procedure typo : := INTEGER | B00LEAN I STRING <string parameter part> 
 I P0INTER I STRUCTURE structure part> ! PATTERN ! <empty> 
 
 <procedure heading> : := <procedure type> <primitive or procedure> <identifier> 
 <formal parameter part>;<name or value> <formal declaration list> 
 
 <procedure t>ody> : := <statement> j F0RWARD | F0RMAL 
 
 <procedure declaration> : := <procedure heading> <procedure body> 
 
 5.12.2. Examples 
 
 PR0CEDURE ADD0NE; X «- X + 1 
 
 STRING PR0CEDURE A(S23) ; STRING S23; 
 
l6l 
 
 BEGIN 
 
 STRING SI, S2 -*■ MT; 
 
 WHILE S23 FIXED {SI «- {"A" | "B" | "C"}} t- MI D0 
 
 S2 ■*■ SI & S2; 
 
 END 
 
 INTEGER PR0CEDURE ADD(X) ; INTEGER X -*- 1; A «- A + X 
 5.12.3. Semantics 
 
 A procedure declaration serves to define the procedure associated 
 with a procedure identifier. The principal constituent of a procedure 
 declaration is a statement or a piece of code, the procedure body, which 
 through the use of procedure statements and/or function designators may be 
 activated from other parts of the block in the head of which the procedure 
 declaration appears. Associated with the body are identifiers to represent 
 formal parameters. Formal parameters in the procedure body will, whenever 
 the procedure is activated (cf. 3.2. Function Designators and U.5. Procedure 
 Statements) be assigned the values of or replaced by actual parameters. 
 Identifiers in the procedure body which are not formal will be either local 
 or non local to the body depending on whether they are declared within the 
 body or not. Those which are non local to the body may well be local to 
 the block in the head of which the procedure declaration appears. The 
 procedure body always acts like a block, whether it has the form of one 
 or not. If the identifier of a formal parameter is declared anew within 
 the procedure body, it is thereby given a local significance and actual 
 parameters which correspond to it are inaccessible throughout the scope 
 of this inner local quantity. 
 
 When a procedure declaration appears in a procedure heading to 
 declare a formal parameter, the procedure body is FORMAL. To allow for one 
 
162 
 
 pass compilation, a procedure body may Ue FORWARD. Thus the compiler is 
 notified of the formats of the procedure parameters but the actual declar- 
 ation of the procedure with a statement procedure body is deferred. 
 
 Formal parameters may receive default values. If the formal 
 parameter declaration is initialized, the initializing expression is 
 taken as a default. 
 5.12.J+. Values of Function Designators 
 
 For a procedure declaration to define the value of a function 
 designator there must, within the procedure body, occur one or more 
 assignments to the function identifier or an expression must be explicitly 
 specified in an escape statement. If no such expression is supplied, the 
 last assignment to the function identifier is used. 
 
 Primitive procedures are within the scope of initiated processes. 
 5.12.5. Specifications 
 
 In the heading, a specification part, giving information about 
 the kinds and types of the formal parameters must be included. In this 
 part no formal parameter may occur more than once. Specifications of 
 formal parameter must be supplied. Types, array dimensions, bases, and 
 lengths of all formal parameters are required in the specification part. 
 
 
163 
 
 5.13. File Declarations 
 
 5.13-1. Syntax 
 
 <file declaration : := FILE <identifier> <input output part> 
 
 <access technique> <record format> <system- parameters> 
 <input output part> : := INPUT | 0UTPUT | < empty > 
 <access technique> : := SEQUENTIAL | INDEXED 
 
 < empty > 
 <record format> : := ( <declaration>) 
 
 ( <declaration> , <blocking> ) 
 
 ( <declaration> ,<blocking> ,<number of records>) 
 <blocking> : := <integer expression> 
 <number of records> : := <integer expression> 
 <system parameters> : := [<actual parameter list>] <empty> 
 
 5.13.2. Examples 
 
 FILE CARDS INPUT SEQUENTIAL (STRING A(80),20) 
 
 FILE TTY SEQUENTIAL (STRING A(80)) [ u NBUFR=2 ,UNIT=TTY32" ] 
 
 5.13.3. Semantics 
 
 Files reside on secondary storage. Their declaration is normally 
 very device dependent. FILE declarations in OSL/2 provide the compiler 
 with the basic information desirable to check the source code. Details 
 of the file which are dependent upon a particular system are in the 
 system parameters . 
 
 Reading or writing from or to a file is done with simple assign- 
 ment statements to and from simple variables, arrays, and structures of 
 the same type and format of the record format declaration. 
 
16U 
 
 6. Compile Time Facilities 
 
 The dollar sign, "$" , indicates a compile time facility. It 
 is possible to declare compile time variables and execute most OSL/2 
 statements at compile time. 
 
165 
 
 6.1. Compile Time Declarations 
 
 6.1.1. Syntax 
 
 <define declaration : := DEFINE <define specification list> 
 <define specification list> : := <define specifications 
 
 | <define specification list> ,<define specification 
 <define specification> : := <identifier> <define parameter list> 
 
 = <define body> # 
 <define parameter list> : := <id list> 
 <define body> : := {any text including balanced DEFINE... # brackets 
 
 but not including a lone#} 
 <compile time declaration> : := $ <declaration> 
 <compile time statement> : := $ <statement> 
 
 6.1.2. Examples 
 
 DEFINE add(A,B) = ( $A) + ($B)# 
 
 DEFINE XX = X <- X + 2# 
 
 $INTEGER X,Y,Z + 0, Q «■ 3 
 
 $IF $X = $Y $THEN P «- $ELSE P «- 3 $FI 
 6.1.3- OSL/2 defines are identical to B5500 defines [23]. 
 
 The define declaration associates a text string with the define identifier. 
 The later appearance of the define identifier in the OSL/2 code will 
 cause the defined text to replace the identifier and that text will then 
 be compiled. If actual parameters are appended to the define, then each 
 occurrence of the corresponding formal parameter in the text will be 
 replaced by the actual parameter. Formal parameters in the text of the 
 define body must be preceeded by "$". The actual parameters passed to 
 
166 
 
 a parameterized define follow the identifier and may be enclosed in 
 either parentheses or square brackets. Each actual parameter is separated 
 by a comma. 
 
 If a variable declaration is preceded by a "$", then all variables 
 so declared are available for use at compile time. Their appearance later 
 in the OSL/2 code is replaced by a constant equal to their current value. 
 Any assignment statements with a compile time variable on the left hand 
 side must be executable at compile time. Thus they may only consist 
 of constants and compile time variables. 
 
 Any OSL/2 statement preceeded by a "$" is executed at compile 
 time. 
 
 Should there be any ambiguity of meaning resulting from a 
 compile time facility, that ambiguity must be resolved by preceeding 
 the appropriate compile time variables or reserved words within a state- 
 ment by a "$". All ambiguous syntax will be resolved as if all non 
 marked ambiguous variables and reserved words were not compile time 
 variables and reserved words. 
 
 In all cases a "$" may preceed any compile time variable or 
 reserved word. 
 
167 
 
 Appendix B 
 An OSL/2 Compiler 
 
 In order to provide hard knowledge of the implementation 
 difficulties of OSL/2, a compiler was generated. The exercise of 
 building the compiler did indeed have an impact on the language. In 
 many places, the syntax was restructured to allow for an easier parse 
 and to make code easier to generate. 
 
 The object code was generated for the OSL/2 machine - a 
 stack machine with arbitrary length words . There are a variety of 
 methods available for mapping variable length data into some fixed word 
 size. Since this is a straight forward operation that involves consider- 
 able coding time and would add little or nothing to the language, the 
 OSL/2 machine had an undefined word length sufficient to hold any single 
 data item. 
 
 Whenever a complex but straight forward operation was required, 
 it was postulated to exist as a single machine instruction. If one scans 
 through the code generators he will notice that the operators are produced 
 in the code listing as phrases - e.g. "DUPLICATE-TOP-OF-STACK-AND-LOAD- 
 INTEGER" which takes the address of an integer on the top of the stack, 
 duplicates the address and then performs a "LOAD- INTEGER" operation 
 using the address on the top of the stack. No mnemonic codes were used 
 in the hope that it would make the code more descriptive. 
 
 The addressing scheme used was the same one described in Chapter 
 k. Level and displacement couples are indicated on the code, and instruc- 
 tions are addressed by segment and instruction number. Each block is one 
 
168 
 
 segment. Instruction addresses appear in the object listing. A simple 
 program is included which shows the object listing format. 
 
 The compiler was built using a B5500 translator writing system 
 which produces a bottom up Floyd Production language parser [25]. The 
 syntax was written in TWINKLE [26] and the semantics in ISL [27]. This 
 system, unlike recursive descent translator systems, will not accept an 
 ambiguous language. This feature and the bottom up parsing technique helped 
 remove ambiguities from the language and made the production of object 
 code straight forward. 
 
 The complete OSL/2 language was not implemented. The implemen- 
 tation proceeded until most of the difficult points were ironed out. The 
 final language does differ slightly from the implemented language in places 
 where the syntax was slightly changed to make OSL/2 code more readable. 
 
 The semantics language ISL is an extension of B5500 ALGOL. While 
 coding the system, the author attempted to provide macros that duplicated 
 OSL/2 facilities. Unfortunately, the B5500 ALGOL macro facilities were 
 inadequate for this task. However, the exercise of producing the code 
 was carried out as if OSL/2 were available. In over 3000 lines of seman- 
 tics there were no instances where OSL/2 constructs, such as the lack of 
 a GO TO, were a hinderance. In fact, the concentration on OSL/2 structure 
 produced a more clean and well defined structure to the entire code than 
 is usually written by this programmer. Furthermore, there were many many 
 instances where OSL/2 constructs, in particular general access variables, 
 would have considerably helped the coding effort, reduced coding time, and 
 improved the readability of the code. 
 
 The primary lessons learned from the implementation effort were 
 that OSL/2 is implementable, general access variables are actually rather 
 
169 
 
 straight forward to implement, the program structure imposed by OSL/2 is 
 clean yet powerful, and the constructs of OSL/2 are useable and desirable. 
 
170 
 
 0SL2 /SYNTAX LISTED BY THESIS ON JANUARY 3* 1971 AT 1H9 A.M. 
 
 SRSWD OOOOOlCO 
 
 language: josi ?) 00000200 
 
 SPECIAL SYMPDI SjCPMMENTJ OOOOC3PC 
 
 AN <DSL2-PRPGRAM> « » ~ <PLPC><> OR <CPMPOUND-ST ATEMENT> OOOOOLCO 
 
 OR <PPPCEDURE-OECLARATlrN> J 00000500 
 
 <fc'EGjN> lt= *BEGlN / <REGIN> <COMNENT> ) 00000600 
 
 <tND> »» = *FND / <END> [<COMMFNT> / <*!> / <*b> ) i 00000700 
 
 <SEMI> »» = ti / <SEMI> <COMf/EMT> ) 00000800 
 
 <STATEMENT-l IST> «!■ LIST <statement> separator <semi> ; 00000900 
 
 <COMPOUND-STATEMENT> its <BEGTN> LIST OF <STATEMEK'T>S 00001000 
 
 SEPAPATFO BY <SEMI> <END> 00001100 
 
 / <OPEN"LABFL> <COMPOUND-ST ATEHENT> <CLOSE-L ABEL> ) 00001200 
 
 <STATEMEM7> »l = <ASSI GKMENT-STATEMENT> 00001300 
 
 / <-CASE-STATEMFNT> OOOOHCO 
 
 / <PRoCEDUPL-STATEMENT> 00001500 
 
 / <iterative-statfmfnt> oooohco 
 
 / <escape-statfmek>t> 00001700 
 
 / <pr0cfss-statfment> 00001600 
 
 / <event-statfment> 00001900 
 
 / <pattfrn-katching-state^ent> 00002000 
 
 / <cdnditional-statfment> 00002100 
 
 / <compound-statemef ! t> 00002200 
 
 / <bLGCK> 00002300 
 
 / <ALLnCATlUN-STATE^ENT> 00002400 
 
 / <DUHMY-STATFMENT> ) 00002500 
 
 <DUMMY-STATFMFNT> «* c EMPTY I 00002600 
 
 <ASSIGNK-EM-STATEMENT> »i = < I N-TEGE R-ASSl GNMENT> 00002700 
 
 / <BOClLEAN-ASSIGNVENT> 00002600 
 
 / <STpING-ASSlGMMENT> 00002900 
 
 / <P0INTER-ASSIGNPENT> <. 00003000 
 
 / <STPUCTURE"ASSIGNK'ENT> 00003100 
 
 / <PATTERN-ASSIGNMENT> ; " OOOO3200 
 
 <ARROW> ::= **■ / Us ; 00003300 
 
 <DECLARATIOK> It* <I NTEGER-PECL ARATI 0N> 00003*00 
 
 / <BOOl-EAN-OECLARATlPN> O0OO350C 
 
 / <STRlNG-DECLARATION> 0000360C 
 
 / <P0INTER-DECLARATI0N> OOOO37C0 
 
 / <EVENT-DECLARATI0N> 00003fr00 ■ 
 
 / <PR0CESS-DECLARATI0N> 00003900 ' 
 
 / <PROCEOUPE-DECLARATION> OOOOOfOl \ 
 
 / <PATTERN-DFCLARATlON> OOOCMOC < 
 
 / <STRUCTURE-OECLARATItrN> OO0C«?0C . 
 
 / <ACCFSS-DECL APATION> 0000<3'>.'i 
 
 / <CODE-DECLARA-TIPN> O0OC««0c i 
 
 / <F II E-DECLAPATlrN> 0000**^ 
 
 / <ACCESS-PLFlMTIOf^> 0000*^0 
 
 / <EVENT-ACTIPN-DFCL ARATIPN> 0C S!!I'rS 
 
 / <MACRO-DEF JNITIPN> OOOC«eC-0 
 
 / <DEFAULT-LEFINITIPN>) • °!!!SJ *? 
 
 <IP-PART> lie <*I> PS ENTFRIDINPFCLSTACK ,'SSJ.nS' 
 
 /K LIST OF [<*! > PS EKTFPIDINDFCLSTACK 1' SEPARATED BY t>t) iCCOOMO 
 
 <STORAGE-CLASS> lie EMPTY / *PWN' PS OWNDECLARATI PN OOOcSpOO 
 
 / <NOpE PS NOPFPECLARATION « °^°J 3 JJ 
 
 <KD"*CLASS-lNTFGEP*DECLAPATirN> Us #INTEGER PS IN'TEGERDECL AR AT ION OOOObfcCO 
 
 FflLLOwFO BY LIST PF °?°c 5 ^ 
 
 <INTEGER-IMTIALI?ATIDN>S SEPARATED BY COMMAS 00005600 
 
 PS ENDOFDATAPFCl ARAT10N I 00005/00 
 
171 
 
 <INTEGEf<-DECLARATlON> Ms <STPRAGE-CL ASS><NO-CL 
 
 <NO-CLASS-BOPLE:AN-DFCLARATlrN> «»e *BPOLFAN PS 
 
 FpLLOwEO BY LIST PF <BPPLFAN- I N I TI AL I 
 
 CpMMAS PS ENDOFDATADECLARATION J 
 
 <BOOLEAN-DFcl ARATlON> tta <STPRAGE-CL ASSxNO-CL 
 
 <NO-CLASS-STPlNf,-PFCl ARATIOK> H« ISTPING PS ST 
 
 FDLlOwfP BY LIST PF <STR I NG- I M T I AL I Z 
 
 CpMMAS ^s endofdatapfclaratipn ; 
 
 <STRIKG-Pf-CL*PATIPN> i:« <STOP A GF-CL A SS> <NO"CL 
 <EVEK-T-OEcLARATIPN> M* #FVFNT PS EvENTDF CL ARAT 
 
 t<ID-PART> FOLLPkED BY <APRAY-PART> 
 
 PS RESETIDLISTCOUKTFR] SEPARATFD BY 
 
 CpMMAs PS LNpPFDATArFCLARATION ) 
 <MO"CLASS-CPDE-pFCLAPATTPN> its #C0DE pS CODEpE 
 
 BY LIST OF [<IO-PART> FOLLOWED BY <AR 
 
 PS RESFTIDLISTCOUMFR 3 
 
 SFPARATFD BY COMMAS PS ENDOFD ATADECL A 
 <CPDE-DECLApATlpN> Ms <STORAoF-CL ASS> <NP-CLAS 
 <NO-CLASS-POINTFR-DFCLAPATIPN> Ms IPOINTER 
 
 PS POINTFROECLAPATIPN FOLLOWED BY LIS 
 
 <PPINTER-IMT!ALI7ATIGN>S SFPARATED B 
 
 PS ENDOFDATADFCLARATION f 
 <SUBSTRLiCTURF-OECLARATIPN> »« = 
 
 <NO-CLASS-IMTEGFR-DECLARATIOM> 
 
 / <NO-CLASS-pnoLEAN-PECLAPATION> 
 
 / <no-ci a'ss-strinc-peclaration> 
 
 / <NO-CLASS-CODE-pEfLARATIOK'> 
 
 / <NO-CLASS-pPlKTFR-DFCLARATIOM> 
 
 / <NO-CLASS-STpUCT(IPF-PECLARATTON> 
 
 / <no-class-prpcess-declaration> 
 
 / <no-cl ass-pat tepn-decl arat i ok> 
 
 / <accfss-declaratipn> 
 
 / <prpcedurl-declarati0n> 
 
 / <FlLf*DFCLAPATIPN> I 
 <NODF-CLASS> »t= *NODE PS NPDFDECL ARAT lOM / EMP 
 <P0IMER-DECLARATI0N> Ms <NOPE-ClASS> <MP-CLAS 
 <PROCESS"OECLARATlON> Ms <KOPE-CLASS> <NP-CLAJ" 
 <STRUCTLRL-DFCLARATION> ms <STOPAGF-CLA?S> 
 
 <KO-CLASS-STRUCTUpE-DECLAPATION> 
 
 PS ENpPFFNTlRFSTRliCTUPEDECLARATION ) 
 <NO-CLASS-STRUCTl!RE-DECLARATIPN> M« ^STRUCTURE 
 
 LIST pF <STRUCTURF-FLEMFNT>S SFPARATE 
 
 PS ENPOFDATADFCLARATION ) 
 <STRUCTLRE-ElEMFNT> tjs <ID-PART> <STRUC TURE-PA 
 
 PS RESFTIDLISTCOUMFR J 
 <NO-CLASS-PATTERK-OFCLARATlnM> » ts #PATTFRN PS 
 
 LIST pF <PATTERN-INITIALIZATI0M>S SEP 
 
 PS ENpOFDATADFCLAPATlON J 
 <pATTERN-DEcLARATTON> jj= <STPR AGF-CL A SSxNO-CL 
 <ACCFSS-DFFiMTlP^> Ms <AC"CrSS-HfAD ING> <accfs 
 <ACCESS-HEAD3KG> Ms [ fACCFSS / *QUEUF / *STAC 
 
 <*I> PS ACCESSIDEMIFIER 
 
 <FPRMAL-PARAMFTFR-JUNK> PS FNDPFACCES 
 <ACCESS-BOOY> Ms #BEGIN [ <P A SE -STRUCTURE > *; 
 
 t <ENTRY-STRUCTURF> ti / PS NOFMRYST 
 
 <ACCESS-PROCEPL)RE-DFCLARATirN-LlST>#; 
 <BASr-STRUCTL'RE> Ms <no-CLa SS-Sl NGLE-$TRUCT(IRE 
 
 PS STPUCTUREMUSTBFNAMFDFASE * 
 <EK'TRY-STRUf TLRF> Ms #NOOE PS NOpEPECL AR A T I ON 
 
 <rP-CL*SS-SINGLE-STPllCTuRE-PFCLARATIO 
 
 PS STRUCTURE Mil STPFNAMFDE NT RYJ 
 
 ASS-INiTFGFR-OEC 
 BPPLEANOECLARAT 
 ZATlON>S SEPARA 
 
 ass-boplean-dec 
 rhgdeclaratipn' 
 ation>s separat 
 
 ass-string-decl 
 ipm followed by 
 
 CLARATION FOLLO 
 RAY"PART> 
 
 IARATI0N>; 
 
 ION 
 
 TED BY 
 
 LARATlON>J 
 
 ED BY 
 
 ARATION>; 
 LIST OF 
 
 wEp 
 
 RATION } 
 
 s-code-declaration>; 
 
 T PF 
 
 Y COMMAS 
 
 ty ; 
 
 s-pointfr-decla 
 s-procfss-decla 
 
 RATinN>; 
 ration>; 
 
 ps structuredeclaration 
 d by commas 
 
 rt> <apray-part> 
 
 patterndeclaration 
 arated by commas 
 
 ass-pattern-declaration>> 
 s-pody> ; 
 
 K ) 
 
 shfading; 
 
 / PS nopasestru 
 
 RUCTURF ] 
 
 * #END PSFNDOFA 
 
 -PFCLARATIPN> 
 
 N> 
 
 CTURE ] 
 CCE sspody; 
 
 00005800 
 00005900 
 00006000 
 00006100 
 00006200 
 00006300 
 00006400 
 00006500 
 00006600 
 00006700 
 00006800 
 00006900 
 00007000 
 00007100 
 00007200 
 00007300 
 00007400 
 00007500 
 00007600 
 00007700 
 00007800 
 00007900 
 00008000 
 00006100 
 00008200 
 00008300 
 00008400 
 00008500 
 00006600 
 00008700 
 00008800 
 00006900 
 00009000 
 00009100 
 00009200 
 00009300 
 00009400 
 00009500 
 00009600 
 00009700 
 00009800 
 00009900 
 
 00010000 
 
 00010100 
 00010200 
 00010300 
 00010400 
 00010500 
 OOO1O6OO 
 00010700 
 00010800 
 00010900 
 
 0001 1000 
 OOOl 1 1 00 
 00011200 
 0001 1300 
 
 0001 1400 
 0001 1500 
 0001 1600 
 
 0001 1700 
 0001 leoo 
 
172 
 
 3T INTEGER 
 #BOOLFAN 
 #STRlNG 
 t #( *** 
 
 t) J& 
 
 <KO-CLASS-SlKGLE*STRUCTIlRF-nECLARATION> M = ^STRUCTURE 
 
 PS STRUCTUREPFCLAPATION <*I> PR ENTFR I P I NDECLST ACK 
 
 <STRUCTURE-KART> PS PESE T I DL I STCOUNTER 
 
 PS ENnCFOATADFCL ARATION; 
 <ACCESS-PRncrOURE-DECLARATlDN-LlST> ««= 
 
 LIST [ <PROCFniiRE-DFCLARATinN> 
 
 / <ACCf SS-PRrCF.nUPE"DFCLARATlON> J 
 
 SFPARATOR <semi>; 
 <ACCFSS"PR0CFDURF-DECLARATIPN> «« = < ACCE SS-PROCE PURE-HE AP I NG> 
 
 PS COpEBEGINPROCEBUPFPOpY <STATEMENT> 
 
 PS CODFENDPfrTCFDUREPODY PS CHECKNOTF ORMAL 
 
 PS ENDOFACCESSf'ROCEr>UREFOPYt 
 <ACCESS-PRDcFOUPE-HEA.DINri> »'= <PROr F.DURF-TYPF > <*I> PS CURRENT ACCESS I D 
 
 tpPDCEOURE <*!> PS PROCEDURE IDFNT I F I ER 
 
 PS ENTEPACCLSSPROCEPUREID 
 
 <FPRMAL-PARAMETER-JUNK> PS FNDPFPRPcEDUPEHE API NC, J 
 <ACCESS-DECl AhATlPN> «J= <ACCFSS*T YFE> PS ACCE SSPFCL ARAT I PN 
 
 [ ^ACCESS / ffJlJEUF / #STACK ] 
 
 LIST <ACCESS-PART> SEPARATOR COMMA f S . ENDOFDAT ADECL AR AT I ONJ 
 <ACCESS-TYPF> II- <*I> PT I S I P AN ACCF SST YPF I 
 <FR0CEDURE-HF.AniK6> M= <PRPC FPUPF -T YPf> ^PROCEDURE 
 
 <*I> pS PRPCEPUREIDENTIFIFR 
 
 <FPRMAL-PARAMFTER-JUNK> PS ENDHF PROCEDUpEHE API NG ; 
 
 <PPOCEDURE-TYPE> *«= EMPTY 
 
 / JfCODF PS CODEDECLARATION 
 
 PS INTEGFRDEf LARATIPN 
 PS POOLEANDECLARfiTION 
 PS STRINCDECLAPATION 
 <INTFGFR-EXPPESSI0N>R 
 [ ft <INTFGER-EXPRFSSI0N> 18 
 / IPOINTER PS POINTFRDECLARATIPN 
 / fSTRUCTuRE ®S STRHCTUREnEcLARATION 
 
 <STRUCTURE-PART> 
 / ^PATTERN PS pATTERNDFCLARftTlOM f 
 <FPRMAL-PARAMETFR-JUNK> ::= <FORMflL-PARAMFTER-LlST> <SEMT> 
 
 <VALUE-PART> <FORMAL-PAR AMETER-SPEC I FI CATION> / <SFMl> i 
 
 <FORMAL"PARAMETFR"LIST> >» = # C 
 
 LIST DFt<*I> «S FORMAL PARAMETER ] -rSEPARATFO PY t> #) 
 
 PS SCANNINGFPPMALPARAMETERDECLARATIONS t 
 <VALUE-PART> Jl = C*VALUE LIST PF t<*I> PS VALUE IPFNT IF IER 1 
 
 SEPARATED BY CPMMAS <SEMI>U f 
 <FPRMAL-PARAVETEP- SPECIFICATION : : = 
 
 LIST PF 
 
 <FORMAL-PARAMFTER-DFCLARATIPN>S SEPARATED BY <SFMI> <SEMI> 
 
 PS ENPOFFORMALS J 
 <FORMAL-PARAMETEP"DFCLARATlPN> f» = <I NTEfiER-DFCLARATI PN> 
 / <eOOLEAN-DECLARATlON> 
 / <STRlMG-DECL.ARATIPN> 
 / <EVENT-DECLARATlON> 
 
 / <cpde-declaratipn> 
 / <ppocfss-dfclaratlon> 
 / <pointer-declaration> 
 / <structure-pfclaratipn> 
 / <pattern-declaratipn> 
 / <accfss-dtclapatipn> 
 / <pr0cedure-peclarati0k> 
 / <filf-peclapatipn> > 
 
 <MACRO-DEFlMTIpN> lis *MACRO PS M A CRPPEF I N I T I ON 
 [ <NO-CL ASS-IMTFGER-DECLARATION> 
 / <ND-CLASS-BPnL EAN-PEC|..ARATIPM> 
 / <N0-CLASS-STRING-PECLARATT0N> 
 
 PS PUSMDUMMYID 
 
 00011900 
 
 000l?CP0 
 
 00012100 
 
 00012200 
 
 00012300 
 
 00012400 
 
 00012500 
 
 00012600 
 
 00012/00 
 
 00012800 
 
 00012900 
 
 00013C00 
 
 00013100 
 
 00013200 
 
 00013300 
 
 000J3400 
 
 00013500 
 
 00013600 
 
 00013/00 
 
 00013600 
 
 00013900 
 
 00014000 
 
 000H1C0 
 
 00014200 
 
 00014300 
 
 00014^00 
 
 00014500 
 
 00014600 
 
 00014700 
 
 00014800 
 
 00014900 
 
 00015000 
 
 00015100 
 
 00015200 
 
 00015300 
 
 00015400 
 
 00015500 
 
 00015600 
 
 00015700 
 
 00015600 
 
 00015900 
 
 00016000 
 
 00016100 
 
 00016200 
 
 00016300 
 
 00016400 
 
 00016500 
 
 00016600 
 
 00016700 
 
 00016800 
 
 00016900 
 
 00017000 
 
 00017100 
 
 00017200 
 
 00017300 
 
 00017400 
 
 00017500 
 
 00017600 
 
 00017700 
 
 00017600 
 
 00017900 
 
173 
 
 <F'ILE- 
 
 <qpen- 
 
 <CLGSE 
 <STRUC 
 
 <point 
 
 <INTEG 
 <bOOLE 
 <STRIN 
 <STR(jC 
 <PATTE 
 <EVEM 
 
 <PRDcf 
 
 <CODE" 
 
 <F ILE- 
 
 <STRL'C 
 
 <P0INT 
 <pATTP 
 <INTEG 
 
 <bOOLf- 
 <pROcE 
 <STRIN 
 <CODt- 
 <FlLE- 
 <SUBSC 
 
 <P0INT 
 
 <event 
 
 <ACCES 
 
 < I N T F. G 
 <PATTE 
 <PplNT 
 
 < S T R I N 
 
 <boole 
 
 <STR|iC 
 <STRl«C 
 
 / <NO-C 
 
 / <NO-C 
 
 / <PRpC 
 DECLARATION 
 
 LIST OF 
 
 PS ENDt) 
 LAPEL> Us 
 -LABEL > I t = 
 TORE "ASSIGN 
 
 <STRUCT 
 
 PS CDDE 
 Eh-ID> Ms 
 
 / <*I> 
 EK-ID> ll« 
 
 / <*I> 
 AN-ID> lis 
 
 / <*I> 
 G~ID> lis < 
 
 / <*I> 
 TURE-ID> i I 
 
 / <*I> 
 RN-ID> lis 
 
 / <*I> 
 -ID> its <* 
 
 / <*I> 
 
 SS-ID> Ms 
 / <*I> 
 
 I D > l|= < * I 
 / <*I> 
 
 ID> 11= <*I 
 / <*I> 
 
 TURE-FIRST- 
 PS SETC 
 ER-NA^f> |i 
 RN-NA|^F> ft 
 Ep-NAVE> It 
 
 an~name> 1 1 
 
 SS"KAmF> i» 
 G*NAME> 11 = 
 NAHE> lis [ 
 NAMt> lis [ 
 RlPT> 11= # 
 
 ER-SPECIFIF 
 
 / <P0IN 
 
 -VARlABLE> 
 S-Ili> lis < 
 
 Eh-f UNCTION 
 RN-f UNCTION 
 EP-f UnCTIpN 
 G -FUNCTION 
 AN-F UNCTION 
 T L. K f -FUNCTI 
 TURE-FXPRFS 
 / <STRU 
 / *IF < 
 
 LASS-PATTEPN- 
 LASS-STRI.lCTUR 
 EDURE-DECLARA 
 
 > I 1= *FILE P 
 C<*1> PS entf 
 FDATADFCLARAT 
 <*I> PS openi 
 
 #1 <*!> PS C 
 M E H T > lis <ST 
 URE-ExPRESSin 
 STRUCTIIPESTOP 
 <*I> PT TESTP 
 PT TESTPOINTE 
 <*I> PT TESTI 
 PT TESTINTEGF 
 <*I> PT TESTP 
 PT TLSTROOI'EA 
 *1> eT TESTST 
 PT TLSTSTRINr, 
 s <*l> ®T TES 
 PT TESTSTRUCT 
 <*I> PT TESTP 
 PT TESTPATTEP 
 I> PT TESTEVF 
 PT TESTEVENT 
 <*I> PT TESTP 
 PT TESTPROCES 
 
 > PT TESTCOOE 
 PT TESTCODE < 
 
 > PT TFSTFILE 
 PT TESTFILF 
 PART> lis LIS 
 URRENTSTRUCTU 
 
 [<STRUCTlJRT 
 [<STRUCTllRF 
 KSTRUCTtlpF 
 r<STRUCTuRF 
 [<STPUCTURF 
 
 [<STRMCTUFE- 
 <STRUCTlJRE-Fl 
 <STRUCTURE-FT 
 t PS STARTSUP 
 PS INCRSUBS 
 R> lis <P0INT 
 
 TER-SPFCIFIEP 
 « 1= <EVFNT-IT 
 *I> PT lOlSAC 
 
 > lis 
 
 <FUNCTI 
 <FUNCTT 
 <FUNCTI 
 <FUNCTI 
 <FUNCTI 
 > its <p L'NT 
 SION> I is <sT 
 
 cture-functio 
 
 boolean-exprf 
 
 > 
 > 
 
 > 
 > 
 
 ON 
 
 I l = 
 J I = 
 l I = 
 I I s 
 
 OECLARA 
 E-OFCLA 
 TION> I 
 S FILED 
 RIDINDE 
 ION ; 
 A PEL #1 
 LOSELAB 
 RUCTUPE 
 N> PS C 
 
 f; 
 
 OINTER 
 R <SUPS 
 NTEGER 
 R <SUPS 
 OOLEAN 
 N <SUPS 
 RING P 
 <SURSC 
 TSTPUCT 
 URF <SU 
 ATTpRN 
 N <SUPS 
 NT PS 
 <SURSCR 
 ROCF SS 
 S <SUBS 
 
 PS MU 
 SURSCPI 
 
 PS MU 
 <SUPSCR 
 T [ <ST 
 REPTR 1 
 -F TRST- 
 -FlRST- 
 -FlRST- 
 -EIRST- 
 -FIRST- 
 FIRST-P 
 RST-PAR 
 RST-PAR 
 SCRIPT 
 CRIPT I 
 ER-NAME 
 
 > <pOIN 
 
 > t 
 
 CESS t 
 ON> PT 
 
 PT 
 
 TIOM> 
 RATI0N> 
 
 i 
 
 FCLARAT 
 CLSTACK 
 
 i 
 
 FL I 
 -VARIAB 
 
 mecktha 
 
 PS MUS 
 CRlPT> 
 
 PS MUS 
 CRIPT> 
 
 PS MUS 
 CRIPT> 
 S MUSTB 
 RIPT> P 
 URE PS 
 PSCRIPT 
 
 PS MUS 
 CRlPT> 
 MUSTBEU 
 IPT> PS 
 
 PS MUS 
 CRlPT> 
 STBFUNS 
 PT> PS 
 STBFUNS 
 IPT> PS 
 RllCTURE 
 
 SEPARA 
 PART>#, 
 PART>#, 
 PART>*. 
 PART>*. 
 PART>#. 
 ART>*. 3 
 T>#.3& 
 T>#.]R 
 LISTKI 
 
 SEPARA 
 > *. 
 TER-NAM 
 
 ION 
 ] SFPARATOR 
 
 LF> <ARROw> 
 TSTRUCTURESARFTHESAME 
 
 .TPEUNSUBS 
 
 PS CMECKS 
 .TREUNSUBS 
 
 PS CHECKS 
 • TF-EUWSUBS 
 
 PS CHFCKS 
 
 IFUNSUBSCR 
 
 ! S CHFCKSU 
 
 MUSTPEUN 
 
 > PS CHEC 
 ■TPEUNSUBS 
 
 PS CHECKS 
 
 INSUBSCRIP 
 
 CHECKSUB 
 
 ■ TPEUNSUBS 
 PS CHECKS 
 
 .UPSCRTPTE 
 CHECKSUBS 
 
 .UPSCRIPTE 
 .CHECKSUB 
 
 >ID> 
 
 ■ TOR #. ; 
 ]& <POINT 
 
 <PATTE 
 <IMTEG 
 <RnOLE 
 <*P P C E 
 <STPING 
 
 CRIPT 
 
 URSCR 
 
 CRIPT 
 
 UPSCR 
 
 CRIPT 
 
 UPSCR 
 
 IPTEO 
 
 RSCRT 
 
 SUBSC 
 
 K S U P S 
 
 CRIPT 
 
 UBSCR 
 
 TFD 
 
 SCRIP 
 
 CRIPT 
 
 UBSCR 
 
 
 
 CRIPT 
 
 
 
 SCRIP 
 
 ED 
 
 IPTMATCH J 
 ED 
 
 IPTMATCH \ 
 ED 
 IPTMATCH J 
 
 PTN'ATCH ; 
 RIPTFD 
 CRIPTMATCH ) 
 ED 
 IPTMATCH ) 
 
 TMATCH ; 
 ED 
 IPTMATCH I 
 
 MATCH ; 
 
 TMATCH J 
 
 U 
 H 
 
 ft 
 
 <CDDF-ID> 
 <FILF-ID> 
 NTEGEP-EX 
 TOR *p #3 
 
 E> *. $ 
 
 ER-TD> PS 
 
 RN-ID> PS 
 
 Ep-IO> PS 
 
 AN-TO> PS 
 
 SS"I0> PS 
 
 -id> ps resetspt^ 
 ps resetspt; 
 ps resetspt; 
 
 pression> 
 
 J 
 
 rfsftspt; 
 resetspt; 
 resetspt; 
 resetspt; 
 resetsptj 
 
 ON> 
 ON> 
 ON> 
 ON> 
 
 PT 
 PT 
 PT 
 
 *CASE <INTEGER-FXP 
 <STRUCTUF<E-EXPRFSS 
 
 TI0N> a 
 RUCTURE 
 N> 
 SSIDN> 
 
 RF SSION 
 ION-LIS 
 
 FUNCTIO 
 FUNCTIO 
 FUNCTIO 
 FUNCTIO 
 FUNrTIO 
 T FHNCT 
 -VARl AB 
 
 «THFN < 
 #ELSE < 
 PS CHFC 
 PS MOVE 
 > #OF 
 T> «FSA 
 
 nisimteger ; 
 mspattern ; 
 mispointer ; 
 misstring ; 
 nisbppleam ; 
 ipnisstructupf | 
 
 LF> 
 
 STRUCTURE-FxPRESSlnN> 
 STRUCTURE-EXPRESS I ON> 
 KTHATSTR UCT URFSARETHESA ME *EI 
 0SLPSFMFIFLDFROM1TO6 
 
 000160C0 
 00018100 
 00016200 
 00015300 
 00018400 
 00016500 
 00018600 
 0001870C 
 00016800 
 00016900 
 00019000 
 00019100 
 00019200 
 000193C0 
 OOO194OO 
 00019500 
 00019600 
 00019700 
 00019600 
 00019900 
 00020000 
 00020100 
 00020200 
 0OO203C0 
 00020400 
 00020^00 
 000?0600 
 00020700 
 OOO2O6OO 
 OO02O9C0 
 00021000 
 00021100 
 00021200 
 00021300 
 0002U00 
 00021500 
 00021600 
 00021700 
 00021600 
 00021900 
 00022000 
 00022100 
 00022200 
 00022300 
 00022400 
 00022500 
 00022600 
 000227C0 
 00022600 
 00022900 
 00023000 
 00023100 
 00023200 
 00023300 
 00023^00 
 00023500 
 00023600 
 00023700 
 00023H00 
 00023900 
 00024000 
 
nk 
 
 PS 
 <STMjCTURF-FXPR 
 / <ST 
 PS 
 
 <default-def -)u\ 
 
 t * I N 
 
 / * I M 
 
 / V ) N 
 
 / *ST 
 
 / *ST 
 
 <STRlNG-CODr> * 
 
 <PR0CFDURE.-ST/<1 
 
 / <F ;, R 
 
 <FUNCTIUN> :'.-.- 
 
 PS 
 
 / <(-R 
 
 <AC 
 
 <ACUlAL-PARANFT 
 
 PS EN 
 
 <ACTliAL-PARA»'f. T 
 
 t e 
 
 r 
 
 / p 
 r 
 
 / « 
 t 
 
 / e 
 C 
 
 / P 
 t 
 
 r 
 
 c 
 
 / p 
 [ 
 
 / p 
 
 r 
 
 / p 
 [ 
 
 / ^ 
 [ 
 
 c 
 
 PS 
 / <AC 
 [ P 
 
 r 
 
 MfU'FnSL 
 
 fssion- 
 pucturf 
 
 CHFCKTH 
 
 TlON> : 
 TFGER * 
 TF.GFR # 
 TFGER # 
 PING #( 
 RING #= 
 i- *RCL 
 FMFNT> 
 pCFDURE 
 <PROCED 
 CHFCKTH 
 pCFDURE 
 TUAL-PA 
 
 fp-list 
 
 nPFACTU 
 
 PR-FIRS 
 
 T CHFCk 
 
 <PROCE 
 
 / **& 
 
 T CHFCK 
 
 <ACCFS 
 
 / **& 
 
 T CHFCK 
 
 <INTEG 
 / #*R 
 
 T CHECK 
 <ROOLE 
 / #** 
 
 T CHECK 
 <STRIN 
 / #*& 
 
 T CHECK 
 <POINT 
 / #*& 
 
 T CHECK 
 <PATTE 
 / #*S 
 
 T CHECK 
 <STRUC 
 / #*S 
 
 T CHECK 
 < EVE NT 
 / #*8 
 
 T CHECK 
 <FILE- 
 / #*R 
 
 T CHECK 
 <PROCE 
 / **& 
 
 T CHECK 
 <CODF- 
 / #*& 
 
 GFTNFXT 
 
 TUAL-PA 
 
 T CHECK 
 <PROCL" 
 / #*& 
 
 2SF. 
 
 LIS 
 
 -FX 
 
 ATS 
 
 l = 
 
 ( < 
 
 = [ 
 
 ( < 
 
 <L 
 
 <S 
 
 /* 
 
 : i = 
 
 -TO 
 
 UPF 
 ATP 
 
 -in 
 
 RAM 
 > : 
 
 AI.P 
 
 T-P 
 
 I FN 
 
 DUR 
 
 PS 
 
 IFN 
 
 s-i 
 
 MS 
 IFN 
 
 FP- 
 PS 
 IFN 
 AM- 
 PS 
 IFN 
 G-F 
 PS 
 IFN 
 ER- 
 PS 
 IFN 
 RN- 
 PS 
 
 I FN' 
 
 TOP 
 
 PS 
 
 IFN 
 
 -VA 
 
 PS 
 
 IFN 
 
 VAP 
 
 PS 
 
 IFN 
 
 SS- 
 
 PS 
 
 IFN 
 
 VAP 
 
 PS 
 
 PAR 
 
 RAM 
 
 IFN 
 
 DUR 
 
 PS 
 
 MFIEL 
 T> : • 
 
 PRFSS 
 TRl'CT 
 *Df FA 
 INTER 
 * ONES 
 IN TEG 
 ENGTH 
 T R 1 N G 
 
 pen/* 
 
 <PRO 
 
 > <AC 
 -ID> 
 ARMSN 
 
 > FT 
 
 FTFR- 
 
 := <A 
 
 ARAMF 
 
 ART> 
 
 FXTFP 
 
 F-ID> 
 
 CODED 
 
 FXTFP 
 
 D> PS 
 
 CODFD 
 
 FXTFP 
 
 fxprf 
 
 CODFD 
 FXTFP 
 EXPRF 
 CODED 
 FXTFP 
 XPPFS 
 CODED 
 FXTFP 
 
 exfrf 
 
 CODFD 
 
 FXTFP 
 
 FXPRF 
 
 CODFD 
 
 FXTFP 
 
 F-FXP 
 
 CODED 
 
 FXTFP 
 
 RIAPI 
 
 CODED 
 
 FXTFP 
 
 IAPLF 
 
 CODFD 
 
 FXTFP 
 
 V A p I A 
 
 CODED 
 
 FXTFF 
 
 IAPLF 
 
 CODED 
 
 M 
 
 ETFR- 
 
 FXTFP 
 
 F - I D > 
 
 CODFD 
 
 DFROM1 
 
 = <STP 
 
 ION-LI 
 
 URESAR 
 
 ULT 
 
 FR-EXP 
 
 /*UOS 
 
 FR-EXP 
 
 >#><SI 
 
 -CODF> 
 
 FPCDIC 
 
 CEDURF 
 
 TUAL-P 
 
 PT CHF 
 
 OTREQH 
 
 CHECKT 
 
 LIST> 
 
 CTUAL- 
 
 TERSCA 
 
 t t= #( 
 
 ISAFRD 
 
 PSCOD 
 FFALILT 
 ISACCF 
 
 COUFA 
 EFAULT 
 ISINTE 
 SSION> 
 FFAULT 
 ISPDOI 
 SSIDN> 
 FFAHLT 
 ISSTRI 
 SlON> 
 EFAULT 
 ISPOIN 
 SSION> 
 FFAULT 
 ISPATT 
 SSlON> 
 FFAULT 
 ISSTRU 
 RESSIO 
 FFAULT 
 ISEVEN 
 F> PS 
 FFAULT 
 ISFILF 
 
 > PS C 
 EF AliLT 
 ISPPOC 
 PLF> P 
 EFAULT 
 ISCDDF 
 
 > PS C 
 EFAULT 
 
 TD4 » 
 
 UCTURF-EXPRFS 
 ST> ft <STRUC 
 ETHESAME I 
 
 RFSSION> 
 I 
 
 RFSSTON> 
 ZF> *) t 
 
 M 
 /*ASr I T 7 
 -ID> PS 
 ARAMFTER 
 CKTHATID 
 IPFD 
 HATIDIST 
 
 ; 
 
 paramfte 
 
 N) 
 PS SETU 
 
 CFDURE 
 
 EPROCFDU 
 
 PROCFDUR 
 
 SS 
 
 CCESSIDA 
 
 A C C F S S I D 
 
 GFR 
 
 PS CODE 
 INTEnFRA 
 FAN 
 
 PS CODE 
 ROOLEANA 
 NG 
 
 PS CODES 
 STRlNGAC 
 TFR 
 
 PS rODE 
 POINTERA 
 F.PN 
 
 PS CODE 
 PATTFRNA 
 CTURF 
 N> PS CO 
 STPUCTUR 
 T 
 
 CHDEFVEN 
 EVENTACT 
 
 #) 
 
 * ) * 
 
 *= <S 
 
 / 1 A S C 
 
 CHECK 
 -LIST 
 ISTYP 
 
 YPED 
 
 R-FIR 
 
 PACTU 
 
 RFIDA 
 EIDAC 
 
 CTUAL 
 ACTUA 
 
 INTER 
 
 CTUAL 
 
 POOLF 
 CTUAL 
 
 TRING 
 TUALP 
 
 POINT 
 CTUAL 
 
 PATTF 
 CTUAL 
 
 DFSTP 
 E A C T U 
 
 TACTU 
 UALPA 
 
 SlON> 
 TURF-EXPRESS10N> 
 
 =[#ONFS/*TWOSl 
 TRING-CODE>]& 
 
 us; 
 
 THATPARMSNOTRFQUIRED 
 
 > ; 
 
 FD 
 
 DDFFIl EACTUAL 
 
 F ILEACTUALPAR 
 
 FSS 
 
 S CODFPROCESS 
 
 PROCFSSACTUAL 
 
 DDFCDDEACTUAL 
 CODEACTUALPAR 
 
 FIPST-PART> t, 
 ISAPPDCFDURF 
 
 PSfODFPROCFDURFIPA 
 FFAULTPROCFDURFIDAC 
 
 ST-PART> f) 
 
 ALPARAMFTFRSCAN 
 
 CTUALPARAMFTER 
 TUALPARAMETEP ] 
 
 PARAMETFR 
 LPARAMETFR ] 
 
 rRACTUALPARAMFTER 
 PARAMETFR ] 
 
 ANACTUALPARAMFTER 
 PARAMETFR 1 
 
 ACTUALPARAMETER 
 ARAMFTER ] 
 
 FRACTUALPArAmFTER 
 PARAMETER ] 
 
 PNACTUALPARAMFTER 
 PARAMFTFR ] 
 
 UCTURE ACTUAL PARAMETER 
 ALPARAMFTER ] 
 
 ALPARAMFTER 
 PAMETFR 1 
 
 PARAMETFR 
 AMETFR 1 
 
 ACTUALPARAMETER 
 PARAMFTFR ] 
 
 PARAMFTFR 
 AMETFR ] ] 
 
 CTUALPARAMFTER 
 TUALPARAMETEP ] 
 
 00024100 
 0002^200 
 00024300 
 00024400 
 00024500 
 0002^t>00 
 00024700 
 00024600 
 00024900 
 00025000 
 00025100 
 00025200 
 00025300 
 00025400 
 00025500 
 00025600 
 00025700 
 00025600 
 00025900 
 00026000 
 00026100 
 00026200 
 00026300 
 00026400 
 00026500 
 00026600 
 00026700 
 00026fa00 
 00026900 
 00027000 
 00027100 
 00027200 
 00027300 
 00027400 
 00027500 
 00027600 
 00027700 
 00027600 
 00027900 
 0002b000 
 00026100 
 00026200 
 00026300 
 00028400 
 00028500 
 00026600 
 00028700 
 00026600 
 00026900 
 00029000 
 00029100 
 00029200 
 00029300 
 00029400 
 00029500 
 00029600 
 00029700 
 00029800 
 00029900 
 00030000 
 00030100 
 
175 
 
 CPHMFNT 
 bLOCio 
 
 LOWER-fc 
 
 UPPER-b 
 INTEGER 
 
 ARRAY-F 
 APRAY-F 
 
 iDDlFAN 
 
 ,ENGTH> 
 
 / PT CHECKIFNFXTFPISACCFSS 
 
 t <ACCESS-ID> PS CODEACCESSIOACTUAL 
 / #*R PS COPFPEFAliLTACCESSlDACTUA 
 / PT CHFCKIFMFXTF PISINTFGFR 
 
 t <lNTEGER-FXFRFSSIf)N> »S rODElNTEC, 
 / #*& PS CODEnEFAliLTINTEGERACTUAL 
 / PT CHECKIFNFXTFPISPrOl FAN 
 
 f <BOOLEAN-FXPRES5IDN> PS CODEPPOLP 
 / **(. PS CCIPEDFFAIjLTBOOLFANACTUAL 
 / PT CHFCKTF^FXTFPISSTRING 
 
 [ <STRING-EXPFFSSI0N> PS CPDESTFING 
 / #*& PS COFEnFFAliLTSTRlMGACTllALP 
 / PT CHFCKIFfJFXTFPISPDlNTFR 
 
 t <pointep-fxprfssion> ps codeppint 
 / <*«. ps cppepffaultpnintfractual 
 / pt chfck1fnextfpispattfrn 
 
 t <pattern-fxprfssipn> ps codepattf 
 / **& ps copf'pffaiiltpattfpnactual 
 / pt checkifmfxtfpisstriicturf 
 
 i <structurf-fxpression> ps coofstr 
 / **fc ps copepffaultstructurfactu 
 / pt chfckifmfxtfpisfvfnt 
 
 t <fvent-varlabi. f> ps codef vent actu 
 / #*& ps copepefatiltfventactualpa 
 / pt checkifmfxtfpisfilf 
 
 f <file-variaplf> ps conef i l.f ac tual 
 
 / #*& ps copfpefaultftleactualpar 
 
 / pt chfckifnfxtfpisprpcfss 
 
 [ <pr0cess-vapiablf> ps cdnfprptess 
 
 / #*& ps cdpepefaultprocfssactual 
 
 / PT checkifnfxtfpiscppf 
 
 [ <CODF-vAPlAPLF> PS CnPECnPEACTUAE 
 / #*& PS COPFPFFAliLTCPDEACTUALPAR 
 PS GFTNEXTPAR^ ; 
 > lj= #CPI^^ENT PS SKIPTHRPURHSEMIC 
 :$= <BFr,IN | > PS COPEPRFDFCI ARATIONB 
 LIST I <DECLARATIPN> FOLLOWED 
 PS COPEPDSTPFCLARATIONBI OCKHFA 
 <STATFMEM-LIST> <ENP> PS COPF 
 / <OPFN"LABEL> <BlOCK> <CLOSF"l.A 
 OUND> »t= <INTEfiFR-FXPRESSlPN> PS 
 OUNr> ::= < I NTEGER-FXPRESS IPN> PS 
 -INITIALISATION M= <ID"PART> <AP 
 t FMPTY / <APR0W> PS CPPEPEGINTN 
 <1NTFGFR-FXPRFSSIPN> PS CODFFN 
 PS RESFTIDLISTCPUNTFP i 
 ART> i tr FMPT Y 
 
 / <ARRAY-FIPST-PART> *I P 
 IRST"PArT> t:= t{ P$ CnPFPE 
 1\ PS COPE PFGINliPPFRBPU 
 PS APPANOTHFPSUPSTRIPT 
 
 / <array-first-paft> *» P 
 
 t\ PS CODEPFGlNiippFRPPU 
 
 PS APPANOTHFRSUPSrpIPT 
 
 -IMTlAi I7ATIUN> M= <ID"PA 
 
 t FHPTY / <APROV> PS CPfE 
 
 <BOOLFAN-ExPRESSlPN> PS 
 
 PS RESFTIPLISTfOUNTFR J 
 
 »: = t t* U PS SETDFFAULTS 
 
 / #* <INTEGER-FXPPESSIPN> 
 
 / <lNTEGER-EXPHFSSl r 'N> £S 
 
 OLON ; 
 
 LOCKHFA 
 
 RY A ^<S 
 
 D PS FN 
 
 RLOCKEN 
 
 RFL> ; 
 
 CODFLPV 
 
 CODFUPP 
 
 RAY-PAR 
 
 TEGFRIM 
 
 DlNTEGF 
 
 S FNTFRNUMPEPP 
 GlMLOWERRnUND 
 K'D <UPPER"pnuN 
 
 S CODFFEGINLOW 
 NO <UPPER-Pf)U*' 
 J 
 
 PT> <APRAY-PAP 
 
 PEGINPOnLEANlM 
 
 CODEFNDBnnLEA 
 
 TRINGLFNGTH 
 PS SFTVARIARI 
 SFTFIXFDSTRIN 
 
 PARAMETFR 
 LPARAMETFR ] 
 
 FRACTUAIPARAMETER 
 PARAMETFR ] 
 
 ANACTUALPARANFTER 
 PARAMFTFP ] 
 
 ACTUALPARAMETER 
 ARAMFTER I 
 
 FRACTUAI.PARAMFTER 
 
 PARAMETFR 1 
 
 PNACTUALPARAMFTER 
 PARAMETFR 1 
 
 ucturfactualparameter 
 alparamfter ] 
 
 alparamfter 
 
 RAmETFR I 
 
 FARAMFTEP 
 AMETFR ] 
 
 ACTUALPARAmETER 
 PARAMFTER ] 
 
 PARAMETFR 
 AMETEP I I 
 
 D 
 FMI> ] 
 
 dofdfcltst 
 
 d ps fnpofrlock 
 
 frbound; 
 frbolimd; 
 
 T> 
 
 ITIALlZATInN' 
 
 RINITIALIZATION ] 
 
 FSUBSCRTPTS ; 
 <LOWFP-RPUND> 
 p> 
 
 FRBOUND <LPwER-R0lJN[)> 
 D> 
 
 T> 
 
 ITIAl IZATION 
 
 N INITIALIZATION ] 
 
 FSTRINGLFNGTH 
 GLENGTH ; 
 
 00030200 
 00030300 
 00030400 
 00030500 
 00030600 
 00030700 
 00030800 
 OOO3O9OO 
 00031000 
 00031100 
 00031200 
 00031300 
 00031400 
 00031500 
 00031600 
 00031700 
 00031600 
 00031900 
 00032000 
 00032100 
 00032200 
 00032300 
 00032400 
 00032500 
 00032600 
 00032700 
 00032600 
 00032900 
 00033000 
 00033100 
 00033200 
 00033300 
 00033400 
 00033500 
 00033600 
 00033700 
 00033600 
 00033900 
 00034000 
 00034100 
 00034200 
 00034300 
 00034400 
 00034500 
 00034600 
 00034700 
 00034600 
 00034900 
 00035000 
 00035100 
 00035200 
 00035300 
 00035400 
 00035500 
 00035fc00 
 00035700 
 00035600 
 00035900 
 00036000 
 00036100 
 00036200 
 
176 
 
 <SI7F 
 <STRI 
 
 MG-SP 
 
 <STRING-lN 
 
 <PDlNTER-I 
 
 <NO-CLASS- 
 
 <STRucTURF 
 <tVF-M-ACT 
 <PATTERN-I 
 
 <ACCFSS-PA 
 <PROCEDORF 
 <C0NDITI0N 
 
 <CASE-STAT 
 
 <lTFRATIVt 
 
 <TNTFGFP-E 
 
 t C I M C A T I n N 
 
 [ PS SFTOEF 
 
 / #( PS C 
 
 r *> ps 
 
 / PS 
 iTlALlZATin 
 [ < A R R VI > P 
 
 <STRlNG-F 
 PS RFsFTlOt 
 MTIAl T Z AT I 
 I <ARpDW> P 
 
 (POINTER- 
 PS RFSFTJDL 
 PRrCFSS-DFC 
 LIST r <IP- 
 
 ps cnDFPp 
 
 SFPARATPR I 
 - p A R T > » t = 
 LIST <SUPST 
 # ) PS C P D E E 
 Itlfv-PFCLARA 
 
 PS CODFPFGI 
 PS COPFFNDE 
 MTIALIZATI 
 [ <ARpOW> P 
 
 <pattfrn- 
 ps resftidl 
 
 R T > $ « = < I u 
 
 [ PS MAKFSU 
 
 / PS SETU 
 
 PS ENDO 
 
 PS CODEACCt 
 
 -ffclaRatid 
 
 [ ps cohere 
 
 ps cohfen 
 
 / *FOPPAL P 
 
 / ^FORWARD 
 
 AL-STATFMFK 
 
 PS COHEPP 
 
 <STATEMEN 
 
 t" #FLSE P 
 
 PS CODE 
 
 / <OPFN"'LAP 
 
 F>-«-NT> »: = 
 
 / #WAIT * 
 
 PS CODE 
 
 i ist r <s 
 
 SEPARATOR 
 [ IDEFAUL 
 
 «s code 
 
 / PS CODE 
 #ESAC PS 
 / <OPFM"LAp 
 -STATrMFNT> 
 #hHItE PS 
 *DO PS CO 
 PS COOFPR 
 
 / #on ps co 
 
 <BOnLFAN- 
 
 / #fnp t <i 
 
 XPRFSSI 
 
 > I J = < 
 
 AULTSTP 
 ODFRFGI 
 CODFBF 
 SETOEFA 
 N> lt = 
 S CPPFP 
 XPPESSI 
 ISTCOUN 
 ON> : » e 
 S CODER 
 EXPRESS 
 ISTCOUN 
 LAPATIO 
 PART> F 
 OCFSSDF 
 
 > PS EK 
 t ( PS s 
 KUCTllRF 
 NDSTRUC 
 
 Tiom> : 
 
 NEVENTA 
 VENT ACT 
 N > : i = 
 S CODER 
 EXPRESS 
 ISTf PUN 
 -PART> 
 RENOPAR 
 PACCFSS 
 F ACCESS 
 SSDECLA 
 N> : : = 
 GINPROC 
 DPROCED 
 S CHECK 
 PS CHEc 
 T> : : = 
 ANCHPAS 
 T-LIST> 
 S CODEP 
 E N D P P A Y 
 EL> <Cp 
 #CASF f 
 ( PS CO 
 ENDOFCA 
 TATFMEN 
 
 <SEMI> 
 T PS CO 
 ENDCASF 
 NOCASFS 
 CODEFNP 
 EL > < C A 
 
 : j = 
 
 cnnFBF 
 
 D F P R A N C 
 A N C H P A C 
 OF PEG IN 
 EXPRESS 
 NTFGFR- 
 
 ON 
 IP 
 IN 
 MS 
 GI 
 Ul 
 
 <s 
 
 EG 
 
 ON 
 
 TF 
 
 < 
 
 EH 
 
 in 
 
 TF 
 
 N> 
 
 m 
 
 ci 
 
 on 
 
 c* 
 
 -P 
 
 Tli 
 I - 
 CT 
 
 ir 
 
 < 
 
 EG 
 
 in 
 
 TE 
 
 > PS 
 -PART 
 GLFKG 
 TRH.G 
 M S T P I 
 TSTRI 
 TRI.NG 
 IN'STR 
 
 > PS 
 R J 
 ID-FA 
 INPOI 
 N> f S 
 P ) 
 
 i :s 
 LOWED 
 ARATI 
 FDATA 
 N SUE'S 
 ECLAR 
 PEDE C 
 
 #PN 
 IOMDE 
 MDFCL 
 IP-PA 
 TNPAT 
 N > PS 
 R ; 
 
 SETSTPINGS 
 > 
 
 THANDSIZE 
 LENGTH <LE 
 NGSIZF <SI 
 NGSIZF 1 t 
 -SPECTFICA 
 INGINITIAl 
 COPEEK'DSTR 
 
 RT> <ARRAy 
 
 NTERINITIA 
 
 CODEFKDPO 
 
 IPROC 
 BY < 
 PN PS 
 DECLA 
 TRucT 
 ATION 
 L «S 
 <EVFN 
 CL #D 
 
 ; 
 
 PT> < 
 
 TERNl 
 
 CODE 
 
 AMETE 
 
 P A P A M 
 PARAM 
 RATIO 
 <PROC 
 EPUPF 
 UPEBO 
 FPRMA 
 KFOPW 
 
 #IF < 
 TTHEN 
 PS 
 RANCH 
 CHPAS 
 NIPITI 
 <INT 
 DFCAS 
 SFWAI 
 T> PS 
 
 RSARFRE 
 
 ftersca 
 
 FTFRSCA 
 K PS RE 
 FDURE-H 
 POPY <S 
 PY PS C 
 I ALLOWE 
 A POCK 3 
 POOLFAN 
 IFFAISE 
 
 CODFEN 
 PASTFLS 
 TEISF 3 
 ONAL-ST 
 EGER-EX 
 EWAITST 
 T 3 #OF 
 
 CPDFCA 
 
 FSS P 
 ARRAY 
 PFSE 
 RATIO 
 URF P 
 > SEP 
 FNDOF 
 T-VAR 
 <ST 
 
 ARRAY 
 NITI A 
 FNOPA 
 
 OUIPE 
 M <AC 
 M 3 < 
 SET ID 
 FADIN 
 TATEM 
 HECKN 
 P 
 
 PS E 
 -FXPP 
 
 *THF 
 PEALS 
 E <ST 
 * *FI 
 ATEPE 
 PRESS 
 ATEMF 
 
 PS C 
 SESTA 
 
 ize ; 
 
 NGTH> 
 
 7L> 
 
 ) 3 <ARRAY-P 
 
 TlOM> 
 
 IZATION 
 
 INGINITIALI7 
 
 -PART> 
 
 I IZATION 
 
 INTEPINITIAL 
 
 S PRPCESSPFC 
 
 -PAPT> 
 
 TIDLIST.CnUNT 
 
 m ; 
 
 S COpEBEGlNS 
 ARATDR <SEMI 
 STRUCTURFDEC 
 T ABL F> 
 ATEMFNT> 
 
 -PAPT> 
 
 LI7ATION 
 
 TTERNINITIAL 
 
 ART> I 
 ATION 3R 
 
 IZATION 3& 
 
 LARATION 
 
 FR 3 
 
 TRUCTUREDECL 
 > 
 
 larAtion ; 
 
 p 
 
 TUAL- 
 
 ARRAY 
 
 LISTC 
 
 G> 
 
 ENT> 
 
 OTFPF 
 
 NfJPFP 
 
 FSSIO 
 
 N 
 
 EBRAN 
 
 ATEMf 
 
 PARAMFT 
 
 -PAPT> 
 
 OUNTFR 
 
 MAI. 
 
 IZATION ]& 
 
 FR-LIST> 
 J 
 
 ROCFPUPEBODY \ 
 N> 
 
 CHPASTT 
 NT-t.IST 
 
 HEN 
 > 
 
 NT> <CLOSE-LARFL> J 
 
 ION> 
 
 NT <FVENT-LIST> *) 
 
 PDFCASEBPANCH 
 
 TFMFNTENTRY 3 
 
 DF CASE STATE PENT OFF ALU T <STATFMEnT> 
 
 STATEMENTDEFAULT 
 
 TATFf'ENTOFFAULT3 
 
 OFCASF 
 
 SF-STATFMENT> <CLOSE-l ABEL> I 
 
 GlNWHILESTATFPEMT <PPrLE ANi-FyPRFSS I ON> 
 HPASTSTATFMENTIFFAl.SF <statemfnt> 
 KTPIp'HILF PS CODEFhDBRANCHIFFALSF 
 DOSTATEMFN'T <STATFMFNT> 'UNTIL 
 ION> PS CODEPRANCHBACKTODOIF FALSE 
 VARIABLF> PS CODEFOPVARI API F <ARROW> 
 
 000363P0 
 00036^00 
 00036^00 
 00036600 
 00036700 
 00036bOO 
 00036900 
 0003/000 
 00037100 
 00037?00 
 00037300 
 00037^(00 
 00037b00 
 00037600 
 00037700 
 00037800 
 00037900 
 00036000 
 OOO3H1OO 
 0003fc?00 
 OOO3B3OO 
 00036^00 
 0003b500 
 00038600 
 00038700 
 00038800 
 00036900 
 00039000 
 00039100 
 00039200 
 00039300 
 00039400 
 00039500 
 00039600 
 00039700 
 00039600 
 00039900 
 00040000 
 00040100 
 00040200 
 00040300 
 00040400 
 00040500 
 00040600 
 000/(0700 
 00040600 
 OOO4O9OO 
 00041000 
 00041100 
 00041200 
 00041 300 
 00041400 
 00041500 
 00041600 
 00041700 
 00041600 
 00041900 
 00042000 
 00042100 
 00042200 
 00042300 
 
177 
 
 integ 
 
 FOR-E 
 
 / 
 
 ER-ftJ 
 
 XPRES 
 
 / 
 
 f OR-LlST-t 
 t 
 
 BOOLE 
 POINT 
 PATTE 
 STRIN 
 tSCAP 
 
 AN-FO 
 S 
 
 ER-FO 
 S 
 
 rk-fo 
 s 
 
 G-FOR 
 S 
 
 E-STA 
 / 
 
 • pop 
 ps c 
 
 <OPF 
 P-LIS 
 S10N> 
 
 ?VAL 
 
 ps c 
 
 l.Ff-FN 
 <FOp 
 f TO 
 PS C 
 / #P 
 PS 
 [ PS 
 *STE 
 PS C 
 <BOO 
 
 / #w 
 
 PS 
 R-L IS 
 EPARA 
 R-LIS 
 
 fpara 
 
 R-L IS 
 FPARA 
 -I 1ST 
 
 fpara 
 
 TFFFN 
 #RFT 
 
 / 
 
 / 
 
 PS 
 
 PROCFSS-ST 
 / 
 / 
 / 
 
 PS 
 PT 
 PS 
 PT 
 PS 
 PT 
 PS 
 PT 
 PS 
 PT 
 PS 
 PT 
 PS 
 ATFMF 
 <PRn 
 *APP 
 PS C 
 *INII 
 <PRD 
 *TFR 
 
 r ps 
 
 / 
 
 / 
 
 <INTF 
 
 <Boni 
 
 <B00t 
 <STRI 
 <ST RI 
 <POIN 
 < P 1 N' 
 <PATT 
 <PATT 
 CODFF 
 <SIMPLF 
 (lPEFORcn 
 N-LABEL> 
 T> II: I 
 » : = < I N 
 UF #( PS 
 ODFENDVA 
 T> i := < 
 -EXPRESS 
 PS CODER 
 PDEENOfP 
 
 y Ps cnn 
 
 CODEENP 
 CODENOS 
 
 p ps cnn 
 
 OPEENUFP 
 I EAN-EXP 
 HILE PS 
 
 CODEENO 
 
 T > J : = |. 
 
 TOR t, \ 
 
 T> »: = |. 
 
 TOP t, ) 
 
 T > t : = l 
 
 TOR *, ) 
 
 > :;= Li 
 
 tor t> ; 
 
 T> : 8= t 
 
 URN 
 
 CHECKTH 
 
 INTEGER 
 
 CO[)FRFT 
 
 BOOLEAN 
 
 TODERET 
 
 STRUcP 
 
 CODFRET 
 
 PATTERN 
 
 CnOERET 
 
 POINTER 
 
 CODERET 
 
 STRUCTIl 
 
 CHECKTH 
 
 NT> : j = 
 
 CFDURE-S 
 
 END # ( P 
 
 ODEFNDAP 
 TIATE t( 
 CESS-VAR 
 MI NATE 
 COPELON 
 C #*& t 
 
 GFR-FOR- 
 FAN-VARI 
 FAN-F'OR- 
 N G - V A P I A 
 l-G-FOR-L 
 TFR-VARI 
 TFR-FOR- 
 EPN-VAPI 
 FPN-FOR- 
 MPFTMl-IS 
 -INTEGER 
 UNTER <S 
 
 <ITEFAT 
 T ST <rOP 
 TEGFR-EX 
 
 CDDFPEG 
 Ll'F #5 I 
 FOR-FXPR 
 IP,N> PS 
 FGINFPRL 
 PL I NIT E 
 FPEGINFO 
 FPRPY 3 
 TEPFOPCD 
 FPEGINFO 
 R S T E P ] [ 
 PFSSIPN> 
 
 codfbfgi 
 
 F R ►■ H I L E 
 TST [ <B 
 
 PS 
 
 ] 
 
 LIST> 
 
 ApLF> PS 
 
 LIST> 
 
 PI F> PS C 
 
 IST> 
 
 A P I F > 
 
 LIST> 
 
 APLF> 
 
 LIST> 
 
 T <STATEN 
 
 -E XPRFSST 
 
 TATFMFNT> 
 
 IVF-STATF 
 
 -I IST-FLF 
 
 PPFSSION> 
 
 IN VALUE < 
 
 FSSTON> « 
 CPPFIMTI 
 I MIT <FOR 
 PS CODEn 
 RPY <FOR- 
 
 NPITIUNAL 
 RSTFP <Fp 
 #UNTI! PS 
 PS CPPEF 
 NFPPWHILF 
 
 3 3 i 
 POLFAM-EX 
 
 1ST [ <POINTER-EX 
 1ST F <PATTFRN-EX 
 ST r <STRING"FXPR 
 LEAVE <*!> PS LEA 
 
 ATPPO 
 PROCE 
 
 URNIN 
 
 ppncE 
 
 LiRNPO 
 RPCED 
 liRNST 
 PROCE 
 U R N P A 
 PROfE 
 URNPO 
 PEPPO 
 ATRFT 
 * S P A W 
 T A T E M 
 S CpD 
 PFNP 
 
 PS C 
 IABLE 
 
 fFPUR 
 
 PURE 
 
 TEGER 
 
 PURE 
 
 PLFAN 
 
 LIRE * 
 
 PING 
 
 PURE 
 
 TTFRN 
 
 PURF 
 
 INTER 
 
 CEDUP 
 
 I'RNST 
 
 N t( 
 
 FNT> 
 
 FBEGI 
 
 OOEPE 
 
 > PS 
 
 EISNOTT 
 *( <INT 
 #) 
 
 *(. <BOn 
 n 
 
 ( <STRT 
 
 *) 
 
 t( <PAT 
 
 *) 
 t( <POI 
 
 #) 
 F *( <S 
 RUCTURF 
 PS CODF 
 PS COPF 
 NAPPFNP 
 
 G I N I N I T 
 CPDFENP 
 
 CODEFORVARIABLE <ARROW> 
 ODEFORVARIABI E <ARROW> 
 CODEFOPVARIAPLE <ARROW> 
 CODEFOPVARIAPLE <ARROW> 
 
 ent> Ps copepranchbackfor 
 
 ON> #TIMES #DO 
 
 PS CODFPRANCHPACKFORTlMES 
 KENT> <CI OSE-LAPFL> ; 
 MENT> SFpARATOR t, ) 
 
 INTEGER-FXPRFSSTON> 
 
 S CODESIhGLEFORASSlGNMENT 
 
 alfprassignnent 
 -expression> 
 
 FFAULTFnFlNCPFMENf 
 FXP«ESSIPN> 
 
 R-EXPRESSlON> 
 
 CODEBEGTNFORUNTIL 
 NDFPPUNTIL 
 
 <BOOLFAN-EXPRESSlON> 
 
 PRESSlOM> PS COPFFORLISTEXP 3 
 
 PRESSIPN> PS COPFFORLISTEXP 3 
 
 PRESSlON> &>S COPFFORLISTEXP 3 
 
 FSSIPN> PS CPDEFPRLlSTExP 1 
 
 VELAP6L 
 
 YPEP 
 EGER-EXPRESSION> 
 
 LEAN-EXPPESSI0N> 
 
 NG-FXPRFSSION> 
 
 TFRN-EXPPESSION> 
 
 NTER-EXPRESSIPN> 
 
 TRUCTURF-EXPPESSI0N> *) 
 MATCPESPPOCEOUPFSTRUCTUR 3 ) 
 BEGTNSPAWN 
 ENOSFAWN #) 
 <PpnCEPURE-STATFMENT> 
 
 IATF <PPPCEDURE-STATEMENT> *> 
 INITIATE #) 
 
 ETERMTNATE 
 
 , PS CODFPFFAULTTERMINATF PS COPECAUSETERMINA 
 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 TEOOO 
 
 42400 
 42500 
 42600 
 42700 
 42600 
 42900 
 43000 
 43100 
 43200 
 43300 
 43400 
 43500 
 43600 
 43700 
 43b00 
 43900 
 44000 
 44J00 
 44200 
 44300 
 44400 
 44500 
 44600 
 44700 
 44600 
 44900 
 45000 
 45100 
 45200 
 45300 
 45400 
 45500 
 45600 
 45700 
 45600 
 45900 
 46000 
 46100 
 46200 
 46300 
 46400 
 46500 
 46600 
 46700 
 46800 
 46900 
 47000 
 47100 
 47200 
 47300 
 47400 
 47500 
 47600 
 47700 
 47600 
 47900 
 46000 
 46100 
 48200 
 48300 
 46400 
 
178 
 
 <EVEMT-I.IST> PS COnEEMDCAUSETFRMINATE OOO485OO 
 
 / PS CPpFFFGlNPROCFSSTEPMINATE <PROCESS-VARI ABU> 0004b600 
 
 PS COPFErUPROCESSTFRMTKATF 00046700 
 
 [ *» CODFCAUSFTERMINATF <EVENT-|_ I ST> 00048800 
 
 PS CODFFKOCAUSFTFRMINATF 1 «, 3 * ) 1 00046900 
 
 / /SUSPEND #( PS COPEPEGINSUSPFKD <PRCCFSS"VARI A8lE> 00049000 
 
 PS CPDEENDSUSPFND *) 00049100 
 
 / iTPESTART *( PS COPEPFGINRFSTART <PROCESS"VARI ABLE> 00049200 
 
 PS CC1DFENDRFSTART f > ) 00049300 
 
 <FVEU-LTST> Ms LIST t <F VFNT-VAR I ABLE> PS C.PDEFVENU 1ST ) 00049400 
 
 SEPARATOR t» ) 00049500 
 
 <EVEMl-STATFMFNT> »«= ICAUSF #( PS CODEBFGINC AUSF <EVENT-U$T> 00049600 
 
 PS COOEENDCAUSE *) 00049700 
 
 / fwAlT #( PS CnDFREGlNWAlT <EvENT-LlST> PS CODEENDMlT #) J 00049800 
 
 <PATTF.RN-K , ATrhING-STATEWFKT> «t B <STR TNG-VAR I ABL F> 00049900 
 
 [ PS CPDEFLOATINGMATCH / PS COPFFlXEDMATCH #FIXFD ) 00050000 
 
 <PATTFRN"EXPPFSSlON> PS CODEPATTERNH ATOP 00050100 
 
 t PS CPDENOMTCHASSIGNMFJNT 00050200 
 
 / <APROw> PS COTF^ATCHASSIGK'MENT <STR I NG-EXPRFSf>lON> 00050300 
 
 PS CODEENDMATCHASSIGNMEK'T 1 * 00050400 
 
 <INTEGER-ASSTGNMFNT> m= <1MFGER-VARIAB| E> PS SFTSTAPOK <ARROW> OOO5O5OO 
 
 <IMTFf,FP-EXpRFSSlrN> PS INTFGERSTORF 00050600 
 
 / <INTFGER-FUNCTIrN-ID> <ARPOfc> OOO5O7OO 
 
 <INTEGER-ExPRESSIPN> PS I N'TE P E RFUMCT IpNSTOPE t 00050800 
 
 <INTEGFh-FUKCTInN-IO> M= <*I> PT TESTI MEGERF UMCT IONIDJ OOO5O9OO 
 
 <BnOLEAN-ASslGNMFNT> ti = <BPOl E AN-VAR I ABLE> PS SFTSTAPOK <ARPOW> 00051000 
 
 <PPOLEAN-EXPpESSlPN> PS BPOl EAmSTORF 0005U00 
 
 / <BOOLEAN-FUNCTION-ID> <ARPOW> 00051200 
 
 <B00LFAN-EXPRI'SSI0N> PS BOPLFANFUNCTTrNSTORE) 00051300 
 
 <bOCLEAN-FLKCTIpN-IO> :!= <*I> PT TFSTROPLFANFUNC T I ONIDJ OOO5I4OO 
 
 <STRING-ASSIGNMFNT> us <STpING-VARlAFLE> PS SETSTAROK <APRn*> 00051500 
 
 <STRHiG-EXPRESSlOr> PS STRINGSTORE 00051600 
 
 / <STRING-VAPIABLF> #. # [ < INTFGER-FXPPF SS I 0N> 00051700 
 
 PS CPDEFIELDSTAPTHYKAKE *« < T NTEGE R-FXPRE SSlON> , 00051800 
 
 PS CODEFIELOLENGTHBYNAMF tl PS SETSTAROK <ARROW> 00051900 
 
 string-expression p s partihstringstore 00052000 
 
 / <STPlMG-FUNCTION-ID> <ARRPW> y .00052100 
 
 <STRlMG-EXPPFSSIOM> PS STPINPFUNCTIP^STORF) 00052200 
 
 <STR1NG-FUNCTI0N-TD> 11= <*I> PT TESTSTPIKGFUNCTIPNIOI 00052300 
 
 <PDINTER-ASSTGNMEKT> »: = <PPI K TER-VARI ABl E> <ARR0W> 00052400 
 
 <P0INTFR-EXPRFSSIPN> PS PP I NTERSTORE 00052500 
 
 / <POINTER-FUK'CTIrM-ID> <ARRO*> 00052600 
 
 <POIMTER-ExPRESSlPN> PS POINTERFUNCTIPNSTOREl 00052700 
 
 <POIkTFR-FUkCTIo^-IO> lis <*I> PT TFSTPPTNTERFUNCTIOMDJ 00052800 
 
 <PAT7ERN-ASSIGNN'ENT> ;;r <PATTERN--VART ABLE> <ARRPW> 00052900 
 
 <PATTFRN-EXPRESSIPN> PS PATTFRKSTORE 00053000 
 
 / <PATTFRN-F UKiCTIPN-TD> <ARPOW> 00053100 
 
 <PATTFRN-ExPRESSlPN> PS P ATTFPNFUNCT I PNSTOPE I 00053200 
 
 <PATTFRN-F UKTTPf 1 -ID> J»= <*t> PT TFSTPAtTFRNF UhCT IOK IDJ 00053300 
 
 <INTLGEh-EXpPtSSlPN> lt= <S I HP|_E- I NTEGER-EXPPF SS T PN> 00053400 
 
 / <INTFGER-ASSIGN^EM> PS CODENONDEsTpUCTlNTEGFPSTPpE I 00053500 
 
 <SlMPLE-lKTEGtR-FXPRESSION> ::= <TFPM> 00053600 
 
 / <SlHPLE-lMFf,FR-EVPPFSSTOM> * * <TFRM> PS CODE INTEgFRADO 00053700 
 
 / <SH'PLE-lNTFGER-FXPPESSION'>#- <TERM> PS CODElMTEGERSUBTRACT;0OO53eO0 
 
 <TERM> »» = <FACTOR> 00053900 
 
 / <TEPP> #* <FACTPR> PS CPPF I NTEGEPPULT IPL Y 00054000 
 
 / <TFRN ( > #/ <FACTpR> PS CPDFDK'IDE 00054100 
 
 / <TFpM> #RDIV <FACTPP> PS C.ODFPDIV 00054200 
 
 / <IFRM> #CDIV <FACTOR> PS CPDFCDIV 0005*300 
 
 / <TFP^> *MOD <FACTPP> PS CODtMOD J 00054400 
 
 <FACTOR> Mr * + <PR!MaPY> / <PRIHaRY> / #• <PRIMARY> PS CPDFNEGATIVF 00054500 
 
179 
 
 / 
 / 
 
 PPH'ARY> :: 
 / 
 / 
 / 
 
 / 
 
 / 
 
 / 
 BOOLEAN-lXp 
 
 / 
 
 / 
 SIMPLE-PUCI 
 
 / 
 IMPLICATION; 
 
 / 
 BDOLEAN-TER 
 
 / 
 
 BOOlEAN-F AC 
 / 
 
 BOOLEAN-SFC 
 
 POOLEAN-PRi 
 / 
 / 
 / 
 / 
 / 
 / 
 / 
 
 <F ACTOR> 
 <FACTPR> 
 r [ <*N> 
 ** PT TFS 
 <INTEGEP- 
 <INTFGER- 
 f IF <BOPL 
 
 pthfm <in 
 ps codeex 
 
 #ELSF <H' 
 #CASF <IN 
 LIST C <I 
 SEPARATOR 
 UDEFAULT 
 PS COOFEN 
 *ESAC PS 
 tfABS #( < 
 if SIGN #C 
 ^BINARY # 
 ^LENGTH # 
 #CHAPSIZF 
 
 #UPPER #( 
 <*I> PS C 
 
 PS CODEUP 
 SLOWER *( 
 <*I> PS C 
 
 PS CODFLO 
 f INTEGER 
 *( <INTEG 
 PESSlON> 
 
 <BOOLEAN- 
 <PATTERN- 
 FAN> M = 
 <SIMPLE-P 
 > t := <RD 
 <IMpLKAT 
 M > j t s < B 
 <BOOLEAN- 
 f #pR <BO 
 / *xOR <B 
 / *ORlF P 
 
 PS CODE 
 TOR> «:= 
 < BOOL FA N- 
 t #ANO <B 
 / #AN0IF 
 
 PS CODF 
 PNOARY> : 
 / #NOT <{, 
 MARY> « t = 
 «* PT TFS 
 <BOOlEAN- 
 <BOOLFAN- 
 #BOOL #( 
 <RFl ATION 
 #( <BOOLF 
 *IF <BOOL 
 *THFN <PU 
 PS CODEEX 
 #ELSF <BO 
 #CAsE <IN 
 
 *PPWF 
 fPPWE 
 
 PS C 
 1 INTF 
 VARIA 
 FUNCT 
 EAN-E 
 TFGER 
 P S K I P 
 TFGFP 
 TFGER 
 NTEGE 
 
 1 > 
 
 PS C 
 OEXPC 
 COOEF 
 INTFG 
 <IMTF 
 ( <ST 
 ( <ST 
 
 *( < 
 
 [ <S 
 HECKS 
 PEP P 
 
 [ <S 
 HECKS 
 If.FR P 
 *( <S 
 EP"EX 
 : j = < 
 A S S I G 
 NiATCH 
 <IMPL 
 OOLEA 
 ULFAN 
 I0N!> 
 UOLEA 
 TFPM> 
 OLFAN 
 OOLEA 
 S COD 
 OR PS 
 <BOOL 
 FACTO 
 OOLEA 
 PS CO 
 AND P 
 5= <B 
 OOLEA 
 
 f #T 
 TBnm 
 VAPIA 
 FUNCT 
 <INTF 
 > 
 
 AN-EX 
 EAN-E 
 L E A N! 
 FSKIP 
 OLFAN 
 TFGER 
 
 R C#*H <PRIMARY> PS CPDEPPWER 
 
 R #- <PRIMARY> PS CPDENFGATIVE PS CpDEPOWER ; 
 
 OPEINTEGERCPNSTANT 
 
 GFRSTARALLOWED 
 
 BLE> PS COPElNTEGFPVALUECAl L 
 
 IpN> PS CPDFINTFGERFUNCTION 
 
 XPRFSSI0N> PS CODFEXPSKIPTHFK'ON'FAI SE 
 
 -FXPRFSSIPN> PS CODFEXPSKIPFLSF 
 
 TOEI. SFFpUN'P 
 
 -FXPPFSSTPM> PS CODFEXPSKIPPASTFLSEFOUND *Fl 
 
 -FXFRFSSIPN> *PF PS CPDFEXPC ASFRR AN'CH 
 
 R-EVPRESSION> PS CODEFXPCASFENTPY 3 
 
 DFFAuLT <INTEGER-FXPRFSsION> 
 / PS CODFNOEVPCASEDFFAULT ] 
 E 
 
 ION> #) PS CPDEABS 
 STON> #) PS CPDESIGN 
 SSlOl"> *) PS CODEINJTGRFRO^STPIMG 
 SSI0N> #) PS CODELFNGTHOFSTRING 
 RFSSI0N> 1) PS CODFCHARSIZFOFSTPING 
 IPST-PART> #. 38, 
 FPRUPPER f <SUBSCRIPT> 36 * > 
 
 IRST-PART> *. 3& 
 
 FPRUPPER [ <SUBSCRIPT> 1& #) 
 
 OPEFX 
 ASEPE 
 NDOEF 
 EP-FX 
 GFR-F 
 RING- 
 RING- 
 STRTN 
 TRUCT 
 UPSCR 
 S RFS 
 TPUCT 
 UPSCR 
 S RFS 
 TPINJG 
 
 press 
 
 SIMPL 
 NmEN'T 
 ING-S 
 1CATI 
 N> C 
 -TERM 
 [ #IM 
 N-FAC 
 
 -FArT 
 
 N-FAC 
 ESKIP 
 CODF 
 EAN-S 
 R> 
 
 N-SFC 
 DFSKI 
 S COD 
 OPLEA 
 N-PPI 
 ROE e 
 EANjST 
 
 ble> 
 
 IPN> 
 GFR-E 
 
 PCASF 
 
 FAULT 
 
 XPCAS 
 
 PRESS 
 
 XPPES 
 
 EXPRF 
 
 FXPRF 
 
 G-FXP 
 
 URF-F 
 
 IPTFD 
 
 ETSPT 
 
 l.'RF-F 
 
 IPTEP 
 
 ETSPT 
 
 -FxPR 
 
 I0N> 
 
 F-BOP 
 
 > PS 
 
 TATEM 
 
 ON> 
 
 #EOV 
 > 
 
 P /*' 
 TPP> 
 
 ) PS COOEPECTOIKTEGER 
 TARNPTALLOWFD I 
 
 ESSlON> * 
 *) 3 PS S 
 LEAN> 
 
 cpdEnpndestruct&oole an store 
 
 ENT> ; 
 
 #> 3 <BOO 
 
 or> ps codeor 
 top> ps cpdexo 
 factpriftpue < 
 fndskipfactor 
 
 fclnpary> 
 
 N D A p 
 P?NDA 
 FEND? 
 N'-PRI 
 MAFY> 
 S COP 
 ARALL 
 
 PS 
 PS CP 
 XPPES 
 
 Y> PS COD 
 PYIFFALSE 
 NPARYSKIP 
 MARY> 
 
 PS CODEN 
 ETRUF / 1 
 OWED 
 
 CPDEPOOLE 
 DFROPLEAM 
 SION> t) 
 
 PRESSIPK> *) 
 XPRFSSIPN> ®S rODEF 
 "EXPRESSIPN> PS COD 
 TPFLSFFOUMD 
 -FXPRESSIPN> PS COD 
 -EXPRESSIONS #PF PS 
 
 3 <IPPLICATIPN> PS^CODEECv; 
 LEANl-TERM> PS CODEIMP % 
 
 HOOLEAN-FACTOR> 
 3 J 
 
 EAND 
 <BOOLEAN-SFCONDARY> 
 3 ) 
 
 PT i 
 
 FALSE PS CODEFALSE 
 
 ANVAl UECALL 
 
 FUNCTION 
 
 PS CPDEINTGRTOPOOL 
 
 xps^iptpenomfalse 
 fexpskipflsf 
 
 fexpskippastflsffound #Fl 
 
 COHFEXPCASFPRANCH 
 
 0005^600 
 0005^700 
 0005^600 
 
 ooob^yoo 
 
 0005S0P0 
 OOObblOO 
 00053200 
 00055300 
 00055i|00 
 00055500 
 00055600 
 00055700 
 00055600 
 00055900 
 OOO560OO 
 00056100 
 00056?00 
 00056300 
 00056A00 
 OOO565OO 
 OOO566OO 
 00056700 
 00056600 
 00056900 
 00057000 
 00057100 
 00057POO 
 00057300 
 00057^(00 
 00057500 
 00057600 
 00057700 
 000576C0 
 00057900 
 OOO56COO 
 00056100 
 00056200 
 00056300 
 00058^00 
 00056500 
 00056600 
 00056700 
 000566C0 
 000569C0 
 00059000 
 00059100 
 00059200 
 00059300 
 00059/tPO 
 00059500 
 00059600 
 00059700 
 00059PPO 
 00059900 
 00060000 
 00060100 
 0006U200 
 00060300 
 00060A00 
 OOO6O5OO 
 00060600 
 
180 
 
 <RELATIUN> 
 
 <REl_A 
 
 <PR0C 
 <STRI 
 <SlMP 
 
 <STRI 
 <STRI 
 <STRI 
 
 TIUNAL 
 / 
 / 
 
 EDUPE" 
 < 
 
 NG-EXP 
 / 
 
 LE-S7R 
 / 
 
 / 
 
 NG-TER 
 
 / 
 
 ng-fac 
 / 
 
 NiG-PRl 
 / 
 / 
 / 
 / 
 / 
 
 / 
 
 / 
 <POINTEh-EX 
 / 
 / 
 / 
 / 
 
 I 1ST C <R[i 
 SEPARATOR 
 tfDEEAULT 
 PS CODEEND 
 #ESAC PS C 
 ] PS STAKN 
 l := <INTEGE 
 LIST[<RELA 
 PS CO 
 <STRING-EX 
 I 1ST r <Rt 
 
 PS 
 <POINTEP-E 
 LIST C <RL 
 
 PS 
 -PFEPATOR> 
 *< PS CODE 
 [#< / *<* = 
 
 I0> : t= [ < 
 *i> pt inis 
 
 hF SSI0NJ> it 
 
 <STpING-AS 
 
 ING-FXPRFSS 
 <SIMPLE-ST 
 <SlMPLE-ST 
 
 p > I : = < S T R 
 <STRlNG-TE 
 
 TPR> Its <S 
 J*SN0T <STR 
 
 M A R Y > J t = [ » 
 1* pT TEST 
 <*S> PS CO 
 <STplNG-FU 
 #DEcI^AL * 
 JTCONVFRT # 
 <STRU'G-FX 
 / i, <INTE 
 #STRIMG *< 
 / t, <INTE 
 #( <STRING 
 * I F <BOOLE 
 #THEM <STR 
 PS CODEEXP 
 IELSE <STR 
 #CASE <INT 
 LIST [ <ST 
 SEPARATOR 
 [#DEF AULT 
 PS COHEEND 
 IESAC PS C 
 ] PS STARN 
 I, *i <INT 
 <INTFGER-E 
 <STPI*G-VA 
 
 PRESSI0N> : 
 
 <POJNTFR-F 
 <POINTER-A 
 *NULL PS C 
 #IF <POOLE 
 #THEN <POI 
 PS CODEFXP 
 
 OLEAN-EXPRESSI 
 *> 
 
 PS CODEFXFCASF 
 EXPCASEOEF AULT 
 OnFENTOFEXPCAS 
 OTALLOWEO; 
 R-EXPRESSION> 
 TIONAL -OPERATP 
 OEINTEGEPREl OP 
 PRFSSTON> 
 LATIOK'AI -OPERA 
 CnDESTRlNGRELO 
 XPPESSI0N> 
 LATIONAI -OPERA 
 CODFPOINTERFEl. 
 j != #= PS CODE 
 
 lss / *> ps cn 
 
 ] PS CODELFp / 
 STRUCTUPF-FIRS 
 PROCEDURE PS P 
 = <SIK'PLE-STRI 
 SIGNMENT> PS C 
 I PM> M= <STRI 
 RING-EXPRESSIO 
 RlNG-EXFRESSlO 
 IMG-FACTOR> 
 RM> #SA*'D <STP 
 TRTNG-PPIMARY> 
 
 ING-PPIHARY> P 
 MT PS CPDE^T 
 STRINGSTARALLO 
 DFSTRIMftCDNSTA 
 NCTIOfo PS COD 
 ( <INTEGER-EXP 
 ( <STPIMG-FXPP 
 PPFSSIOW> t PS 
 GFR-EXPPESSIOM 
 <INTEGFR-EXPR 
 GFR-EXPPFSSION 
 -FXPRFSSI0N> t 
 AN-EXPRFSSIDN> 
 ING-EXPPFSSIOM 
 SKIPTOEI SFFOUN 
 ING-EXPRFSSION 
 FGER-EXPPESSIO 
 RlNiG-EXPPESSlP 
 t, 
 
 PS COTEFXPCASE 
 EXPCASEDEFAOLT 
 ODEFNPOFEXPCAS 
 OTALLPWFD 
 FGER-FXPRESSIP 
 XPRFSSl n N> PS 
 RIABLF> PS CPP 
 := <PPIKTER-VA 
 
 UNCTIpN> PS CO 
 SSIGNMENT> PS 
 ODENUl L 
 
 AN-EXPRFSSIDN> 
 NTER-F XPPESSIP 
 SKIPTPE! SFFOUN 
 
 0N> PS CODEEXPCASEENTPY ] 
 
 DEFAULT <P001EAN-FX 
 / PS CODENOEXPCASE 
 E 
 
 R> EMPTY <INTEGER-E 
 1 
 
 TPR> EMPTY <STRING" 
 
 P 1 
 
 PPFSsl0N> 
 DFFAULT ] 
 
 XPRESSI0N> 
 
 EXPRESSI0N> 
 
 -FXPRESSI0N> 
 
 TPR> EMPTY <P0INTFR 
 
 OP ] J 
 
 EQL / ** PS CODENEO 
 
 DFGTR 
 
 tti / #>#=3 PS CODEGFO i 
 T-PART> #, H 
 ESETSPT I 
 NG-ExPRESSlON> 
 OPE NPNDE STRUCT ST RING STORE; 
 NG-TFPM> 
 
 N> #SOR <STRING-TER 
 N> #SXOR <STRING-TF 
 
 M> PS CPDESOP 
 RM> PS CODESXOR 
 
 ING"fACTOP> PS CODESAND I 
 S COPESNOT ; 
 
 WED 
 NT 
 FST 
 RFS 
 ESS 
 SE 
 
 > 3 
 ESS 
 
 > I 
 ) 
 
 »S 
 
 > P 
 D 
 
 > P 
 N> 
 N> 
 
 PINGFUNCTIPN 
 SION> t) PS CODE 
 IPK> t, <STPING" 
 TCONVERTDEFAULT 
 
 t) PS^CODFCONVE 
 IPN> [ PS CODEST 
 
 *) PS CODFINTGR 
 
 CPDEEXPSKIPTHFN 
 S CODEEXPSKIPELS 
 
 S CODEEXPSKlPPAS 
 *0F PS CODFEXPCA 
 PS CODEEXPCASEEN 
 
 DEFAULT <STRING-EyP 
 / PS CODENOEXPCASE 
 
 n> ps codffieldstar 
 cpdefieldlength *) 
 estRtngvaluecall; 
 
 RIABl F> Ps CPDEPOIN 
 
 depointerfunction 
 codenpndestructpoin 
 
 ps codeexpskipthen 
 n> ps codeexpskipfl 
 
 D 
 
 INTGRTODECIMAL 
 EXPRESS*lON> t, 
 
 RT 
 
 RINGDEFAULT 
 
 TOSTPlNfi 
 
 ONFALSE 
 E 
 
 TFLSEFOUNO #FI 
 SFPRANCH 
 
 TRY ] 
 
 RFSSION> 
 DFFAULT ] 
 
 T #1 
 
 TFRVALUFCALL 
 tFRSTORE 
 
 ONFALSE 
 SE 
 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 10006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 
 oooi 
 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 0006 
 
 0700 
 
 0600 
 OyOO 
 1000 
 
 1100 
 1200 
 
 1300 
 
 1400 
 
 1500 
 
 1600 
 
 1700 
 
 1600 
 
 1900 
 
 2000 
 
 2100 
 
 2200 
 
 2300 
 
 2400 
 
 2500 
 
 2600 
 
 2700 
 
 2600 
 
 2900 
 
 3000 
 
 3100 
 
 3200 
 
 3300 
 
 3400 
 
 3500 
 
 3600 
 
 3700 , 
 
 3600 
 
 4000 
 
 4100 I 
 
 4J>S0 ! 
 
 «300 . 
 
 4 4 00 
 
 45.00 
 
 4600 . 
 
 4700 ' 
 
 5000 : 
 
 MOO 
 
 5200 
 
 5300 
 
 54 00 
 
 5500 
 
 5600 
 
 5700 
 
 5600 
 
 5900 
 
 6000 
 
 6100 
 
 6200 
 
 6210 
 
 6300 
 
 6400 
 
 6500 
 
 6600 
 
 6700 
 
 6600 
 
 6900 
 
181 
 
 ELSEFPUND #FI 
 
 EPRANCH 
 TRY ] 
 
 RES$IpN> 
 FFAULT ] 
 
 YCANBEPOINTFDTO 
 
 ALLCCATI 
 
 pATTERN- 
 
 T"PAPT> *. H 
 
 SSIpN> *> ] 
 PTDEFAULT 
 
 i-'c.LArjPir ll ' r. l struiiKu 
 <PATTFRN-FxPRESSlPN> PS CODEExPSK I PPAS 
 <INTEGER-FXPRESSIPN> «PF PS CPDFEXPCAS 
 
 C <PATTtRN-EXPRESSlON'> eS CODEEXPC ASEEN 
 
 ATOR ## 
 
 aim t « c rnnrrypr»«rnrrliii T *DATTreiu»rvDi 
 
 PATTERN 
 PATTERK- 
 
 TFLSEFPUND *Fl 
 FBRANCH 
 
 TRY ] 
 
 RESSIPN> 
 EFAULT ] 
 
 R> PS CODEPCR ; 
 ROW> ]& 
 
 -NAME> 
 
 00067000 
 00067100 
 00067?00 
 00067300 
 00067400 
 00067500 
 00067600 
 00067700 
 00067600 
 00067900 
 00066000 
 00066100 
 00066200 
 OOO663OO 
 00066400 
 00066500 
 00066600 
 00066700 
 00066600 
 00066900 
 00069000 
 00069100 
 00069200 
 00069300 
 00069400 
 00069500 
 00069600 
 00069700 
 00069800 
 00069900 
 00070000 
 OOO7O1OO 
 00070200 
 00070300 
 00070400 
 00070500 
 00070600 
 00070700 
 00070800 
 00070900 
 00071000 
 00071100 
 00071200 
 00071300 
 00071400 
 00071500 
 00071600 
 00071700 
 00071600 
 00071900 
 00072000 
 00072100 
 00072200 
 00072300 
 00072310 
 00072*00 
 00072500 
 00072600 
 00072700 
 00072800 
 00072900 
 
182 
 
 H <COOF*NAME> 
 
 <mDE-VARIAPlE> «»= t <P0I NTER-SPEC IF TFR> 
 <CODE v ^ 1 ^ L < t ACfFSS - VARlABLF> p T ACCFSSCPDE ) 
 
 <FILE-VAPIAPIF> M= [ <PnlNTEP-SPFCIFIFR> H <FlLF"NAME> 
 / <ACCFSS-VARTABLF> PT ACCESS* ILF. J 
 
 <STRUCTURE-VARIABLE> ll» t <PP I NTER-SPEC I 
 / <ACCESS-VARIABLE> PT 
 
 00073000 
 00073100 
 00073200 
 00073300 
 ]R <-STRUCTURF-FlRST-PART>000 7 3ftOO 
 ACCESSSTRUCTURE ) 00073500 
 
183 
 
 OSL? /SMANTIx 
 
 LISTFD BY THFSlS ON JANUARY 3* 1971 AT 1 1 21 A.M. 
 
 * NOL 1ST SAVEZIPDECK DISK TEST 
 (PEGIN SUF-PFRN(2O0)J 
 
 INTEGER IDCOUMER* 
 
 IDLISTCOUNTEP* 
 
 CURRENTDCCLTVPF* 
 
 CURRENTDFCLOWN, 
 CURRENTDECLNODE* 
 CURRENTDECLMACPO* 
 CURRENTNUMBROFSUBS, 
 
 CURREN7PPOCEDUPEIO* 
 
 CURRENTEXPPESSlONTYPE* 
 
 CURRENTSTRUCTUPEPTF* 
 
 IF T 
 IF T 
 
 CURRENTNUMPEPOF SUP STRUCTURES* 
 
 THIS IS T 
 DECl ARATI 
 THE CUPPE 
 THIS COM 
 NUMf.FR TF 
 ID PART. 
 
 THIS IS 
 THE CURPE 
 
 = 1 IF T 
 OWN. 
 
 = 1 
 NODF 
 ' si 
 MACRO. 
 
 WHEN A 
 BEING SCA 
 A SUBSCPI 
 AN ARRAY 
 WILL CPNT 
 SUBSCRIPT 
 
 THIS IS 
 CURRENTLY 
 PROCEDURE 
 
 THIS VA 
 CONTAINS 
 EXPRESSIO 
 
 IF A ST 
 LAST SCAN 
 CONTAINS 
 STRUCTURE 
 RIATE SVp 
 
 HE CURRENT NUMBER 
 UN IDS PROCFSSEO I 
 NT BLOCK HEAD. 
 AIMS THF CURRENT 
 IDS PROCESSED IN 
 
 THF DEFAULT TYPF 
 NT DECLARATION . 
 HIS DECLARATION Is 
 
 HIS DECLARATION IS 
 
 HIS DECLARATION IS 
 
 BOUND 
 NNED 
 PT LI 
 PART* 
 AIN T 
 S ALR 
 A PO 
 BFIN 
 IN I 
 RIABL 
 THF T 
 N SCA 
 RUCTU 
 NED* 
 A POI 
 TAP T 
 STRUC 
 
 PAIR 
 IN THE 
 ST OR 
 
 THIS 
 HE NUM 
 FADY R 
 TNTER 
 6 OFF I 
 DSTACK 
 F 
 
 YPE or 
 NNED. 
 PF VAR 
 
 THIS 
 NTER I 
 THE 
 TURE V 
 
 LIST IS 
 PARSE 
 
 VARIAPL 
 RER OF 
 ECCIGNIZ 
 TO THF 
 
 NED 
 
 THE LA 
 
 IABLE W 
 
 NTO 
 
 APPROP- 
 
 FCTOR. 
 
 CURRENTIDPTR, 
 
 THIS IS 
 THF ABOVE 
 
 IF THF 
 PART OF A 
 VARIABLE 
 STRUCTURE 
 TABULATED 
 
 CURRENT FORMAL PARAMETERL I STPO I NTER, 
 
 % THIS VA 
 
 * DURING AC 
 
 * TO POINT 
 
 f THE DECLA 
 
 * LIST IN S 
 CURRENTNUMPEROFFORMAL PARAMETERS* 
 
 * THIS IS 
 % THE ABOVE 
 
 CURRENT AC TUAIPARAMETERCOUNT* 
 
 % THIS IS 
 
 % ACTUAL PA 
 % THF ACTUA 
 
 * BEING SCA 
 
 THE LENGTH OF 
 POINTED AT VECTOR 
 
 LAST ID SCANNED WA 
 STRUCTURE* THEN T 
 
 POINTS INTO 
 
 TAP WHFRE THEID IS 
 
 RIAPLF IS USED 
 TUAL PARAMETER SCA 
 TO THF BEGINNING 
 RED FORMAL PARAMFT 
 TRUCTUPETAB. 
 
 THE LFNGTH OF 
 
 VFCTDR, 
 
 THF POSITION IN T 
 RAMETFR LIST OF 
 L PARAMETER CURRFN 
 NNFD. 
 
 CURRENT MAXACCESSNUMRFR, 
 
 THIS VARIAPLF IS THE CODE 
 
 OOO 
 000 
 
 OF 000 
 
 N 000 
 000 
 000 
 
 AN 000 
 000 
 
 FOROOO 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 
 OF 000 
 000 
 
 E 000 
 000 
 
 ED. 000 
 000 
 000 
 000 
 000 
 
 ST 000 
 000 
 
 AS 000 
 000 
 000 
 000 
 000 
 000 
 000 
 
 , 000 
 
 s ooo 
 
 HISOOO 
 000 
 000 
 
 ooo 
 
 000 
 
 000 
 
 NS 000 
 
 F 000 
 
 ER 000 
 
 ooo 
 
 000 
 
 ooo 
 
 000 
 000 
 
 HE 000 
 000 
 
 TLYOOO 
 000 
 000 
 
 ooo 
 
 oooio 
 00020 
 ooioo 
 
 00200 
 
 00300 
 00400 
 00500 
 
 OOhOO 
 
 00700 
 
 00600 
 
 00900 
 oicoo 
 
 01100 
 
 01200 
 
 01 300 
 
 01100 
 01500 
 016C0 
 01700 
 
 01600 
 01900 
 02000 
 02100 
 02200 
 02300 
 02000 
 02500 
 02600 
 02700 
 02600 
 02900 
 03000 
 03100 
 03200 
 03300 
 03400 
 03500 
 03600 
 03700 
 03600 
 03900 
 04000 
 0^100 
 042^0 
 04300 
 04400 
 04500 
 04600 
 04700 
 04600 
 04900 
 05000 
 05100 
 05200 
 05300 
 05400 
 05500 
 
181+ 
 
 CURRENTSFfiKENT* 
 Cl'RRENTADDPESSt 
 CURRFNTLFVEL* 
 
 !NT 
 
 CURRENTCASECPUNT* 
 
 I ASTTYPE* 
 
 pELOP, 
 
 MAXIMUMSFGME 
 
 CURRENTMAylMUMDISPLACEMENT* 
 
 % 
 T 
 
 V 
 t 
 
 I 
 % 
 % 
 
 r 
 % 
 % 
 * 
 t 
 v 
 % 
 r 
 r 
 % 
 r 
 % 
 % 
 % 
 * 
 % 
 % 
 r 
 t 
 % 
 t 
 
 NUM 
 
 ACC 
 
 ACC 
 
 ACC 
 
 IS 
 
 CUR 
 
 WOU 
 
 C 
 
 C 
 
 C 
 
 IN 
 
 T 
 NUM 
 
 T 
 BE 
 
 T 
 NUM 
 STA 
 CAS 
 STA 
 
 U 
 AST 
 LAS 
 THF 
 
 R 
 REL 
 LAS 
 
 PER PF THE LAST ASSIGNFD 
 
 FSS TYPE, E.G. FIFO 
 
 FSS MIGHT PF #1 AND LIFU 
 
 FSS MIGHT BF #2, IF THAT 
 
 ALL THERE ARE, THEN 
 
 RENTMAXACCESSNUMBER 
 
 1.0 PF 2. 
 
 URRFMT CODE SEGMENT 
 
 URRFT CODF ADDRFSS 
 
 URRFNT LFVEL REGISTER 
 
 liSF 
 
 HE I ARGFST SFGMFNT 
 
 PEP COMPILED SO F AR 
 
 HE ME 
 A S S I G 
 HIS C 
 PER P 
 TEHFN 
 F EXP 
 TEHFN 
 SED T 
 FRISK 
 TTYPF 
 LAST 
 FLOP 
 ATIOM 
 T SCA 
 
 N 
 
 XT OISPl ACEMFNT TO 
 NED AT THIS LEVEL 
 ONTAINS THE CURRENT 
 F EXPPFSSIPNS OR 
 TS SCANNED UTHIN A 
 PESSION OR CASE 
 T. 
 
 HANDLF THF 
 CONVENTION - 
 IS THF TYPE OF 
 VAPIAPIE SCANNED. 
 TELLS WHICH 
 AL OPERATOR WAS 
 NNED. 
 ONE 
 
 CUPRENTACCFSSIDJ 
 POINTER PMESOUT; 
 BOOLEAN STRUCTUREISOWN* 
 
 PRINTOBJECT* 
 SCANNlNGFORMALPARAMFTEPDECLARA 
 
 T 
 
 CUR 
 ACC 
 
 T 
 IN 
 ARR 
 
 T 
 OWN 
 DEC 
 
 T 
 IS 
 
 ASTERISKALLOWET* 
 
 NONAMECALl > 
 
 T 
 FOR 
 IS 
 PUS 
 DEC 
 A F 
 
 T 
 AST 
 INV 
 STA 
 
 T 
 A S 
 SCA 
 SHO 
 
 HIS / 
 PENTl 
 FSS T 
 HIS P 
 ACTIP 
 AY ME 
 HIS S 
 STPU 
 I ARFD 
 RUE I 
 
 rESjp 
 
 TIOMS 
 
 HIS S 
 
 HAL P 
 
 PEING 
 
 HED V 
 
 LAPAT 
 
 (iRMAL 
 
 HIS I 
 
 FRISK 
 
 PKFD 
 
 TEMFM 
 
 RUF I 
 
 UBSCP 
 
 NNE'P 
 
 ULD P 
 
 OINTS TO THE 
 
 Y BEING DEFINED 
 
 YPE ENTRY IN IDSTACK 
 
 OINTER IS INITIALIZE 
 
 N(0) TO POINT TO THE 
 
 SOUT. 
 
 WITCH IS TRUE IE AN 
 
 CTURE IS BEING 
 
 F OBJECT LISTING 
 
 ED 
 
 > 
 
 WITCH IS TRUF IF A 
 
 ARAMFTFP DECLARATION 
 
 SCANNFP. IT MUST B 
 HEN A PROCEDURE 
 ION IS ENCOUNTERED F 
 
 PARAMFTER. 
 S TRUE IF THE 
 
 CONVENTION MAY BE 
 IN AN ASSIGNMENT 
 T. 
 
 F A STRUCTURE OR 
 IPT HAVF BEEN 
 AND MO NAMF CALL 
 E EMITTED BY THE 
 
 00005600 
 00005700 
 00005^00 
 00005900 
 00006000 
 00006100 
 00006200 
 00006300 
 00006400 
 00006500 
 00006600 
 00006700 
 00006600 
 00006900 
 00007000 
 00007100 
 00007200 
 00007300 
 00007400 
 00007^00 
 00007600 
 00007700 
 00007800 
 00007900 
 00008000 
 00008100 
 00008200 
 00006300 
 00006400 
 00008500 
 00008600 
 00008700 
 00006600 
 00006900 
 00009000 
 00009100 
 00009200 
 . 00009300 
 D 00009400 
 00009500 
 00009600 
 00009700 
 00009B00 
 00009900 
 0001C000 
 
 00010100 
 
 00010200 
 00010300 
 00010400 
 
 E 00010500 
 00010600 
 
 OROOOIO7OO 
 OOOlObOO 
 
 00010900 
 00011000 
 00011100 
 
 00011200 
 
 0001 1300 
 00011400 
 
 OOOllbOO 
 * 00011600 
 
185 
 
 CURRITUSTRUCTURFPTR 
 
 ARRAY Mf SPLIT t t 1 7 D # 
 
 ACCFSSTAPLFC0:63]J 
 
 Dtf INE PI .ANKME SPLIT * RFPIA 
 
 FRPMS 
 
 TSKT 
 RFPL 
 
 SKfFALS 
 ACF PME. 
 
 yoRITFMESOUT * WRITE 
 
 UNDECL 
 IKT = 
 pPOL = 
 STR = 
 pTR = 
 fVNT = 
 PROS b 
 PATT = 
 STRUCT 
 ACCESS 
 DSLCODI 
 OSLFILi 
 LAPL = 
 ACCESSVARa 
 LFAVE= 
 
 iE = 
 .E = 
 
 
 
 1 
 
 2 
 
 3 
 
 4 
 
 5 
 
 6 
 
 7 
 
 6 
 
 9 
 
 10 
 
 11 
 
 12 
 
 13 
 
 • TO 
 
 PFGINS 
 FNDS = 
 
 r PE 
 
 ;frud 
 
 GIN LAP 
 
 FCflRPl 
 
 THENS 
 ELSE'S 
 FI = E 
 
 = THEN 
 = FND 
 ND t> 
 
 RFGIN 
 ELSE PE 
 
 ISlNIDS 
 % 
 % 
 % 
 t 
 % 
 * 
 
 * 
 r 
 
 * 
 
 1 
 
 CE PMES 
 
 % 
 
 J 
 
 F*FALSF 
 
 SOUT BY 
 
 * 
 
 * 
 CLINE'l 
 
 % 
 
 % 
 
 sr 
 f 
 % 
 
 * 
 
 * 
 * 
 
 f 
 % 
 y 
 
 EL FRUD 
 
 END *' 
 f. 
 % 
 J 
 f 
 1 
 % 
 
 t, 
 
 GIN t» 
 
 r 
 % 
 % 
 % 
 * 
 % 
 
 VARIABLF 
 TACK; 
 
 THIS V 
 CURRENTS 
 INTO THE 
 STRUCTUR 
 
 THIS A 
 OUTPUT V 
 LISTING. 
 WILL .ALW 
 
 THIS A 
 P01NTEPS 
 FOR THE 
 ACCFSS T 
 OUT PY " 
 
 THIS S 
 RLANKS I 
 
 );blankmf 
 
 ***** » , 
 THIS D 
 
 FIRST PA 
 
 INTO THE 
 
 7,MFS0im 
 
 THIS P 
 
 ARRAY ME 
 
 LINE. 
 THIS 
 THIS 
 THIS 
 THIS 
 THIS 
 THIS 
 THIS 
 THIS 
 THIS 
 THIS 
 THI$ 
 THIS 
 THIS 
 THIS 
 THIS 
 
 AN PSL 
 
 ecorp;#, 
 
 CODE PROCEDURES. 
 
 ARIARL 
 TRUf Til 
 
 IDSTA 
 ETAP. 
 RRAY I 
 ESS AGE 
 
 THF 
 AYS PO 
 RRAY C 
 
 INTO 
 LOCATI 
 YPE PE 
 " FPR 
 TATFME 
 NTO TH 
 SOUT J 
 
 t> 
 EFINE 
 RT OF 
 
 ARRAY 
 *]) *t 
 EFINE 
 SOUT I 
 
 F IS T 
 
 RFPTR 
 C* INS 
 
 S USED 
 S FOR 
 PPINTE 
 TNT TO 
 N T A I N 
 THE IP 
 ON OF 
 GLARED 
 17 WOR 
 NT WIL 
 E ARRA 
 
 WILL P 
 
 AN ERR 
 
 HESOU 
 
 WILL W 
 NTO TH 
 
 RUE I 
 POINT 
 TEAD 
 
 TO S 
 THE S 
 P PME 
 
 MESO 
 S 
 
 STACK 
 FACH 
 
 DS #> 
 L PUT 
 Y MES 
 
 F 
 
 S 
 OF 
 
 IS 
 IS 
 IS 
 IS 
 IS 
 IS 
 IS 
 IS 
 IS 
 IS 
 
 IS 
 
 IS 
 IS 
 
 is 
 
 LLOW 
 EAVF 
 
 UNDECAR 
 INTEGER 
 ROPLEAN 
 STRING. 
 POINTER 
 EVFNT. 
 PROCESS 
 PATTERN 
 STRUCTU 
 ACCESS. 
 CODE. 
 FILE. 
 A LAPEL 
 AN ACCE 
 S ONE TO 
 
 UT TH 
 OR ME 
 T. 
 
 RITE 
 E FIL 
 
 FD. 
 
 000 
 
 000 
 
 000 
 
 000 
 
 000 
 
 000 
 
 TORE 000 
 
 OURCEOOO 
 
 SOUT 000 
 
 unojooo 
 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 
 out 
 
 THE 
 F 
 
 PFGINS 
 IN PLACF 
 BEGIN AN 
 DEC I ARAT 
 USE AN 
 RETURN F 
 
 THE AP 
 
 ALIPW PN 
 
 STATEMFN 
 
 IF < 
 
 THEN 
 
 AND ENDS WH 
 OF THE OUTE 
 D FND IN A P 
 ION ROPY ALL 
 SL PFTURN ST 
 ROM THF PROC 
 
 OVF THREE DE 
 E TP USE OSL 
 TS OF THE FO 
 B.E.> 
 S 
 <STATEMENT> 
 <STATEMENT> 
 
 RE. 
 
 SS VA 
 SIMU 
 
 EN US 
 RMOST 
 ROCED 
 OW ON 
 ATEME 
 EDURE 
 
 FINES 
 2 IF 
 
 PMi 
 
 SSAGEOOO 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 RBLE 000 
 LATE 000 
 000 
 000 
 000 
 000 
 000 
 000 
 
 ED 
 
 ORE 
 
 F TO 000 
 NT TOOOO 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 000 
 
 11700 
 1 1600 
 1 1900 
 12000 
 12100 
 12200 
 12300 
 1 2 A 
 12500 
 12600 
 12/00 
 12600 
 12900 
 13000 
 13100 
 13200 
 13300 
 13400 
 1 3i>00 
 1 3600 
 13700 
 13600 
 13900 
 1 4000 
 1 4 1 
 1 4200 
 H300 
 1 4400 
 1 4500 
 14600 
 14700 
 14600 
 I4c,00 
 
 15000 
 15100 
 15200 
 15300 
 15400 
 15500 
 15600 
 15700 
 15600 
 15900 
 16000 
 16100 
 16200 
 163C0 
 16400 
 16500 
 16600 
 16700 
 16600 
 16900 
 17000 
 17100 
 1 7200 
 17300 
 17400 
 17500 
 17600 
 17700 
 
186 
 
 * 
 % 
 % 
 % 
 % 
 r 
 
 * 
 % 
 % 
 % 
 * 
 
 % 
 
 r 
 
 ELSFS 
 
 <STATFN'ENT>; 
 <STATEMENT> 
 
 <STATFHENT>) 
 <STATFHENT>J 
 
 FI 
 
 RpANCH(pPANCHl»PRANCH2,RRANCH3) = 
 
 PFGIN 
 
 IF PRlNTOPJfCT 
 
 THFN 
 
 BEGIN 
 
 blankmfsout; 
 
 replace pmfsput by currfntsegme^t 
 "|",rpanch1 for 4 digits* 
 
 replace fmfsput+35 by "( m , 
 
 curpentsegment for 3 digits,"*", 
 branch? for 4 d i g i t$, " ) " i 
 
 WRITEMESOUT 
 
 00017600 
 00017900 
 00016000 
 OOOlblOO 
 00016200 
 00016300 
 00016400 
 00016^00 
 00016600 
 00016700 
 00016600 
 00016900 
 00019000 
 00019100 
 00019200 
 00019300 
 00019400 
 000195)00 
 00019600 
 00019700 
 00019600 
 FOR 3 DIGITS, 00019900 
 «*** w#RRANCH3;00020000 
 00020100 
 
 <STATEMEKlT>> 
 
 <STATF^ENT> 
 
 END 
 
 END 
 
 * THIS DEFINE OUTPUTS 
 
 * BRANCH INSTRUCTION OF 
 
 * FORHt 
 
 * SEGtADDR BRANCH 
 pPERATOR(OPEPATORl) = 
 BEGIN 
 
 IF PRINTOBJECT 
 
 THEN * 
 
 BEGIN 
 
 blan*mesout; 
 
 replace pmfsout by currentsegment 
 "i^currfntaddpess 
 " ",operatoru 
 
 writfhesout 
 
 END» 
 SINCR(CURPENTADDRFSS) 
 
 END #, 
 
 % 
 
 % 
 
 % 
 
 XPPERATORCXOPERATORl) = 
 BEGIN 
 
 IF PRINTOBJFCT 
 
 THEN 
 ' BEGIN 
 
 blankmesout; 
 
 replace pmfsput by curprh tsegment 
 
 "l",CURRFNTADDRESS 
 
 •»*** ",XPPERAT0P1J 
 
 WRITFMESOIJT 
 
 END) 
 SlNCR(CliRPFNTADDRFSS) 
 
 00020200 
 
 00020300 
 
 00020400 
 
 00020500 
 
 00020600 
 
 A 00020700 
 
 THE 00020600 
 
 00020900 
 
 (SEGtADDR) OOOplOOO 
 
 00021100 
 
 00021200 
 
 00021300 
 
 00021400 
 
 00021500 
 
 00021600 
 
 FOP 3 DIGITS* 00021700 
 
 FOR A DIGITS, 00021600 
 
 00021900 
 
 00022000 
 
 00022100 
 
 00022200 
 
 00022300 
 
 THIS DEFINE EMITS AN 00022400 
 
 OPERATOR AS OBJECT CODE. 00022500 
 
 CURRENTADDRESS IS INCREMENTED .00022600 
 
 00O?2700 
 
 00022600 
 00022900 
 OOO23000 
 00023100 
 00023200 
 FOR 3 DIGITS, 00023300 
 FOP A DIGITS, O00?3400 
 00023500 
 00023600 
 00023700 
 00023600 
 
187 
 
 FND tt 
 
 % THIS PEFINF FMITS AN 
 
 * OPFRATOP AS riBJFCT CODE. 
 
 % CURRENTADDRFSS IS INCREMENTED 
 
 * THE OPFRATOP IS MARKED AS 
 
 % AN OVERWRITTEN INSTRUCTION. 
 
 COUPLF ( COUPLE i»C0UFLE2> COUPLE 3 > COUPLE*) = 
 BEGIN 
 
 IF PRINTOPJECT 
 
 THEN 
 
 BEGIN 
 
 BLANKMESOUTJ 
 REPLACE PMESO 
 
 WRJTFMESO 
 END! 
 
 SINCRCCURRENTA 
 FNO t* 
 
 UT 
 
 DDRE 
 
 UT BY CURPFNTSFGMENT FOR 3 DIGITS 
 "l w #CURRENTADDRESS FOR * DIGITS 
 " "»COUPLFl>" (% 
 C0UPLF2 FOR 2 niCJTS* M » ,, > 
 COUPLE3 FOR * DIGITS*") "> 
 C0UPLF4J 
 
 SS) 
 
 PUTPUTRFLOPCPUT 
 BEGIN 
 
 IE PRINTOP 
 
 THEN 
 
 BEGIN 
 
 INTFr. 
 POTNT 
 GETLK 
 BLANK 
 REPLA 
 
 PUTR 
 JECT 
 
 ER I 
 ER P 
 SYMC 
 MESO 
 CE P 
 CURR 
 
 w 
 
 CASE RELO 
 
 BEGIN 
 t 
 
 REPL 
 REPL 
 REPL 
 REPL 
 REPL 
 REPL 
 
 FND 
 
 ENPI 
 RELOP 
 t, 
 
 END) 
 IE (I 
 OR 1 
 OR I 
 THFN 
 WRITE 
 
 ♦ 01 
 
 ♦ SOP 
 = "< 
 
 = ••> 
 
 RFPL 
 MESO 
 
 * THIS DEFINF FMITS AN 
 f OPERATION CODE FOLLOWED BY 
 % A (LEVFl /DISPLACEMENT) COUpLE 
 FL0P1) * 
 
 t 
 j 
 
 DJ 
 
 utj 
 
 iPMFSOUT BY 
 
 ENTSEGMENT F O^P 3 DIGITS* 
 
 CURRENTADDRFSS FOR 4 DIGITS* 
 
 ">OUTPUTRELOP1*"-"J 
 P OF 
 
 ACE P'P BY "LFSS-THAN W J 
 
 ACE PIP BY "LESS-OR-EQUAL*; 
 
 ACE P»P BY ••ECUAL"; 
 
 ACE PIP BY "GRFATER-OR-EQllAL"J 
 
 ACE PIP BY "GRFATER-THAN") 
 
 ACE PIP PY ♦'NOT-EQUAL" 
 
 D(MSTACK»tTOP+l*PSYM)) = "< w 
 
 * OP I = "= M OP I = ">" 
 
 " OR I : "*•• 
 
 ACE PIP BY ••-PARTIAL-DESTRUCTIVE")' 
 
 UT? 
 
 % THIS rEFH'E FMITS 
 
 * RELATION OPERATOR CODE 
 f FOR INTEGERSjSTRINGS* 
 
 * AND POINTERS. 
 
 opfrfirstpart = 
 
 000?3900 
 0002*000 
 
 0002*100 
 
 .0002*200 
 0002*300 
 0002*400 
 0002*500 
 000?*600 
 0002*700 
 0002*600 
 0002*900 
 00025000 
 
 *00025l00 
 
 *00025200 
 00025300 
 00025400 
 00025500 
 00025600 
 00025700 
 00025600 
 00025900 
 00026000 
 00026100 
 00026200 
 
 ,00026300 
 00026400 
 00026500 
 00026600 
 00026700 
 0002680G 
 00026900 
 00027000 
 00027100 
 00027200 
 00027300 
 00027400 
 00027500 
 00027600 
 00027700 
 00027600 
 00027900 
 00026000 
 00026100 
 00026200 
 00026300 
 00026400 
 00026500 
 00026600 
 00026700 
 00026600 
 00026900 
 00029000 
 00029100 
 00029200 
 00029300 
 00029400 
 00029500 
 00029600 
 00029700 
 00029600 
 00029900 
 
188 
 
 BEGIN 
 
 IF PRINTORJECT 
 
 THEN 
 
 BEGIN 
 
 BLANKMESOUTJ 
 REPLACE PMFS 
 
 OPf RL ASTPART= 
 
 WRITFMESPUT 
 
 END) 
 
 SINCR(CURPENTADDR 
 FND Up 
 
 DROP = BEGIN DEFINE 01 
 
 *TABLE( IDSTACK' 1000, 
 
 TYPE = 
 ACCESSTYPE' 
 
 1 U, 
 5»6, 
 
 STDRETYPEs 11U, 
 
 EETCHTYPE= 15|4, 
 
 NUMBROFSUBS= 19l8> 
 
 Nl'MBRSUBSTRUCT = ?7:8> 
 
 MIMBROF PARMSs 35 j 6» 
 
 TYPEFLAGS= 43»5> 
 
 MACRCI= A 3 : 1 # 
 
 SUBSCRIPTED* 44»1, 
 
 PROCEDURES 45»1> 
 
 NDDE= 46M> 
 
 pWN = 47ll, 
 
 MlSCFLAGS= 49t8> 
 
 FORMALPARM= 49tl> 
 
 VALUEPARMs 50ll> 
 
 HASPEENSPEC= 5U1» 
 
 ACCESSpRncEDURE=5?t 1 » 
 DDMMYPARMs 5 3 t 1 > 
 
 pIGTAPPTRs 
 
 57 1 1 3* 
 
 GUT p 
 
 n 
 
 x 
 
 x 
 
 ESS} 
 
 % 
 
 X 
 
 37 = XX 
 
 X 
 X 
 X 
 
 X 
 
 J! 
 
 X 
 % 
 X 
 
 % 
 
 X 
 
 X 
 X 
 X 
 X 
 X 
 x 
 x 
 % 
 % 
 x 
 
 X 
 
 X 
 X 
 X 
 
 X 
 
 % 
 
 X 
 X 
 
 X 
 X 
 X 
 X 
 X 
 X 
 X 
 X 
 X 
 X 
 X 
 X 
 X 
 X 
 
 Y CURRFNTSFGMEMT FOP 3 DIGITS 
 ">CllRPENTADDPESS FOR 4 DIGITS 
 
 THIS DEFINE PUTS OUT T 
 THE FIRST PART OF AN OPERATOR 
 
 THI 
 THE L 
 IF PR 
 
 #;#; 
 
 THI 
 INTO 
 
 THI 
 CURPE 
 AND T 
 TO EA 
 
 THI 
 TYPE 
 
 THI 
 ACCES 
 DECLA 
 
 TYP 
 DATA. 
 
 TYP 
 DATA. 
 
 THI 
 NUMPE 
 
 NUM 
 
 NUM 
 
 THE 
 STORE 
 
 s define outputs 
 
 ast part of an operator 
 
 intobject is turned on. 
 
 s define is used to drop 
 
 a new segmfnt. 
 
 s stack stores all 
 
 ntly definfd identifiers 
 
 he information relative 
 
 ch of them. 
 
 s field holds the dsl 
 
 of the data. 
 
 s f ield contains the 
 
 s type number of data 
 
 red accfss. 
 
 e of store for access 
 
 e of fetch for access 
 
 MIS 
 
 FOR 
 
 CAL 
 
 THI 
 
 BEEN 
 
 PROCE 
 
 THI 
 
 THI 
 
 PARAM 
 
 ACCES 
 
 TO IN 
 
 VARIA 
 
 ACCFS 
 
 THI 
 
 TO TH 
 
 CURPE 
 
 S FIELD 
 R OF SU 
 BFP OF 
 BER OF 
 
 FOLLOW 
 
 D HERE! 
 
 MACR 
 
 SUBS 
 
 PROC 
 
 NODE 
 
 OWN 
 
 CEl.LANF 
 
 MAL PAR 
 
 L BY VA 
 
 S FORMA 
 
 DECLARE 
 
 DURE HE 
 
 S IS AN 
 
 S IS A 
 
 ETER IN 
 
 S PROCF 
 
 SPE THA 
 
 BLE IS 
 
 S PROCF 
 
 S POINT 
 
 E ID CH 
 
 NT SEMA 
 
 CONTAINS THE 
 BSCPIPTS. 
 SUBSTRUCTURES. 
 PROCEDURE PARMS. 
 INC. TYPE ELAGS AR 
 
 FLAG 
 CRIPTED 
 EDURE N 
 
 FLAG 
 FLAG 
 OUS FLA 
 AMETER 
 LUF FOR 
 L PARAM 
 D IN TH 
 ADING. 
 
 ACCESS 
 DUMMY F 
 SEPTED 
 PURE IN 
 T THE A 
 INCLUDE 
 DURE CA 
 S RACK 
 ARACTER 
 NTIC Fl 
 
 VARIABLE 
 AME 
 
 GS 
 
 MAL PAPM. 
 ETER HAS 
 E 
 
 PROCEDURE 
 ORMAL 
 INTO AN 
 
 ORDER 
 CCESS 
 D IN THE 
 LI . 
 
 INTO BlGTA 
 S AND 
 ELD FOP 
 
 00030000 
 00030100 
 00030200 
 00030300 
 00030400 
 /00030500 
 >00030600 
 00030700 
 00030t)00 
 .00030900 
 00031000 
 00031100 
 00031200 
 00031300 
 00031400 
 00031500 
 00031600 
 OOO3I7OO 
 O0O3lhO0 
 00031900 
 00032000 
 00100100 
 OOlOOgOO 
 00100300 
 00100400 
 OOlOObOO 
 00100600 
 00100700 
 00100600 
 00100900 
 OOlOlOOO 
 
 00101100 
 00101200 
 00101300 
 
 00101400 
 00101500 
 00101600 
 
 00101700 
 
 EOO1O1600 
 00101900 
 00102000 
 00102100 
 00102200 
 00102300 
 00102400 
 00102500 
 00102600 
 00102700 
 
 ooio2eoo 
 00102900 
 
 00103000 
 00103100 
 00103200 
 00103300 
 00103400 
 00103500 
 00103600 
 OO1O3700 
 B00103600 
 OO1O3900 
 00104000 
 
189 
 
 STRUCTURFPTR: 
 
 701 13* 
 
 FORMALPARMPTRs 83 I 1 3# 
 
 LEVEL = 97:6/ 
 FETCHPR0CEDURE=103:13* 
 ST0REPH0CEDUPE = H6:13/ 
 pLDSEMFIELD= 129 a 15* 
 
 ISDEFINED: 
 
 1 29 I 1 * 
 
 ISBETINGDFFINFD«130|1# 
 
 F0RWARDDEFINFD = 131 : 1* 
 iDSTACKPTRs 132x12* 
 DISPLACEMENT = 145:8/ 
 
 STRUCTPTRBEFORE= 153:1 3* 
 
 FFTCHAUXPTR= 1 66 » 1 3* 
 
 STPRFAUXPTRs 179 » 1 3* 
 LAPELSEGMFN'T = 1 53 » 1 5* % 
 I ABELSTARTADrRFSS= 166:13/* 
 LAPELENDADDRFSS=179:13j % 
 
 STPUCTURETA6* 1000/ 
 
 TYPE = 1:4, 
 
 ACCESS7YPF= 5:6* 
 
 STORETYPF= 11:4, 
 
 FETCHTYPE= 1 5 t ft * 
 
 K'UHBROFSUPSs 1918/ 
 
 NllMBRSUB5TRUCT*27:B, 
 
 MUMBROF PARh'Sr 35:8/ 
 
 TYPEFLAGS= 43:5/ 
 
 MACRO= 43:1/ 
 
 St'PSCRI PTFP= 44U* 
 
 PROCEDURFb 45:1* 
 
 NODE* 46:1* 
 
 ACCES! 
 
 ACCES! 
 
 CONTE 
 BIGTA 
 F C L A R 
 
 OWN 
 
 THIS in. 
 
 THIS POINTS TO SUP 
 DATA IN STRtlCTltRETAP 
 THF SUBSTRUCTURE OAT 
 BEGINS AT A HIGH ADD 
 AND CONTINUES TO A L 
 
 THIS POINTS TO A F 
 PARAMETFR LIST IN ST 
 THE FORMAL PARAMETER 
 BEGINS AT A HIGH ADR 
 AND CONTINUES TO A L 
 
 THIS VARIARLF IS A 
 AT THIS LEVEL 
 
 THIS PUINTS TO AN 
 FETCH PPOCFPURF. 
 
 THIS POINTS TO AN 
 STORE PROCEDURE. 
 
 THIS CONTAINS THE 
 OF THE SEM FIELD OF 
 BEFORE THIS TD WAS D 
 
 THIS IS THE BREAKP 
 
 SEM FIFl D, * 
 
 * 
 
 * 
 
 * 
 
 THIS VARIARLF IS A 
 AT THIS DISPLACEMENT 
 
 THIS IS STRUCTURET 
 BEFORE THIS MESS WAS 
 
 THIS FIELD IS USFD 
 AUXILLIARY FETCH DAT 
 ACCFSS TYPES AND ACC 
 VARIABLES. 
 
 AUXILLIARY STORE D 
 THESE THREE FIELDS 
 DESCR1PF THF BOUNDS 
 LABEL^, 
 
 THIS TABLE-STACK L 
 IDENTICAL TD IDSTACK 
 USED TO STORE ALL SU 
 IDS AND THF INFORMAT 
 RELATIVF TO THFM, 
 
 THIS FIELD HOLDS T 
 TYPE OF THE DATA. 
 
 THIS FIELD CONTAIN 
 ACCESS TYPE NUMBER 
 DECLARED ACCESS. 
 
 TYPE OF STORE FOR 
 DATA. 
 
 TYPE OF FETCH FOR 
 DATA. 
 
 THIS FIELD CONTAIN 
 NUMPER OF SUBSCRIPTS. 
 
 NUMRFP OF SUBSTRUCTURE'S 
 
 NUMBFP OF PROCEDURE PAR 
 
 THE FOLLOWING TyPF FLAG 
 STORED HERE: 
 
 MACRO FLAG 
 SUBSCRIPTED VARIA 
 PROCFDUPF NAME 
 NODE FLAG 
 
 001 
 STRUCTURE 001 
 
 001 
 
 A 001 
 
 RESS 001 
 
 PW ADDHESS001 
 
 R M A L 01 
 
 RUCTURETAB001 
 
 .DATA 001 
 
 RESS 001 
 
 OW ADDRESS001 
 
 DDRESSEO 001 
 
 001 
 
 001 
 
 001 
 
 001 
 
 001 
 
 001 
 
 001 
 
 001 
 
 NTS 
 
 P 
 
 ED. 
 
 F 
 
 DDRESSED 
 
 AB PO 
 
 DECL 
 
 FOR 
 A IN 
 ESS 
 
 ATA. 
 
 OF A 
 
 OOKS 
 . IT 
 BSTRU 
 ION 
 
 HE OSL 
 
 S THE 
 F DATA 
 
 ACCES 
 ACCES 
 S THE 
 
 THF001 
 001 
 001 
 001 
 001 
 001 
 001 
 INTER001 
 ARED.OOl 
 001 
 001 
 001 
 001 
 001 
 001 
 001 
 001 
 001 
 IS 001 
 CTURE001 
 001 
 001 
 001 
 001 
 001 
 001 
 001 
 001 
 001 
 001 
 001 
 001 
 001 
 001 
 MS. 001 
 S ARF001 
 001 
 001 
 001 
 001 
 001 
 
 s 
 
 RLE 
 
 04100 
 04200 
 
 04300 
 04400 
 04500 
 04600 
 04700 
 04600 
 04900 
 05000 
 05100 
 05?00 
 05300 
 05400 
 05500 
 05600 
 05700 
 05800 
 05900 
 06000 
 06100 
 06200 
 06300 
 06400 
 06500 
 06600 
 06700 
 6800 
 06900 
 07000 
 07100 
 07200 
 07300 
 07400 
 07500 
 07600 
 07700 
 07800 
 07900 
 08000 
 08100 
 08200 
 06300 
 08400 
 08500 
 06600 
 06700 
 06800 
 08900 
 09000 
 09100 
 09200 
 09300 
 09400 
 09500 
 09600 
 09700 
 9 6 00 
 09900 
 10000 
 10100 
 
190 
 
 pWN = 
 MlSCFLAGS= 
 
 f0rmalparm= 
 
 valueparm= 
 
 hasbefnspfc= 
 
 ACCESSpRPcFDl>RF = 52i 1* 
 
 DUMMYPARMs 
 
 47:1* * 
 
 49»P, * 
 
 4911* % 
 
 50*1* % 
 
 51» 1* * 
 
 * 
 
 S 
 
 * 
 
 5311* * 
 
 X 
 
 % 
 
 % 
 
 r 
 
 57113* r 
 
 * 
 
 t 
 t 
 
 r 
 
 * 
 * 
 
 X 
 
 * 
 
 % 
 % 
 X 
 % 
 % 
 f 
 1 
 
 1 29i 1 * X 
 
 * 
 
 X 
 X 
 t 
 
 * 
 J! 
 
 * 
 
 X 
 X 
 
 STHREAUXPTR* 1 79 » 1 3* X 
 
 LABELSEGMFNT = 153 1 15* X 
 
 LABELSTARTADDRFSS=166:13*? 
 
 LABELENDADDRFS?sl79ll3)J X 
 SCELL( IDENTRY* 
 
 TYPE = 111* * 
 
 X 
 
 ACCESSTYPE= 516* X 
 
 X 
 % 
 
 ST0RETYPF= ll»fl* X 
 
 pIGTABPTP= 
 STRUCTURFPTRr 70 l 1 3* 
 
 FORMALPARMPTR= 83113* 
 
 LEVEL = 97i6* 
 FETCHPROCEDURE=103jl3* 
 ST0REPR0CEDURE=ll6|l3# 
 OLDSEMF IFLO= 129»15* 
 
 ISDEFINED= 
 
 ISBEING0FFINFD=130j1» 
 FPPWARDDEFINFD = 131 t 1* 
 lOSTACKPTRr 132tl?» 
 DISPLACEMENT = H5l8* 
 
 STRUCTPTRpFF0RF=153»13* 
 FETCHAUXPTR= 166 i 1 3* 
 
 MIS 
 
 FOR 
 
 CAL 
 
 TNI 
 BEEN 
 PROCE 
 
 THI 
 
 THI. 
 PAPAM 
 ACCFS 
 TO IN 
 VARI A 
 ACCFS 
 
 THI 
 TO TH 
 CURPE 
 THIS 
 
 THI 
 DATA 
 THE S 
 BEGIN 
 AND C 
 
 THI 
 PARAM 
 THE F 
 BEGIN 
 AND C 
 
 THI 
 AT TH 
 
 THI 
 FETCH 
 
 THI 
 STOPE 
 
 THI 
 OF TH 
 BEFOR 
 
 THI 
 SEM F 
 
 THI 
 AT TH 
 
 THI 
 BEFCR 
 
 THI 
 AUXIL 
 ACCFS 
 VARIA 
 
 AUX 
 
 THFS 
 
 DESCR 
 
 LABEL 
 
 THI 
 TYPF 
 
 THI 
 ACCFS 
 DECl A 
 
 TYP 
 
 OWN FLAG 00 
 
 CFILANFOUS FlAGS 00 
 
 MAI. PAPAMFTER 00 
 
 L BY VALUF FORMAL PARM. 00 
 
 S FORMAL PARAMETER HAS 00 
 
 DFCLARFD IN THE 00 
 
 DUPE HEADING. 00 
 
 S IS AN ACCESS PROCEDURE 00 
 
 S IS A DUMMY FORMAL 00 
 
 FTFR INSERTED INTO AM 00 
 
 S PROCFDUPF IN ORDER 00 
 
 SRF THAT THE ACCESS 00 
 
 BLF IS INCLUDED IN THE 00 
 
 S FROCFDUPF CALL. 00 
 S POINTS PACK INTO RlGTABOO 
 
 E ID CHARACTERS AND 00 
 
 NT SEMANTIC FIELD FOP 00 
 
 m. 00 
 
 S POINTS TO SUBSTRUCTURE 00 
 IN STRUCTllPETAB. 00 
 
 IJRSTRUCTURF DATA 00 
 
 S AT A HIGH ADDRESS 00 
 ONTINUFS -TO A LOW ADPRESSOO 
 S POINTS TO A FORMAL 00 
 ETFR LIST IN ST RUCTUPET ABOO 
 OPMAL PARAMETER DATA 00 
 S AT A HIGH ADDRESS 00 
 ONTINUFS TO A LOW ADPRESSOO 
 
 IS ADDRESSED 
 ACCESS 
 
 00 
 00 
 
 
 00 
 00 
 00 
 00 
 00 
 00 
 
 S VARIABLE 
 
 IS LEVFL 
 
 S POINTS TO AN 
 
 PROCEDURE. 
 S POINTS TO AN ACCESS 
 
 PPOCEDtlRF. 
 S CONTAINS THE CONTENTS 
 E SEM FIELD OF PlGTAP 
 E THIS ID WAS DECLARED. 
 S IS THE BREAKDOWN OF THEOO 
 IFLD. * 00 
 
 * 00 
 
 * 00 
 
 * 00 
 S VARIAPLF IS ADDRESSED 00 
 IS DISPLACEMENT 00 
 S IS STRUCTURFTAR POINTEROO 
 E THIS MESS WAS DECLARED, 00 
 
 S FIELD IS USED FOR 
 I TARY FFTCH DATA In 
 S TYPES AND ACCESS 
 BLFS. 
 
 STPRF DATA. 
 
 FIELDS 
 
 BOUNDS OF A 
 
 THE OSL 
 
 ILLIARY 
 E THREE 
 IPE THE 
 
 S FIELD HOLDS 
 
 OF THE DATA, 
 
 S FIEID CONTAINS THE 
 
 S TYPE NUMBER OF DATA 
 
 RED ACCFSS. 
 
 E PF STORF FOR ACCESS 
 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 
191 
 
 FETCHTYPE= 15:4, 
 
 NUMBROFSHRSs 19f8» 
 
 NUMPRSUBSTF<UCTB?7tP# 
 
 NUMBROFPARMSs 35 t ft » 
 
 TYPEFLAGS= 43l5> 
 
 MACRO= 43ll> 
 
 SUBSCRIPTED* 44tl, 
 
 PROCEDURE* 45ll» 
 
 NODE* A6 I 1 * 
 
 OWN= /»7tl» 
 
 MlSCFLAGS= 4 9 » 6 * 
 
 FORMALPARMs 49tl> 
 
 VALUEPARM= 50 1 1 > 
 
 HASBEENSPFCs 5ltl> 
 
 ACCESSPRncEDURE=5?ll# 
 pl)MMYPARM = 53»1» 
 
 BIGTABPTR= 
 
 STRUCTURFPTRi 
 
 57113/ 
 
 70»13/ 
 
 FORMALPARMPTps 83tl3, 
 
 LEVEL = 97i6> 
 
 FETCHPR0CEDUPE=103 jl3> 
 ST0REPR0CEDUPE=116»13* 
 PLDSEMFlELOs 129 t 15* 
 
 ISDEFINEDs 
 
 1 29 1 1 * 
 
 ISPEINGDFF!NFD=130«1* 
 F0RWARDDFF1NFD-131 J 1 > 
 IPSTACKPTR= 1 32 i 1 2> 
 DISPLACEMENT = 145j8> 
 
 STRUCTPTRREFPRF=153$13, 
 
 FETCHAUXPTR* 166|13> 
 
 * DATA. 
 
 % TYPE OF FFTCH FOR 
 
 * DATA. 
 
 * THIS FIELD CONTAIN 
 % NUMBER OF SUBSCRIPTS 
 % NUMBFR OF SUPSTRUC 
 ? NUMBFR OF PROCEPUR 
 
 * THE FOLLOWING TYPE 
 % STORED HEREJ 
 
 * MACRO FLAG 
 
 % ■ SUBSCRIPTED 
 
 t PROCFDURE NA 
 
 * NODF FLAG 
 % OWN FLAG 
 
 * MISCELLANEOUS FLAG 
 X FORMAL PARAMETER 
 
 * CALL PY VALUE FORM 
 T THIS FORMAL PARAGE 
 r BEEN DTCLARED I N THE 
 S PROCEDURE HEADING. 
 
 % THIS IS AM ACCESS 
 
 * THIS IS A OUMMY FO 
 
 * PARAMETER INSERTED I 
 r ACCESS PROCEDURE IN 
 ?: TO INSRF THAT THE AC 
 1 VARIABLE IS INCLUDED 
 
 * ACCESS PROCEDURF CAL 
 % THIS POINTS BACK I 
 
 * TO THE ID CHARACTERS 
 y CURRENT SEMANTIC FIE 
 
 * this in. 
 
 % THIS POINTS TO SL'F 
 
 % DATA IN STRUCTliRETAR 
 % THE SUBSTRUCTURE PAT 
 
 * BEGINS AT A HIGH ADD 
 % AND CONTINUES TO A L 
 
 * THIS POINTS TO A F 
 f PARAMETER LIST IN ST 
 % THE FORMAL PARAMETER 
 % BEGINS AT A HIGH APT 
 
 * AND CONTINUES TO A L 
 
 * THIS VARIABLE IS A 
 
 * AT THIS LEVEL 
 
 * THIS POINTS TO 
 
 * FETCH PROCEDURE. 
 
 * THIS POINTS TO 
 
 * STOKE PPOCEPURE. 
 
 % THIS CONTAINS THE 
 
 * OF THE SEM FIELD OF 
 
 * BEFORE THIS ID WAS P 
 
 * THIS IS THE PREAKO 
 
 * SEM FIELD. * 
 t # 
 t * 
 % * 
 
 f THIS VARIABLF IS A 
 
 * AT THIS DISPLACEMENT 
 % THIS IS STRUCTURET 
 % BEFORE THIS MESS WAS 
 % THIS FIELD IS USED 
 
 * AUXILLIARY FETCH DAT 
 
 ACCES 
 
 S THE 
 
 TURES 
 
 E PAR 
 
 FLAG 
 
 VARIA 
 ME 
 
 PLE 
 
 AL PA 
 TER H 
 
 PROCE 
 RMAL 
 NTO A 
 ORDER 
 CESS 
 
 IN T 
 L. 
 NTO B 
 
 ANP 
 LD FO 
 
 STRUC 
 . 
 A 
 
 RtSS 
 OW AD 
 ORMAL 
 RUCTU 
 PATA 
 RESS 
 OW AD 
 DDRES 
 
 00 
 S 00 
 00 
 00 
 00 
 00 
 MS. 00 
 S AREOO 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 DURE 00 
 00 
 
 PM 
 AS 
 
 HE 
 
 AN ACCESS 
 
 AN ACCESS 
 
 00 
 
 00 
 00 
 00 
 00 
 
 IGTABOC 
 00 
 
 P 00 
 00 
 
 TuRE 00 
 00 
 00 
 00 
 
 PhESSOO 
 00 
 
 PFTABOO 
 00 
 00 
 
 rRESSOO 
 
 SED 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 
 CONTENTS 
 
 BIGTAP 
 
 ECLARED. 
 
 OWN OF THEOO 
 00 
 00 
 00 
 00 
 
 DDRESSED 00 
 00 
 
 AB POTNTEROO 
 DECLARED. 00 
 FOR 00 
 
 A IN 00 
 
 U6300 
 1 16400 
 H6500 
 1 16600 
 116700 
 U6600 
 116900 
 117000 
 117100 
 H7200 
 H7300 
 117400 
 H7500 
 117600 
 117700 
 117600 
 117900 
 116000 
 116100 
 1 16200 
 116300 
 116400 
 116500 
 118600 
 U6700 
 118600 
 116900 
 1 19000 
 119100 
 H9200 
 U9300 
 119400 
 H9500 
 119600 
 119700 
 1198.00 
 1 19900 
 120000 
 120100 
 120200 
 120300 
 120400 
 120500 
 120600 
 120700 
 lpOBOO 
 120900 
 121000 
 12H00 
 121200 
 121300 
 1?1400 
 121500 
 121600 
 121700 
 121600 
 121900 
 122000 
 122100 
 122200 
 122300 
 
192 
 
 * 
 
 % 
 
 STOREAUXPTR* 179»13> % 
 lABELSEGMENT = 1 53 l 15* % 
 LAPEL ST ARTADPRFSSM6M13*? 
 LABELENDADDRESS=179Jl3)> f 
 STAF.LEC LFAVEsTACK* 100* MARK=1 $ 1 * ADDRFS 
 
 % 
 * 
 % 
 
 r 
 
 iADDCOU BlGTAR* 
 
 ISDEFINED = HI, r 
 
 ?! 
 
 % 
 
 ISREINGDEFINFD=2»1* * 
 
 % 
 
 * 
 * 
 
 IDSTACKPTR ~ 4»12* * 
 
 % 
 % 
 % 
 
 f 
 
 X 
 F0RWARDDFFlNFD=3ll* * 
 
 V 
 
 r 
 
 IDLENGTH = 16t6J * 
 
 MSTACK* 
 
 05L2SEMFIELD = 1«35» % 
 
 % 
 NODE = 111* % 
 
 % 
 STRUCTUREPTR = 2tl3* * 
 
 r 
 * 
 
 NUMBRSUBSTRUCT=l5t8* * 
 PPOCEDUREPTRISINTDIDSTACK : 
 
 % 
 
 r 
 
 r 
 s 
 
 PROCEDUREPTR = 2Atl?)J % 
 
 % 
 % 
 
 sstackc Idcounterstack* 32; % 
 
 r 
 
 * 
 
 r 
 f 
 
 STPUCTURFPARMSTACM 160; % 
 
 * 
 % 
 
 PPOCEPUREIDSTACK* 32; * 
 
 r 
 % 
 
 ACCFSS TYPES AND ACCFSS 
 VARIABl FS. 
 
 AUXILI IARY STORE DATA. 
 THFSE THREE FIELDS 
 DESCRIPF THF BOUNDS OF A 
 LABEL 
 S=2|46)J 
 
 LEAVFSTACK SAVES PRANCH 
 ADDPESSFS FOR A PLANT AT 
 THE END OF A LABELLED 
 STATEMFNT. 
 
 00122400 
 
 00122500 
 
 00122600 
 
 00122700 
 
 00122(}00 
 
 00122900 
 
 00123000 
 
 00123100 
 
 00123200 
 
 00123300 
 
 00123400 
 
 00123500 
 
 THIS ID IS CURRENTLY 00123&00 
 
 DECLARFT. (NOTE! THIS FIELD 00123700 
 
 ALSO OCCURS IN IDSTACK.) 00l23b00 
 
 THIS ID IS DFCLAPfcO IN THE 00123900 
 
 CURRENT BLOCK AND MAY NOT BE 0012^000 
 
 RE-pECI ARFD BY ANOTHFR 0012M00 
 
 DECLARATION IN THE SAME BLOCK 0012^200 
 
 HEAD. (NCTFJ THIS FIELD AL SOOOl 2^300 
 
 OCCURS IN IDSTACK.) 0012^400 
 
 THIS FIELD CONTAUS A 0012^500 
 
 POINTER INTO THE CURRENT ENTRYOO 1 24600 
 
 IN IDSTACK THAT DEFINES THE 00124700 
 
 TYPE AMP PARAMETERS OF THIS 00124600 
 
 ID. (NOTE: THIS FIELD ALSO 0012^900 
 
 OCCURS IN IDSTACK.) 00125000 
 
 THIS IS A FORWARD DEFINED 00125100 
 
 PROCEDURE IF THIS FIELD IS A 00125200 
 
 ONE, 00125300 
 
 THIS IS THE LENGTH 00125400 
 
 OF THE ID IN THIS BEGTAB CELL , 001 25500 
 
 00125600 
 
 THIS IS THE 0SL2 * 00125700 
 
 SEMANTICS FIELD IN MSTACK. O0l25bO0 
 
 IF THIS BIT TS ON* THE ID 00125900 
 
 SCANNFD IS OF CLASS MODE. 00126000 
 
 THIS FIELD POINTS INTO 00126100 
 
 STRUCTUPETAP IF THE ID 00126200 
 
 SCANNED WAS A STRUCTURE. ■ 00l?6300 
 
 LFNGTH OF ABOVE VECTOR. 00126400 
 
 23:1* 00126500 
 
 IF PROCEDUREPTR BFLOw 00126600 
 
 POINTS TO A PROCEDURE IN THE 00126700 
 
 IDSTACK RATHFR THAN 00126800 
 
 STRUCTUPETAP* THEN THIS 00126900 
 
 FIELD TS SET TO ONE (1). 00127000 
 
 POINTER TO PROCEDURE 00127100 
 
 IF' LAST ID SCANNED WAS A 00127200 
 
 PROCEDURE. 0C127300 
 
 THIS STACK CONTAINS ID 00127400 
 
 COUNTFRS THAT TFLL HOW MANY 00127500 
 
 IDENTIFIERS HAVF TO BE POPPED 00127600 
 
 OFF OF THE ID STACK AT THF 00127700 
 
 CLOSE OF THF CURRENT BLOCK. 00127B00 
 
 THIS STACK HOLDS PUSHED DOWN001?7VOO 
 
 PARAMFTFRS DURING A STRUCTURE 00128000 
 
 DECLARATION SCAN. 00126100 
 
 AS NFSTED PROCEDURF DFCL ARA-00 1 28200 
 
 TIONS ARE ENCOUNTERED* THE OOI283OO 
 
 POINTER TO THE OLD FROCEDUHE 00128400 
 
193 
 
 BOOLEAN iFORMALSWlTCHSTACK* 
 
 SUPSCRIPTSTACK, 96; 
 
 BLOCKSTACK/ 96; 
 
 STMTIFSTACK, 96j 
 
 EyPRSMFSTACK* 96; 
 
 LpLCOllNTFRSTACK* 32; 
 
 CASESTACK* 256; 
 
 ACTUALPARMSTACK* 96); 
 
 f 
 
 f 
 % 
 
 V 
 
 % 
 
 32;* 
 
 y 
 % 
 
 % 
 
 v 
 
 %. 
 % 
 % 
 % 
 f 
 % 
 % 
 r 
 % 
 
 * 
 
 % 
 
 * 
 
 BEING DF 
 THIS STA 
 THE POIN 
 RETURN S 
 
 PROPERLY 
 
 THIS S 
 
 THE STAT 
 
 FORNALPA 
 
 SWITCH 
 
 CONTAI 
 CURRENTN 
 OTHER PA 
 
 HOLDS 
 ADDRESS 
 
 HOLDS 
 FOR IFST 
 
 HOLDS 
 FOR IF F 
 
 THIS S 
 NUMPER 
 TO RE ST 
 
 THIS S 
 ADPPESSF 
 CODE. 
 
 WHEN S 
 ACTUAL P 
 STACK CO 
 DOWN VAL 
 AND ACTU 
 COUNTERS 
 IDSTACK 
 
 FINFD IS PUSH 
 CK. THE PURP 
 TF.RS IS TO AL 
 TATFMFNTS TO 
 
 PROCESSED. 
 TACK IS USED 
 US OF THE SCA 
 RAMETEROECI AR 
 
 NS Pll 
 
 UK PER 
 
 TA. 
 
 SEGMF 
 
 DATA 
 
 IF IN 
 
 ATFMF 
 
 IF IN 
 
 XPRES 
 
 TACK 
 
 F LEF 
 
 OPED 
 
 TACK 
 
 S FOP 
 
 SHFD' DOW 
 OFSUPS A 
 
 NT ANT 
 
 FORMATIO 
 NTS 
 
 FORMATIO 
 SIONS 
 HOLDS TH 
 T PART I 
 INTO, 
 HOLDS PR 
 CASE OB 
 
 ED INTO 
 OSE OF 
 
 LOW 
 BF 
 
 TO STORE 
 
 NNINO- 
 
 ATIOMS 
 
 N VALUES 
 ND 
 
 N 
 
 N 
 
 E 
 TEMS 
 
 DEF INE PRINTID = 
 
 POINTER($rPD(PlGTAB>fOPD(fSTAC 
 FOR $OPD(BlGTAB>$OPDfMSTACK^T 
 
 * THIS 
 % CHAPACTE 
 f BIGTAB P 
 
 * IN THE f 
 
 CANNING 
 ARANETFRS, TH 
 NT A IMS THE PU 
 UES OF THE FO 
 AL PARAMETER 
 
 ANO POINTERS 
 ARE STORED HF 
 
 K, STOP, ENTRY ) 
 OP»FNTRY)#IDL 
 EFINF PRINTS 
 RS POINTED TO 
 Y THE ENTRY F 
 OP OF MSTACK. 
 
 ANCH 
 JECT 
 
 IS 
 
 SHED 
 
 RMAL 
 
 RE. 
 
 + 1/SALD) 
 ENGJH) ti 
 THE ID 
 
 IN 
 IELD 
 
 PROCE 
 VALUE 
 BOOLE 
 BEGIN 
 
 dupe dompentry( i d, entry* indfnt ) ; 
 
 iD/entrymndfnt; 
 an id; integer entr y> i ndent j 
 
 integer i>nfl»nol>n>t; 
 
 ALPHA ARRAY At0l89]l 
 
 fointfr p*paj 
 
 bl ankmfsout; 
 
 pa «■ pointer(a); 
 
 replace pjpmes0ut+(i«-mln(5xindfnt^95)) py 
 
 if id then replace p»p py "idstack « 
 
 else rfplacf plp fy "strl'c tupft ar "; 
 replace p by "entry "'entry fop 4 digits' 
 
 " lfvel "# infect for 2 digits; 
 writemfsout; 
 
 I <- Ub) 
 
 NPL <- FMTlER((l32-l)/20); 
 
 P <- PA* 
 
 IF (T ♦ SOPD(IDENTRY,TYPE)) * 
 
 THEN 
 
 ===> "; 
 
 OOI265OO 
 00126600 
 00126700 
 00126600 
 00126900 
 00129000 
 00129100 
 00129200 
 00129300 
 00129400 
 00129500 
 00129600 
 00129700 
 00129600 
 00129900 
 00130000 
 00130100 
 00130200 
 001 30300 
 00130400 
 00130500 
 00130600 
 00130/00 
 00130600 
 
 001 30900 
 
 00131000 
 00131100 
 00131200 
 00131300 
 OO13UO0 
 00131500 
 00200100 
 00200200 
 G0200300 
 00200400 
 00200500 
 00200600 
 00200700 
 00300100 
 00300200 
 00300300 
 00300400 
 00300500 
 00300600 
 00300700 
 00300600 
 00300900 
 00301000 
 00301100 
 00301200 
 00301300 
 00301400 
 00301500 
 00301600 
 00301700 
 00301600 
 00301900 
 00302000 
 00302100 
 00302200 
 00302300 
 
19^ 
 
 B F G I N 
 
 IF T > 
 
 THFN RE 
 
 flse 
 
 PEG IN 
 
 DE 
 PP 
 CA 
 PE 
 
 13 
 
 PLACE P«P 
 
 BY "TYPE ",T FDR 2 DIGITS 
 
 FIN 
 P " 
 SF 
 GIN 
 
 F FPP=RFPLACF 
 
 TYPE "J 
 
 T TF 
 
 PfP BY #) 
 
 RFPL.ACF PJP-? BY 
 RPF ".INTEGER") 
 RPP ".POPLEAN") 
 RPP "..STRING"; 
 RPP ".POINTER") 
 RPP "...EVENT") 
 RPP ".PPOCFSS"; 
 RPP ".PATTFRN") 
 REPLACE PlP-1 BY 
 RPP "..ACCFSS") 
 RPP "....CPPF") 
 RPP "....FILE") 
 RPP "...LAPFL") 
 REFLACE PtP-1 BY 
 
 "UNpECL ARED") 
 
 "STRUCTURE") 
 
 "ACCESSVAR"; 
 
 EN 
 END 
 END) 
 
 IF (T «■ SOPD 
 1HFN RFPLACE 
 IF CT <■ SOPD 
 THEN REPLACE 
 IF (T «■ SpPU 
 
 then replace 
 
 if ct «■ sopd 
 then replace 
 
 if (T <- SOPD 
 THEN pFPLACE 
 IF (T «■ SOPD 
 THEN REPLACE 
 IF BOPt.EAN(S 
 THFN REPLACE 
 IF bOpLEANCS 
 THEN RFPLACE 
 IF BOOLEANU 
 THEN REPLACE 
 IF BOOl PAN (J. 
 THFN REPLACE 
 IF BOpLEANCS 
 THEN RFFLACt 
 IF BODLEAN($ 
 THEN REPLACE 
 IF POPLEANC* 
 THFN RFPLACE 
 IF BOOLEANCfc 
 
 then replace 
 if (T ♦• SOPD 
 THEN RFPLACE 
 IF (T * SPPD 
 THEN REPLACE 
 IF (T «■ Sppp 
 THEN REPLACE 
 
 if (T «■ snPD 
 
 ( IDFNTRY*ACCESSTYPF)) * 
 
 PiP PY "ACCESSTYPF ",T FOR 2 DIGITS) 
 
 ( IDENTRY^STORETYPE)) * 
 
 P:P PY "STPRETYPE ",T FOR 2 DIGITS) 
 
 ( IDENTRY/FETCHTYPE)) i 
 
 PtP PY "FFTCHTYPE. , . . . . ,",T FOP 2 PIGITSJ 
 ( IDENTRY>KtiMPPOFSUPS)) * 
 
 PtP RY "NUMRPOFSUPS... ,"»T FOR 3 PIGITS) 
 CIDENTRY,NUK'BRSI'BSTRUCT)) / 
 
 PJP PY "NUMRPSURSTRUCT."#T FOR 3 DIGITS) 
 (TDFNTRY,NUHBROFPARMS)) # <r 
 
 PjP FY "NUKPPOFPARKS. . ,">T FOR 3 DIGITS) 
 OPDCIDEN'TRY, MACRO)) 
 
 PtP py "MACRO. ....... ,TRUF") 
 
 OPD ( IDE MTRY> SUBSCRIPTED)) 
 
 PtP PY "SUBSCRIPTED. . .TRUE") 
 DPD( I PENTRY, PROCEDURE)) 
 
 PtP PY "PROCFDURE TRUF") 
 
 OPD( IDFNTRY^NODE)) 
 
 PtP PY "NPDF TRUF") 
 
 rlPD( I PELTRY* FORM ALP ARM)) 
 
 PtP PY "FORMALPARM. . ...TRUE") 
 OPP(IPFNTRY,VALUEPARM)) 
 
 PtP FY "VAI.UEPARM. . . . .TRUE") 
 OPP(IPF^ TRY/HASPEEMSPEC)) 
 
 PtP PY "HASPFENSPFC. . .TRUE") 
 OPDC IPENTRY^OWN) ) 
 
 PtP PY "OWN ......TRUF") 
 
 (TDFNTRY..BIGTABPTR) ) * 
 
 PtP PY "BIGTABPTR "#T FOR « DIGITS) 
 
 ( IDENTRV/STRUCTUREPTR) ) * 
 
 PtP PY "STPUCTUREPTR. ,"^T FOR 4 DIGITS) 
 ClDENTRY,FORMALPARMPTRn * 
 
 PtP PY "FORMALPARMPTR."*T FOR A DIGITS) 
 ( IDENTRY,FETCHPROCFPURE)) * 
 
 00302400 
 00302500 
 00302600 
 00302700 
 00302600 
 00302900 
 00303000 
 00303J00 
 00303?P0 
 00303300 
 00303400 
 00303500 
 00303600 
 00303700 
 00303800 
 00303900 
 0030^000 
 0030^100 
 00304200 
 00304300 
 00304400 
 00304500 
 00304600 
 00304700 
 00304600 
 00304900 
 00305000 
 00305100 
 00305200 
 00305300 
 00305400 
 00305500 
 00305600 
 00305700 
 00305800 
 00305900 
 00306000 
 00306100 
 00306200 
 00306300 
 00306400 
 00306500 
 003066^0 
 00306700 
 00306600 
 00306900 
 00307000 
 00307100 
 00307200 
 00307300 
 00307400 
 00307500 
 00307600 
 00307700 
 00307600 
 00307900 
 00308000 
 00306100 
 0030(3200 
 00306300 
 00306400 
 
195 
 
 THEN PFP 
 IF (T + 
 THFN pEP 
 IF CT «■ 
 THFN PFP 
 IF (T «■ 
 THFN PFP 
 IF BOOI.F 
 THFN REP 
 IF bOPLF 
 THFN PFP 
 IF BOPLE 
 THEN PFP 
 IF CT * 
 THFN RFP 
 
 if (t <- 
 
 THFN PEP 
 N * DELT 
 IF N r 
 THFN 
 BFGIN 
 
 PI A 
 RFP 
 
 END 
 El SE 
 BFGIN 
 
 T * 
 WHT 
 BFG 
 
 DTGITSI 
 
 digits; 
 
 LACE P«P PY M FFTCHPRPCDPR..«,T FOR 4 DTGITS; 
 
 SOPO(IDENTRY»STpRFPROCFDURE)) 4 
 
 LACE PtP PY "STPPROCEDURE. .">T FOR 4 DIGITS; 
 
 SOPD(IDENTRY,FETCHAUXPTR)) / 
 
 LACE PlP FY "FFTCHAUXPTR, . „•«> T FOR 4 
 
 SOPDC IDENTRY»STC1RFAUXPTP) ) 4 
 
 LACE P»P PY "STORFAUXPTR. ..", T FOR 4 
 
 ANCSOPDC IPENTRY,ISPFFH'ED)) 
 
 LACE P:P PY "ISTEFI^'ED tRUF*J 
 
 anupppc ipe>'try,isbeinodefhedn 
 lace p:p py "ispeingdef.. # .true*; 
 
 AN(SPPD(lDENTRY,FORWARprEFlNED)) 
 
 LACE P«P PY "FDRWARDDEf. . . .TRUF"; 
 
 *OPU(TDENTRY*IDSTACkPTR)) * 
 
 LACE P»P PY "IPSTACKPTR. . ..«>T FOR 4 DIGITS; 
 
 SOPD(IDFNTRY,STRUCTPTRPFFORF)) * 
 
 LACL P«P PY "STRliCTPTRPFnR.*/T FOR 4 DIGITS; 
 
 A ( P A > P ) / 1 8 ; 
 
 nkme.sout; 
 
 lace. pmesput + i by "no fntrlfs"; 
 
 TEt^ESPUT 
 
 o; 
 
 LF T < N DO 
 
 IN 
 
 blankmesopt; 
 
 p «■ pmesoht+i; 
 
 NOL <- 0; 
 
 ^HILE NPL<NPL AND T<M DO 
 
 BEGIN 
 
 REPLACE PJP PY PA+lBxT FPR 18," "; 
 
 NOL «- NPL + i; 
 
 T * T + ll -f 
 
 ENDI 
 WRITEWESOUT 
 
 FNP 
 ENP 
 END DUHPENTRY. 
 
 PROCEDURE pL'MPBlGTABCN, INDENT); VALUF N»U'DENTJ INTEGER N*INDENT; 
 BEGIN 
 
 hteger i#j) 
 blankk'FSput; 
 
 RpPLAcE PMESOUT + C T«^'IN(5x!NDENTM00)> PY »*= = > BIGTAB "; 
 N FOR 4 DIGITS* 
 " ID = "j> POINTFRC J>0PDCPIGT/*P,N+1>SALL)) 
 
 fpr min($0pd(bigtaf*n»tdlfngth)m12-i); 
 writemfsout; 
 i «- 1*5; 
 if boole an($opdcblgtab*n>isden ned)) 
 
 THEN 
 BEGIN 
 
 plankmfsput; 
 
 pfplace pmesput + i by " i sdff i ned"; 
 
 00306500 
 00306600 
 00308700 
 00306600 
 00306900 
 00309000 
 00309100 
 00309200 
 00309300 
 00309400 
 00309500 
 00309600 
 00309700 
 00309600 
 00309900 
 00310000 
 00310100 
 00310200 
 00310300 
 00310400 
 00310500 
 00310600 
 00310700 
 00310600 
 00310900 
 00311000 
 00311100 
 00311200 
 00311300 
 00311400 
 00311500 
 00311600 
 00311700 
 00311800 
 00311900 
 00312000 
 00312100 
 00312200 
 00312300 
 00312400 
 00312500 
 00312600 
 00312700 
 00312600 
 00312900 
 00313000 
 00313100 
 00313200 
 00313300 
 0031 3<t00 
 0031 3500 
 00313600 
 00313700 
 00313600 
 00313900 
 00314000 
 00314100 
 00314200 
 00314300 
 003l4«00 
 00314500 
 
196 
 
 writemesout 
 
 end; 
 
 IF t ) CinLEANJ($OPD(BlGTAP/N»ISPElNGDEFlNFr)) 
 
 THFN 
 
 BEGIN 
 
 BLANKMf SHUT; 
 
 REPLACE PMFSCUT+I BY " I SBf I NGOf F I Nf D" J 
 
 WRITEMESDUT 
 ENPJ 
 IF BnrLEAN(SOPD(BiGTAB#N»FORWAPDDEFlNEn)) 
 
 THFN 
 BFGIN 
 
 pl ankmesout; 
 
 RFPLACE PMFSOUT+I BY "FORwARDDEFINeD*; 
 WRITEMESOUT 
 
 END 
 
 if (j «• s0pd(pigtap*n*idstackptr)) # 
 then 
 
 BFGIN 
 
 plankmesout; 
 
 rfplace pmfstut + i by " idstackptrs", j for 4 digits; 
 
 writemesout 
 
 END J 
 END DUHPBIGTAB; 
 
 PRICE 
 VALUE 
 BOOLE 
 
 INTEG 
 BEGIN 
 
 DljRt' DUMPTAb( ID*EMTRY'TRACEPARM*TRACESFM#IN0ENT»TRACEBIG)J 
 
 jP»FNTRY*THACePARM#TRACFSF^»INDeNT/TPACEBIG; 
 
 AN 
 
 EP 
 
 ID, 
 
 traceparm* 
 
 tracfsem, 
 
 tracebig; 
 
 ENTRY, 
 INDENT? 
 
 2 TRUE IF IDSTACK - OTHFPWISE STRUCTURETAB 
 
 * TRUE IF FOPMAlS AMD SUPSTRUCT TO PE DUMPED 
 
 * TRUE IF PLnsEMFlELD TO BE TRACED 
 % TRUE IF PIGTAR TO PE PUMPED 
 
 % WHICH FNTPY TO DUMP , 
 
 % I FVEL OF RECURSION 
 
 INTEGER 
 LAPEL AW 
 IF ENTRY 
 IF ID TH 
 EL 
 
 NS 
 SP 
 NP 
 PP 
 IP 
 
 *OP 
 SOP 
 SOP 
 SOP 
 SOP 
 
 J <- MIN( 
 
 Bt «■ ?P p 
 DUMf-ENTR 
 IF TRACE 
 IF TRACE 
 THFN 
 BEGIN 
 
 IF 
 
 THF 
 
 PEG 
 
 I>J,NS*SP>NP»PP*IP'PT; 
 
 ay; 
 
 s THEN GO AWAY; 
 EN SENTER( IDE NTRY^SALL OF (IDSTACK, ENTRY)) 
 SE iENTERC I P ENTRY »SALLnF(STRUCTURETAB# ENTRY)); 
 D(IDEMTRY*NUMBRSUPSTRUCT); 
 
 dcidentry^structureptr); 
 D(Identry,numbrofparmS); 
 d(Identry>formalparmptr); 
 D(identry,idstackptr); 
 
 5xlNDENT>95)+5; 
 
 d(Identry,bigtabptr); 
 
 y(Id»fntry#indent); 
 
 pig thfn dumpbigtab(bt»indent+1)j 
 
 PARH 
 
 NS 
 
 N 
 
 IN 
 
 t 
 
 blankmesout; 
 replace pk'espi't + j ry 
 
 "tttttttt SUBSTRUCTURES 
 
 writemesout; 
 
 for i «■ 1 step 1 until ns do 
 
 ########••; 
 
 00314600 
 
 00314700 
 
 00314600 
 
 00314900 
 
 00315000 
 
 00315100 
 
 00315200 
 
 00315300 
 
 00315400 
 
 00315500 
 
 00315600 
 
 00315700 
 
 00315800 
 
 00-315900 
 
 00316000 
 
 00316100 
 
 00316200 
 
 00316300 
 
 00316400 
 
 00316500 
 
 00316600 
 
 00316700 
 
 00316800 
 
 00316900 
 
 00317000 
 
 00317100 
 
 00317200 
 
 00317300 
 
 00317400 
 
 00317500 
 
 00317600 
 
 00317700 
 
 003l7bOO 
 
 00317900 
 
 00318000 
 
 00318100 
 
 00318200 
 
 00318300 
 
 00316400 
 
 00316500 
 
 00316600 
 
 00316700 
 
 00318800 
 
 00318900 
 
 00319000 
 
 00319100 
 
 00319200 
 
 00319300 
 
 00319400 
 
 00319500 
 
 00319600 
 
 00319700 
 
 00319600 
 
 00319900 
 
 00320000 
 
 00320100 
 
 00320200 
 
 00320300 
 
 00320400 
 
 00320500 
 
 00320600 
 
197 
 
 END; 
 IF N 
 THEN 
 pEGI 
 
 END 
 IF 1 
 THEN 
 BFG1 
 
 fnd; 
 
 TRACE 
 RACES 
 
 N 
 
 DUMPTABCFALSE/SP-M-I* 
 
 TPACEPARM#TRACESEMMNDENT*1# TRACES IG) 
 
 P / 
 
 N 
 BLANKMESOUTI 
 REPLACE PMFSOUT+J BY 
 
 '•*>#### FORMAL PARAMETERS ######"! 
 WRITEMESOUT) 
 
 FOR I * 1 STEP 1 UNTIL NP DO 
 DUMPTAB(FALSF#PP+1-I» 
 
 TRACEPARM#TRACESEH>INrENT+l#TRACFPlG) 
 
 PARMI 
 
 EM AND IP*0 
 
 END 
 
 BLANKMESnUTI 
 
 rfplace pmfsput+j by 
 
 "######### up level id #**######"; 
 
 writemesoutj 
 
 dumptab(tpue,ip,tracfparm,tracfsem,lndfnt+l ,tracebig> 
 tracesem; 
 
 AWAYt 
 
 END DUMPTAPJ 
 
 PROCEDURE DUMPMSTACK(N); VALUE Nl INTEGER Nl 
 BEGIN 
 
 POINTFR P; 
 
 integer ii 
 
 definf comma=tf p*pmes0ut*5 thfn replacf p«p by "> "#l 
 
 blankmesout; 
 
 replace pmesout by ""*> mstack "» n ftp 4 digitsl 
 
 writfmesout; 
 blankmesout; 
 p «- pmes0ut + 5i 
 
 IF BOOlEAN(£OPD(MsTACK*N#NODF)) 
 
 THEN REPLACE PtP PY "NODE") 
 
 IF BOpLEAN(SOPD( MSTACK' NjPROCEDUREPTRIS I NTOIDSTACK)) 
 
 THEN 
 
 BEGIN 
 
 COMMA! 
 
 replace plp by "procfdureptrisintojdstack" 
 end; 
 if (i «■ *opd(mstack»n#procedurfptr)) * 
 
 THEN 
 BEGIN 
 
 COMMA) 
 
 rfplace ptp by "procfdureptr*", j for 4 digits 
 end; 
 if (i «■ *opd(mstack'n#entry)) # 
 
 THEN 
 BEGIN 
 
 comma; 
 
 rfplace ptp py w entry="#i for 4 digits) 
 end; 
 
 IF (I «■ SOPD(MSTACK»N#STRUCTtlREPTR)) i 
 THEN 
 
 00320700 
 00320800 
 00320900 
 00321000 
 00321100 
 00321200 
 00321300 
 00321400 
 00321500 
 00321600 
 00321700 
 00321600 
 00321900 
 00322000 
 00322100 
 00322200 
 00322300 
 00322400 
 00322500 
 00322600 
 00322700 
 00322600 
 00322900 
 00323000 
 00323100 
 00323200 
 00323300 
 00323400 
 00323500 
 00323600 
 00323700 
 00323600 
 00323900 
 00324000 
 00324100 
 00324200 
 00324300 
 00324400 
 00324500 
 00324600 
 00324700 
 00324800 
 00324900 
 00325000 
 00325100 
 00325200 
 00325300 
 00325400 
 00325500 
 00325600 
 00325700 
 00325600 
 00325900 
 00326Q00 
 00326100 
 00326200 
 00326300 
 00326400 
 00326500 
 00326600 
 00326700 
 
198 
 
 begin oo326eoo 
 
 COMMA) 00326900 
 
 REPLACE PlP BY "STPUCTUREPTRe", I FOR 4 DIGITS! 00327000 
 
 END) 00327100 
 
 IF (I ♦ *OPD(MSTACK»N*Nl)MBRSUBSTRUCT)) * 00327200 
 
 THEN 00327300 
 
 BEGIN 00327400 
 
 COMMA) • 00327500 
 
 replace plp py "numbrsubstructs", i for 3 digits 00327600 
 end; • 00327700 
 
 hRlTEMESOUT; 00327600 
 
 END DUMPMSTACK; 00327900 
 
 00328000 
 
 00326100 
 
 00326200 
 
 PROCEDURE PRINTSTACkCA,B); VALUE B* ALPHA ARRAY AtOj; INTEGER B; 00326300 
 
 BEGIN 00326000 
 
 integer i; 00326500 
 
 format f(x10#t10); 00326600 
 
 fop i ♦ 6-1 step -1 until 00 00326700 
 
 write(linf>f#a(i])j 00326600 
 
 END; 00326900 
 
 00329000 
 
 00329100 
 
 00329200 
 
 PROCEDURE PRINTBSTACK(A#P);VALUE B^OOLEAN ARRAY AIOIMNTEGER B; 00329300 
 
 BEGIN 00329000 
 
 integer i; 00329500 
 
 format f(x15,l5); 00329600 
 
 fdr i *■ b-l step -1 until do 00329700 
 
 WRlTE(LINE>F>Atl3); 00329600 
 
 END; 00329900 
 
 00330000 
 
 , 00330100 
 
 00330200 
 
 BOOLEAN PROCEDURE LANGUAr,ECONTPOLCARD( PARM) ; 00330300 
 
 VALUE PARM; ALPHA PARMl ., 00330400 
 
 COMMENT ThIS PROCEDURE IS TRUE If AN 0SL2 CONTROL CARD IS 00330500 
 
 BEING SCANNED. GTHERWISF IT IS FALSE. THE LEGITIMATE 0SL2 CONTROL00330600 
 
 CARDS ARE AS FOLLOWSI 00330700 
 
 PDUMP UDSTACK/STRUCTURFTAR] [ TP ACFf t PARM/SEM/P IGTAB J *& 3 3&00 3 30ftOO 
 
 tALL/N/TOP N3 00330900 
 
 idstack or structuretab is dumped, 00331000 
 
 if trace is not presfnt* then only the 00331100 
 
 inpkated fntrifs are dumped. 00331200 
 
 if trace is on' then the trace parameters 00331300 
 
 causf a tracf on the indkatfd pointers 00331000 
 
 parm => stpuctureptr & formal parmptr 00331500 
 
 sem => old semfield 00331600 
 
 bigtab => pigtapptr 00331700 
 
 if no trace parameter is entfred* then all 00331600 
 
 are assumed. 00331900 
 
 one can dump all of the entries in a 00332000 
 
 stack or just entry n or the top n entries. 00332100 
 
 mstack [top n/tpace r p i gt a b/p arm/sfm/ all 3] 00332200 
 
 THF TOP N ELEMENTS OF MSTACK ARF OliflPFD 00332300 
 
 OR THE TOP ELEMFNT IS DUMPED KITH A TRACE 00332400 
 
 INTO JUST PIGTAP OR IF PARM OR SEM OR ALL 00332500 
 
 ARE SPECIFIED/ THEN THE TRACE CONTINUES INTO 00332600 
 
 IDSTACK OR STRUCTURETAP WITH THF INDICATED 00332700 
 
 TRACF PARAMETERS. NOTE THAT THF USE OF 00332800 
 
199 
 
 BIGTAB HERF IS UNIQUE. THE ONLY WAY TO TURN 
 ON A BIGTAP TRACF PARAMFTER WHEN A TRACE 
 PRrcFFDS INTO IPSTACK DR STRUCTURET Ap IS TO 
 USE THE TRACF PARAMETER ALL WHICH TURNS ON 
 ALL OF THE TRACF PARAMETERS. 
 
 IDCOUNTERSTACK 
 
 STRUKTUPEPARMSTACK 
 
 PROCFDUPEIDSTACK 
 
 SUBSCRIPTSTACK 
 
 ACTUALPARMSTACK 
 
 FORMALSWITCHSTACK 
 
 STATUS 
 
 BEGIN 
 
 OPJFCT TURNS ON OBJECT PRINTING 
 NOOBjECT TURNS OFF OBJECT PRINTING 
 KILL DOES A DIVIDE BY 7EROJ 
 
 THIS DUMPS ALL OF THE 
 SINGLE VARIABLES IF THEY 
 ARE NON ZERO OR TRUE 
 
 OOLEAN 
 MTEGeP 
 ANGUAGE 
 
 F PARM 
 HFN I <■ 
 
 iD^TRACFPARM'TRACESEMi-TPACEPlG; 
 
 n»top>bottom; 
 contrhlcaro * true; 
 
 = "KILL " 
 
 I/O 
 PARM b "OPjFCT" THEN PRINTOBJECT «■ TRUE 
 PARM = "NpoBJE" THEN PRINTOBJECT <- FALSE 
 PARM="DUMP " 
 
 LSE IF 
 LSE IF 
 LSE IF 
 
 HFN 
 
 BEGIN 
 
 DEFINE PRINT = BL ANKMESOUTJ REPL ACF PMESOUT+5 BY t, 
 FIMISH(FINISH1 )=>" = •% 
 
 FINISH1 FOR A DIGITS; WRI TEMFSOuTiC* 
 PR I NT I APELeBLANKMESOUTJ 
 
 REPLACE PMESOUT PY "s = s> *,$) 
 LABEL FANCY; 
 
 LANGUAGECON'TPOLCARD «• TRUf; 
 PARM ♦• CCSCANJ 
 IF PARM = "STATUS" 
 
 THEN -«• 
 
 BEGIN 
 
 printlapel "status"; 
 
 writemfsout; 
 
 if idcounter # 
 
 THEN 
 BEGIN 
 
 PRINT "IDCOUNTEP" 
 
 FINISH(IDCOUNTER) 
 
 end; 
 
 IF IDLISTCOUNTER * 
 
 THEN 
 
 BEGIN 
 
 print "idlistcounter" 
 
 finish(idlistcoiinter) 
 end; 
 if cuprfntdecltype * 
 
 THEN 
 BEGIN 
 
 print "currentdfcltype" 
 
 finishccurpentdfcltype) 
 end; 
 if cuprfntdfclown # 
 
 THEN 
 
 00332900 
 00333000 
 00333100 
 00333200 
 00333300 
 00333400 
 00333500 
 00333600 
 00333700 
 00333600 
 00333900 
 00334000 
 00334100 
 0033^200 
 00334300 
 00334400 
 00334500 
 00334600 
 00334700 
 00334600 
 00334900 
 00335000 
 00335100 
 00335200 
 00335300 
 00335400 
 00335500 
 00335600 
 00335700 
 00335600 
 00335900 
 00336000 
 00336100 
 00336200 
 00336300 
 00336400 
 00336500 
 00336600 
 00336700 
 00336600 
 00336900 
 00337000 
 00337100 
 00337200 
 00337300 
 00337400 
 00337500 
 00337600 
 00337700 
 00337600 
 00337900 
 00338000 
 00336100 
 0033&200 
 00336300 
 00336400 
 00336500 
 00336600 
 00336700 
 00336600 
 00338900 
 
200 
 
 BEGIN 00339000 
 
 PRINT "CURPENTDFCLOwr' 00339100 
 
 F INI SH (CURRfiNTDF CLOW h) 00 3392 00 
 
 END) 00339300 
 
 IF CURRFNTDECLNODF * 00339400 
 
 THEN 00339500 
 
 BEGIN 00339600 
 
 PRINT "CURPENTDFCLNODE" 00339700 
 
 FINISH(CURREMTDFCLNODE) 00 339600 
 
 END) . 00339900 
 
 IF CURRFNTDECLMACRO # 00340000 
 
 THEN 00340100 
 
 BEGIN 00340200 
 
 PRINT "CURPENTDrCLMACRO" 00340300 
 
 FINISHCCURRENTDFCLMACRO) 00340400 
 
 END) 00340500 
 
 If CURRENTNUMPROFSUBS # 00340600 
 
 THEN 00340700 
 
 BEGIN 00340600 
 
 PRINT "CURPEK'TNUMRROFSUPS" 00340900 
 
 FINlSH(CURRENTNuMFROFSUPS) 00 341000 
 
 END) 00341100 
 
 IF CURRFNTPR0CEDURE1D * 00341200 
 
 THEN 00341300 
 
 BEGIN 00341400 
 
 PRINT "CURRENTPROCEDl'REID" 00341500 
 
 FINISHCCURRENTPROCEDUREIP) 00341600 
 
 END) 00341700 
 
 IF CURRFNTEXPPESSIONTYPE t 00341600 
 
 THEN 00341900 
 
 BEGIN 00342000 
 
 PRINT "CllRRENTEyPRESSlONTYPE" 00342100 
 
 FINISHCCURREN'TEVPRESSIONTYPE) 00342200 
 
 END) , 00342300 
 
 IF CURRENTSTRUCTUREPTR * 00342400 
 
 THEN 00342500 
 
 BEGIN 00342600 
 
 PRINT M CURRENTST^UCTllREPTR M 00342700 
 
 FIMSH(CuRPENTSTRUCTuRfPTR) 00342600 
 
 END) 00342900 
 
 IF CURRENTNUMF-EROFSUPSTRUCTURFS * 00343000 
 
 THEN 00343100 
 
 BEGIN 00343200 
 
 PRINT *CURPENTNuMREROFSURSTRUCTllRES" 00343300 
 
 F I N I SH< CURRENT NUKBEROFSUP STRUCTURES) 0034 34 00 
 
 END) 00343500 
 
 IF CURRENTIDPTR * 00343600 
 
 THEN 00343700 
 
 BEGIN 00343600 
 
 PRINT "CURPFNTlDPTR" 00343900 
 
 FINlSH(CURRENTIDPTR) 00344000 
 
 END) 00344100 
 
 IF CURRENTFORHALPARAMETERLISTPOINTER * 0034^200 
 
 THEN 00344300 
 
 BEGIN 00344400 
 
 PRINT "CURPENTEPRMALPARAMETERLlSTPnlNTER" 0034*500 
 
 FINISH(CURRENTF'DRMALPARAKETERLISTPOINTEP) 00 34 4 6 00 
 
 END) 00344700 
 
 IF CURRFNTNUMpEROFFOPMALPARAMFTERS # 00344600 
 
 THEN 00344900 
 
 BEGIN 00345000 
 
201 
 
 PRINT "CURPEKTMiMBEROFFOPMALPARAMETEpS" 00345100 
 
 FIMSHCCURPEK'TM^BERnFFOPMALPARAMETEPS) 00 3<jb?P0 
 
 END; 00345300 
 
 IF CURRENTACTUALPARAMETERCOUNT * 00345400 
 
 THEN 003/15500 
 
 BEGIN 00345600 
 
 PRINT "CURRENTACTUALPARAMETEPCOUNT" 00345700 
 
 FIN I SH( CURRENT ACTUAL PARAMETERCOUNT) 00 34 5 600 
 
 END; 00345900 
 
 IF CURRENTMAXACCESSNUHBER * 00346000 
 
 THEN 00346100 
 
 BEGIN 00346200 
 
 PRINT "CURPENTMAXACCFSSNUMBEP" 00346300 
 
 FINISH (CURRENTS A XACCESSNL'MBER) 00 34 6 4 00 
 
 ENO) 00346500 
 
 IF CURRENTACCESSID # 00346600 
 
 THEN 00346700 
 
 BEGIN 00346600 
 
 PRINT "CURRENTACCESSID" 00346900 
 
 FINISH (CURRENT ACCESS ID) 00 34 7 000 
 
 END) 00347100 
 
 IF STRUCTURElSnwN 00347200 
 
 THEN 00347300 
 
 BEGIN 00347400 
 
 PR I NT "STRUCTURE I SOWN") 00 34 7 500 
 
 WRITFMESOUT 00347600 
 
 END) 00347700 
 
 IF SCANNINGFORMALPARAMETERDECLARATIONS 00347800 
 
 THEN 00347900 
 
 BEGIN 00346000 
 
 PRINT"SCANNINGFDPMALPARAMETERDECLARATI0NS W ; 00 34 6100 
 
 WRlTFMESDUT 00348200 
 
 END) 00348300 
 
 IF CURRFNTSTRUCTUREPTRISIMDSTACK * 00348400 
 
 THEN 00346500 
 
 BEGIN 00348600 
 
 PRINT"CURRFNTSTRUCTUREPTRIS1NIDSTACK"; 00346700 
 
 WRITFHESOUT 00346800 
 
 END; 00348900 
 
 END 00349000 
 
 ELSE IF PARM = "IDCOUN" 00349100 
 
 THEN 00349200 
 
 BEGIN 00349300 
 
 PRINTLApFL "IDCDUNTERSTACk"; 00349400 
 
 hRlTECESOUTJ 00349500 
 
 PR I NT STACK (lDCOUNTERSTACK#PTinCOUNTERSTACK) 0034 9600 
 
 FND 00349700 
 
 ELSE IF PARM = "STRUKT" 00349800 
 
 THEN 00349900 
 
 BEGIN 00350000 
 
 printlapel "structurfparmstack"; 00350100 
 
 write^esoi't; 00350200 
 printstack(structureparmstacki-ptstructureparmstack) 00350300 
 
 FND 00350400 
 
 ELSE IF PARM = "PROCED" 00350500 
 
 THFN 00350600 
 
 BEGIN 00350700 
 
 PRINTLAPFL "PROCEDURF I DST ACK"; 00350600 
 
 WRITEMESOUTJ 00350900 
 
 PRINTSTACK(PROCEDURElDSTACK/PTPROCFDliREIDSTACK) 00 35100 
 
 END 00351100 
 
202 
 
 FLSE IF PARM = "SUBSCR" 00351^00 
 
 THEN 00351300 
 
 BEGIN 00351400 
 
 PklNTLAPFL "SURSCP IPTST AC K "J 00351500 
 
 uritemfsout; 00351600 
 
 phintstack(supscriptstack*ptsubscriptstack) 00 351/0 
 
 FND 0035U*00 
 
 ELSE IF PARM = "ACTUAL" 00351900 
 
 THFN 00352000 
 
 PEGIN • 00352100 
 
 PRINTLAPEl "AfTUALPAPMSTACK") 00352200 
 
 WRiTrMESClUT; 00352300 
 
 PRINTSTACK(ACTUALPARWSTACK'PTACTUALPARM STACK) 00352 400 
 
 END 00352500 
 
 ELSE IF PARM = "FORMAL" 00352600 
 
 THEN 00352700 
 
 BEGIN 00352800 
 
 printlapel "fprmalswttchstackwj 00352900 
 
 writemesout; 00353000 
 phintpstackcfr-rmalswitchstack^ptformalswltchstack) 00 35 3100 
 
 FND 00353200 
 
 ELSE IF PARM = "IDSTAC" 00353300 
 
 THEN 00353400 
 
 PEGIN 00353500 
 
 ID «■ TRUE* 00353600 
 
 GO TO FANCY 00353700 
 
 END 00353600 
 
 ELSE IF PARM = "STRUCT" 00353900 
 
 THEN 00354000 
 
 PEGIN 00354100 
 
 ID «■ FALSE; 00354200 
 
 EANCYt PARM «- CCSCAN; 00354300 
 
 IF PARM = "TRACE " 00354400 
 
 THEN * 00354500 
 
 DO REGIN 00354600 
 
 PARM *■ CCSCAN; 00354700 
 
 IE PARM - "PARM '♦ ., 00354800 
 
 THEN 00354900 
 
 BEGIN 00355000 
 
 TRACEPARM «■ TRUE* 00355100 
 
 PARM + CCSCAN 00355200 
 
 END 00355300 
 
 ELSE IF PARM = "SEM " 00355400 
 
 THEN 00355500 
 
 BEGIN 00355600 
 
 TRACESEM ♦ TRUE; 00355700 
 
 PARM * CCSCAN 00355b00 
 
 END 00355900 
 
 ELSE IF PARM = "FIGTAB" 00356000 
 
 THFN 00356100 
 
 BEGIN 00356200 
 
 TPACEPIG <- TRUEj 00356300 
 
 PARM «- CCSCAN 00356400 
 
 FNp 00356500 
 
 ELSE TRACEPARM < TRACESEM «- TRACERIG * TRUE 00356600 
 
 FND UNTIL PARM * "»"J 00356700 
 
 IF PARM = "ALL " 00356800 
 
 THEN 00356900 
 
 PEGIN 00357000 
 
 TOP * IF ID THEN' PTIDSTACK-1 00357100 
 
 EL?F PTSTRUCTURFTAP-ll 00357200 
 
203 
 
 BOTTOM «■ 
 END 
 
 ELSE IF PARM = 
 THEM 
 BEGIN 
 
 TOP <■ IF 
 
 N <• CCSCA 
 BOTTOM «■ 
 END 
 
 ELSE TOP <- POT 
 FOR N «- TOP ST 
 DUMPTAB(IP>Ni>T 
 
 II 
 
 'TOP 
 
 id then ptidstack-1 
 
 flsf ptstructuretab-1j 
 n; 
 
 TOP+l-N) 
 
 TOM «■ PARMJ 
 
 FP -1 UNTIL BOTTOM DO 
 
 RACFPARM, TRACE SFM>0,TRACEBlG) 
 
 FND 
 FLSE 
 THFN 
 pEGI 
 
 IF PARM = "MSTACK" 
 
 N 
 
 IF (PARM * 
 
 THEN 
 
 BEGIN 
 
 DO 
 
 CCSCAN) = ♦•TRACE " 
 
 RFGIN 
 
 IF ( 
 
 THEN 
 
 FLSF 
 
 THEN 
 
 ELSE 
 
 THFN 
 
 END UNTIL 
 
 DUMPMSTAC 
 
 IF TRACER 
 
 THEN DUMP 
 
 END 
 
 ELSE IF PARM = 
 
 THEN 
 
 BEGIN 
 
 N «- CCSCA 
 BOTTOM «- 
 
 TOP <- PTM 
 FOR M «■ T 
 DUMPMSTAC 
 
 END 
 FND 
 ELSE 
 BEGIN 
 
 BLANKMESOUTJ 
 REPLACE PMFSOU 
 "THIS *DU 
 WRITEMESOUT 
 END) 
 
 IF CCSCAN = "j" THE 
 END UNTIL CCSCAN 4 *>" 
 ELSE LANGUAGECONTPOl CARD 
 END LANGUAgECONTROICARDJ 
 
 PARM «■ CCSCAN) s "ALL w 
 
 traceparm«-tracfsem<-tracebig«-true 
 
 IF PARM s "PARM " 
 TRACEPARM <- TRUE 
 IF PAPM = "SEM " 
 TRACESFM <r TRUFJ 
 (PARM «- CCSCAN) * ","J 
 K(PTMSTACK-1 )J 
 ARM OR TRACFSEM OR TRACEBIG 
 TAB(TRUE,SOPD(BIGTAP> 
 
 SPPD(M STACK, STOP* ENTRY 
 IDSTACKPTR), 
 TRACEPAPM*TPACFSFM/1*TRACEPI-G)I 
 
 "TOP " 
 
 Nl 
 
 MAX(PTMSTACK-N»0)J 
 
 STACK-1 J 
 
 OP STEP -1 UNTIL BOTTOM DO 
 
 K(N)j 
 
 T BY "s — > i CAN NOT UNDERSTAND M » 
 MP CARD. "J 
 
 N ID*LANC,UAGECPNTROLCARD("DUMP ")J 
 «■ FALSE 
 
 PPXCtDuFL 
 BEGIN 
 
 NOFORWARDMATCHJ 
 
 00 3 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 )*003 
 003 
 003 
 003 
 00 3 
 003 
 003 
 003 
 003 
 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 003 
 004 
 004 
 004 
 004 
 004 
 
 57300 
 57400 
 57500 
 57600 
 57700 
 57600 
 57900 
 5&000 
 56100 
 56200 
 56300 
 56400 
 56500 
 56600 
 56700 
 56600 
 56900 
 59000 
 59100 
 59200 
 59300 
 59400 
 59500 
 59600 
 59700 
 59600 
 59900 
 60000 
 60100 
 60200 
 60300 
 60400 
 60500 
 60600 
 60700 
 60600 
 60900 
 61000 
 61100 
 61200 
 61300 
 61400 
 61500 
 61600 
 61700 
 61600 
 61900 
 62000 
 62100 
 62200 
 62300 
 62400 
 62500 
 62600 
 62700 
 62600 
 00100 
 00200 
 00300 
 00«00 
 00500 
 
201+ 
 
 erpms "this procedure hf aping does not match the forward "> 
 
 "declaration of itself. "i 
 writemesout; 
 end nofprwapdmatch; 
 
 BOOLEAN PROCEDURE FoUALSTRUCTUPETABf A*B); INTEGER A>p; 
 
 COMNFNT THIS PROCEDURE CHECKS THAT THE PATA TYPfS AT AiB IN 
 
 struc.tiipetab have the same specification and substructure 
 
 specification; 
 
 if a = then fqualstructurftap <- p = 
 
 ELSE IF b = THEN EOUALSTPUC TllRFT AR «■ FALSE 
 
 else eoualstructuretab «• 
 
 sopd(structurftab,a,$all 0) = sopd c structurft ar , b , sall 0) 
 and Ecu als truc turf tab csopd ( structure t a p,a» st ructureptR), 
 
 SOPD (StRUCTURFT A R,B, STRUC TUREPTR)) 
 AND EeU*LSTRUCTURETAB(*OPD( STRUCTURFT AP# A* FPPM ALP ARMPTR)# 
 
 SOPn(STRuCTURETAP#B#FPPMALPARMPTR))J 
 
 BOOLEAN PROCEDURE FQUAl IPSTACK C A#B > J INTEGFR A*B; 
 
 COMMFNT THIS PROCEDURE CHECKS IF THE GOflDlES AT A « P IN 
 IDSTACK HA\/E THE SAMF SPECIFICATION AND SUPSPEC I F I C AT I ON INSOFAR 
 AS DATA TYPE IS CONCERNEPI 
 
 EOUALIDSTACK * $0P0( I DSTACK » A » S ALL 0>=S0F D( TPST ACK >P» SAL L 0) 
 AND EQUALSTRUCTURETAP($OPP(IDSTACK#A,STPUCTUREpTR)> 
 
 SOPD(IDSTACK^B»STRUCTUREPTR)) 
 AND E©UALSTRUCTURETAP($OPP(IDSTACK,A,FPRMALPARMPTR), 
 
 SOPP(IDSTACK,B#FPPMALPARNPTR))J 
 
 boolean procedure equal idstruct ( a, b 5 j integer a»p; 
 
 commfnt this procedure checks that the guy a in idstack is the 
 same type as b in structuretari 
 
 egualidstruct «■ sppdc idstack , a , sall ) = sopd( s*ructurftar,b> sall 0) 
 and eoualstructuretap(sopd( idstack* a * structureptr )t 
 
 scpd ( struc turf tar*b> st ruc turf ptr)) 
 anp eoualstructurftab(sopd(idstackf a > formalp armptr ) * 
 
 sopd (struc turf tap* b> formal parmptr )) ; 
 
 BOOLEAN PROCEDURE TFSTTYPE ( TYPE ) I VALUE TYPF) INTEGFR TYPE; 
 
 COMMENT THIS PROCEDURE CHECKS IF THE TYPE OF THF ID IN MSTACK 
 IS THE SAME AS THE "TYPE" IN THE FORMAL PARAMETER LIST; 
 BEGIN LAPFL ERUDECPPP) 
 
 DEFINE RETURN(RETUPM) = 
 BEGIN 
 
 TESTTYPE ♦ RFTURNi; 
 GO TO FRUDFCORP 
 END t\ 
 
 If currentstructupeptr r o 
 
 then 
 
 begin 
 
 senter(mstack#*top*nodftsopd(ipstack#sopd(pigtab# 
 
 sopd(mstack*stop > entry )# 
 idstackptp) »node)); 
 
 IF ( TESTTYPE «■ 
 
 00400600 
 00400700 
 00400600 
 00400900 
 00401000 
 
 ooaoiioo 
 
 00401200 
 00401300 
 00401400 
 00401500 
 00401&00 
 00401700 
 00401600 
 00401900 
 00402000 
 00402100 
 004022C0 
 00402300 
 00402400 
 00402500 
 00402600 
 00402700 
 00402800 
 00402900 
 00403000 
 00403100 
 00403200 
 00403300 
 00403400 
 00403500 
 00403600 
 00403700 
 00403600 
 00403900 
 00404&00 
 00404100 
 00404200 
 00404300 
 00404400 
 00404500 
 00404600 
 00404700 
 00404600 
 00404900 
 00405000 
 00405100 
 00405200 
 00405300 
 00405400 
 00405500 
 00405600 
 00405700 
 00405600 
 00405900 
 00406000 
 00406100 
 00406200 
 00406300 
 00406400 
 00406500 
 00406600 
 
205 
 
 SOPDC 
 AND ( 
 
 THEN COUPL 
 SUPDC 
 
 SOPD( 
 PRINT 
 
 END 
 
 ELSE 
 
 BEGIN 
 
 loop* 
 
 LAPEL LOOP 
 INTEGER It 
 
 IDST ACK* SOPDC BlGTAB, SOPDC MSTACK, STOP* ENTRY)* 
 
 IDSTACKPTR)*TYPE) = TYPE ) 
 TYPE = STRUCT OR 
 SOPDC IDSTACK* 
 
 SOPDC PIG TAP* SOPDC MS TACK* STOP GENTRY)* 
 IDSTACKPTR)>NUMPROFSUBS) > ) 
 ECNAME-CALL"* 
 
 lDSTACK*I«-SOPDCRIGTAP*SnPD(MSTACK* 
 STOP* ENTRY )>TDSTACKPTR)> I EVEL)* 
 IDSTACK*I*DISPLACEMENT)* 
 ID)J 
 
 BEGIN 
 
 FOR I 
 DO PE 
 
 end; 
 
 END) 
 
 ERRMS 
 
 WRITE 
 
 RETUR 
 
 LOOPJ 
 
 CURRENTIDP 
 
 IE TESTTYP 
 
 THEN 
 
 BEGIN 
 
 OPERE 
 "INTE 
 1-1 F 
 OPERL 
 OPERF 
 "MAKE 
 PRINT 
 OPERL 
 
 <- 1 STEP 1 UNTIL CURREN7NUMPER0FSUBSTRUCTURES 
 GIN 
 IE SPPDCSTRUCTURETAB, 
 
 CURRENT STRUCTURFPTR+1 -I* 
 
 pigtarptr) = 
 sppdcmstack* stop* entry) 
 then leave loop 
 
 "this 10 is not part of this structure.") 
 mesout; 
 
 NCTRUE)) 
 
 TR «• CURREMTSTRUCTUREPTR + 1-I J 
 
 E «- S0PDCSTRUCTURETAP»CURRENTIDPTR*TYPE)»TYPE 
 
 IRSTPART* 
 
 r.EP-LITERAL-CALL 
 
 OR 3 DIGITS) 
 
 ASTPARTl 
 
 IRSTPART* 
 
 -INDEX "* 
 
 ID; 
 
 astpart; 
 
 end; 
 
 end; 
 erudecorpi 
 
 END ; 
 
 INTEGER FRPCFDURE FI NDSUeSTRUCTUREl DC Bl GTApPTR ) i 
 
 value pigtfibptr; intfger pigtarptr; 
 
 comment this procedure uses thf current values of 
 currentstructureptr anp curpentnumberofsubstpuctures to ftnd 
 an entry in structurftar that has the same td as that which 
 is at pigtafptr in pigtap. if no entry is found* then the 
 
 VALUE OF FlN'DSUBSTRUCTiiREID IS ZERO CO)) 
 BEGIN LABEL FRUOECORP; 
 
 DEFINE RETURNCRETUPN1 ) r 
 BEGIN 
 
 EINDSUPSTRUCTUREIP * RETURNl; 
 GO TO FRUDFCORP 
 END #1 
 
 00106700 
 00406600 
 00406810 
 00406620 
 00406630 
 00406840 
 00406900 
 00407000 
 00407100 
 00407200 
 00407300 
 00407400 
 00407500 
 00407600 
 00407700 
 00407600 
 00407900 
 004Q6000 
 00406100 
 00408200 
 00408300 
 00406400 
 00406500 
 00408600 
 00408700 
 00406600 
 00406900 
 00409000 
 00409100 
 00409200 
 00409300 
 00409400 
 00409500 
 00409600 
 0O409700 
 00409800 
 00409900 
 00410000 
 00410100 
 00410200 
 00410300 
 00410400 
 00410500 
 00410600 
 00410700 
 00410800 
 00410900 
 004H000 
 00411100 
 00411200 
 00411300 
 0041 1400 
 00411500 
 00411600 
 00411700 
 004H«00 
 00411900 
 00412000 
 00412100 
 00412200 
 00412300 
 
206 
 
 1NTEGFR 
 FOR I «■ 
 BFGIN 
 
 IF 
 
 II 
 
 1 STFP 
 
 1 UNTIL CURRENTNUMBEPOFSUBSTRUCTURES DO 
 
 $opd(structuretab» 
 
 currfntstructurePtr+i-i» 
 bigtabptr) • rtgtaeptr 
 thfn return (cupre nt structureptr+i-i) 
 
 END 
 I ERUDECORPI END J 
 
 BOOLEAN PROCEDURE FUNCT I PNTEST( TYPE 5 I 
 
 VALUE TYPFI INTEGER TYPf» 
 
 COMMENT THIS PRPCEpijRE CHECKS IF THE FUNCTION ON THE 
 
 TOP OF NSTACK IS OF THF SPECIFIED TyPFI 
 
 FUNCTIONTEST <- 
 
 (IF BOOLFAN(SPPD(MSTACK#STOP*PROCEDUREPTRISINTPlDSTACK)) 
 THFN SOP DC IOSTACK,*npD(MSTACK* JTnP#PROCFDURFPTP)#TvpF) 
 ELSE $OPD(STRUCTUPETAB,tOPD(MSTACK,$TOP,PRPCFDUREPTR)#TYPF)) 
 = TYPE* 
 
 BOOLEAN PROCEDURE PFFSF TFQUAL ( A> LA> P) I 
 VALUE A>LA,P> INTFGFR A»IA*B> 
 
 CONSENT THIS PROCEDURE DOES AN ECUALSTRUCTuRFT AB WHERE A ANQ 
 LA POINT Tp THF A VECTOR AND DESCRIBE ITS LFNGTH. B IS AS IN 
 EOLALSTPUCTURETAb; 
 BEGIN LABEL ERUDECORPI 
 
 DEFINE RETLiPN(RETUPM ) « 
 BEGIN 
 
 OFFSETFOUAL ♦ RETnPNlj 
 GO TO FRUOECORP 
 END ti 
 
 integfr i'p) 
 
 p «• $opd(structuretap*b»structlireptp); 
 
 if la / sopu(structurftap*b#numfrsupstruct) 
 
 then begin 
 
 return(false) 
 end else regin 
 
 for i <- 1 stfp 1 until la co 
 
 IF NOT EOUALSTFUCTl'RETAR(A + l-I>P + l-I) 
 THEN BEGIN RETURN( F ALSE ) FND 
 ENPI 
 
 rfturn(truf) 
 
 I ERUDECORp: END ; 
 
 PROCEDURE TESTFPTYPE(TYPF)! VALUF TYPE! INTFGER TYPFI 
 
 COMMENT THIS PROriPUPF PRINTS AN FPROP M^SSAGF IF THE NEXT 
 <AL PARA^FTFP IN A pRPCEDURF POLS NOT HAVF TYPF "TYPE"! 
 :UBPENTACTUALPAPAMETERC0UNT i CURRENTNUMPE ROFFORMALPAR A METERS 
 
 FORM 
 IF C 
 THEN 
 BEGI 
 
 N 
 
 END 
 ELSF 
 
 OF ACTUAL PARAMETERS EXCFFDS NUMBFR ALLOWED," I 
 FALSF 
 
 If *opd(structuretap»currentformalparamfterlistpointfr - 
 
 ERPMS *numper 
 *ritemesout; 
 semantictest «■ 
 
 001 
 
 004 
 
 004 
 
 004 
 
 004: 
 
 004; 
 
 004: 
 
 004 
 004 
 004 
 004' 
 
 004: 
 004: 
 004: 
 004: 
 
 004 
 004 
 004 
 
 004: 
 
 004' 
 
 004 
 
 004 
 
 004 
 
 004 
 
 004: 
 004: 
 004: 
 004: 
 004: 
 004: 
 004: 
 004: 
 004: 
 
 004 
 
 004: 
 
 004 
 
 004: 
 004: 
 004: 
 004: 
 004: 
 004: 
 004: 
 004: 
 004: 
 004: 
 004: 
 004: 
 004: 
 004: 
 004: 
 
 004 
 
 004: 
 
 004 
 004 
 004 
 004 
 004 
 004 
 004 
 004 
 
207 
 
 CURRFNTACTUALPARAMETERCOUNT»TYPE)*TYPE 004 18500 
 
 THEN' SFMANTKTFST ♦ FALSF 00418600 
 
 ELSF SFMANTlCTLST *■ TRl'EJ 00418700 
 
 00418800 
 
 00418900 
 
 00419000 
 
 PROCEDURE TESTACCESSTYPF(TYPE)) VALl'F TYPE! INTEGER TYPE) 00419100 
 
 COMMENT THIS PRnCEDUPF TESTS THf TYPf OF THE ACCESS VARjABLf 00419200 
 
 ON THE TOP PF MSTACK. IF IT IS FOLLOWED BY AN ARROW* IT IS TESTED 00419300 
 
 FOR A STORE TYPE) . 00419400 
 
 DRDP 00419500 
 
 GETLKSYM(I); 00419600 
 
 IF *OPD(MSTACIOSTPP+1#P$YM) s "t" 00419700 
 
 OR $nPPCMSTACK,STOP + i>PSYM) = "«•" 004l9p00 
 
 THEN SEMAMICTEST <• TYPE * 00419900 
 
 SOPDC I DsTACK,J>PPD(PIGTAB>JOPD(M STACK* STOP* ENTRY)* 00420000 
 
 IDSTACKPTP)*STORETYPF) 004?0l00 
 
 ElSE SFMAKTICTEST «■ TYPE * 00420200 
 
 SOPD( IDSTAC K/ ?rPDCRlGTAR*SOPD( MSTACK, STOP *ENTRY)* 004 20 300 
 
 IDSTACKPTR)*FETCHTYPE); 004?0400 
 
 END TESTACCESSTYPE) 00420500 
 
 00500100 
 
 00500200 
 
 00500300 
 
 5ACTI0N(0)« 00500400 
 
 DRCP 00500500 
 
 PMESOUT * POlNTER(MES0UTfO])j 00500600 
 
 PTIPSTACK <- 1 ; 00500700 
 
 PTSTRUCTURFTAR <- 1) 00500600 
 
 CURRENTSEGMENT <- CURPEKTLEVEL ♦ -II 00500900 
 
 ENDJ 00501000 
 
 &ACTlON(ACcFSSpOOLEAN)t 00501100 
 
 TESTACCFSSTYPECBOOL); 0050H10 
 
 JACTIONCACCESSCODE): 00501200 
 
 FACTION (ACCFSSDFCLARATTON)J 00501300 
 
 COMMFNT THIS ACTION SETS UP AN ACCESS DECLARATION SCAN, 00501400 
 
 CURRENTPEClTYPE IS SET UP AND CURRENT ACCESSIJ) IS SET TO FOlNT TO 00501500 
 
 THE DECLARATION OF THE ACCESS TYPE TN IDSTACM 00501600 
 
 DRDP 00501700 
 
 CURRENTDECLTYPE ♦• ACCESSVARJ 00501800 
 
 CURRENTACCFSSID *■ *OPD(RlGTAp,$OPDCMSTACK#$TPP»ENTRY)#IDSTAcKPTR); 00501900 
 
 END) 00502000 
 
 iACTlON(ACCFSSFH-E)i 00502100 
 
 »ACTlON(ACCFSSiPFNTIFIFP)l 00502200 
 
 CUMMFNT THIS ACTION FK'TERS THE TD INTO TDSTACK AND SETS UP FOR 00502300 
 
 AN ACCESS DEFINITION. K THE ID IS IN USE IN THIS PLOCK* AN ERROR 00502400 
 
 MESSAGE IS PRINTED) 00502500 
 
 DROP 00502600 
 
 CURRENTDECLTYPE <• ACCESS? 00502700 
 
 JEXECCENTFRIPINDECL STACKS 00502 600 
 
 $ENTER( IDS TACK, $ TOP, STRUCTPTR8EF ORE tPTSTRUCTl'RETAP, 00502 900 
 
 ACCESSTYFEt 00503000 
 
 (CUPRFNTMAyACCESSNUMBER «■ 00503100 
 
 CURRENTMAyACCESSNUVBER+1))) 0050 3200 
 
 »PUSHCPR0CFPURFIDSTACK>CURRFNTPR0CEDUREIP)| 0050 3300 
 
 CUKRENTPROCFPUREID * PTIPSTACK-IJ 00503400 
 
 $EXEC( SCAN SUP STRUCTURE); 00503500 
 
 END) 00503600 
 
 WCTIONCACCFSSlNTEGER)! 0050 3700 
 
 TESTACCFSSTYPECINT)J 00503710 
 
 SACTIOMACCFSSPATTERN)! 0050 37 ?0 
 
208 
 
 TESTACCFSSTYPE(PATT)* 
 iACTlOMACCFSSFOlNTFfOl 
 
 TESTACCESSTYPE(PTR)! 
 $ACTlON(ACCFSSPP0CESS)J 
 $ACTlONCACCFSSSTRUCTURF)l 
 
 testaccfsstype(struct); 
 $acti0k(accfsstring)» 
 testaccfsstvpf(Str); 
 
 tACTlONCADDANHTHFRSUb SCRIPT) I 
 
 SIKChCcl'RPF^TNUMtpnFSUPS); 
 iACTlON(bDDLEANDFCLAKATTON) j 
 
 commfnt this action sets curpentcecltypf = bool to indicate 
 that a poolfan declaration is peing scanned f 
 currentdecltypf <- pool; 
 
 $ACTlON(bOOLEANPROCEDURE)l 
 DRIP 
 SEKANTICIEST «- (IF CURPFNTSTRUCTUREpTR = 
 
 THEN $flPPUDSTACK#CURRFNTPRpCEDliRElD#TYPE) 
 ELSE f OPD ( ST RUC TURF TAB/ CURRENT I DPT R*TYPF)) 
 «= POOL I 
 FNDJ 
 JACTlONCbOOLEANSTORE) j 
 DROP 
 
 OPERATDPCSTORF-bOnLEAN'M; 
 END; 
 $ACTION(ChECI 
 COMMFl 
 IS ALLPWI 
 DROP 
 
 IE NOT J0PD(F0RMALSWITCHSTACK>ST0P-1) % CHK IF FORML PARM SCANTNG 
 THEN 
 EEGIN 
 
 EpPMS "A ","»», "FORMAL ,, #" ,, "> , ' SPECIFICATION IS ONLY ALLOWED ' 
 
 KFPRMAI ALLOWFD) t 
 
 NT THIS ACTION MAKES SURE THAT A FORMAL PROCEDURE PODY 
 .LDi 
 
 WRI 
 
 end; 
 
 end; 
 
 sactioncchec 
 
 COM ME 
 PROCEDliP 
 DRIP 
 
 I * $opd 
 
 IF SOPDC 
 
 THEN 
 
 BEGIN 
 
 ERP 
 ; ft 
 
 END 
 
 ELSE If 
 
 THEN 
 
 PEGIN 
 
 ERP 
 
 KR I 
 
 END 
 
 ELSE SOP 
 END) 
 SACTIONCCHFC 
 DROP 
 IF CURRE 
 
 "AS A PROCEDURE BODY IF THE DECLARED PROCEDURE "» * 
 "IS A FORMAL PARAMETER OF ANOTHER PROCEDURE,"; 
 TEMESOUT 
 
 KFOPWARDOKI I 
 
 NT THIS ACTION CHECKS TO MAkE SURE THAT A FORWARD 
 
 E PODY IS ALLO^FP; 
 
 ( IpSTACK>CUPRENTPROCFDURFID,PIGTABPTR)J 
 BIGTAB/I^FORWAPDDEFINFD) = 1 
 
 MS "HEY DUMMY - ONLY ONE FORWARD PER PROCEDURE IS ALLOWED. 
 RITEMESOUT 
 
 SCANMNGFORMALPAPAMETEPDFCLARATIONS 
 
 MS "FORWARD IS NHT AN ALLOWFD PROCEDURE BODY HERE. ONLY H 
 
 "FORMAL IS PERMITTED. "J 
 TEMESOUT 
 
 D(BIGTABM»F0RWARDDEF INED) «■ II 
 
 KIFNEXTFPISAPROCFDURE )« 
 
 NTACTUALPARAMETERCOUNT > CUPRFNTNUMPEROFFPRM ALP AR AMETFRS 
 
 00503730 
 00503600 
 00503610 
 00503900 
 00504000 
 0050401 
 0050^100 
 00504110 
 00504200 
 00504300 
 00504400 
 00504500 
 00504600 
 00504700 
 00504600 
 O0504VO0 
 00505(;00 
 00505100 
 00505200 
 00505300 
 00505400 
 00505500 
 00505600 
 00505700 
 00505600 
 00505900 
 00506000 
 00506100 
 00506200 
 00506300 
 
 00506400 
 00506500 
 
 >00506600 
 00506700 
 00506600 
 00506900 
 00507000 
 00507100 
 00507200 
 00507300 
 00507400 
 00507500 
 00507600 
 00507700 
 00507600 
 00507900 
 
 "00506000 
 00506100 
 00506200 
 00508300 
 00508400 
 00506500 
 
 >00508600 
 00506700 
 00508600 
 00506900 
 00509000 
 00509100 
 00509200 
 00509300 
 00509400 
 
209 
 
 THEN 00509500 
 
 BEGIN 00509600 
 
 ERRMS "NUMBER OF ACTUAL PARAMETERS EXCEEDS NUMPFR ALLOWED." J 00509/00 
 
 KRITEMESOUT; 00509800 
 
 SEMANTKTEST «- TRUE! 00509900 
 
 END 005: 
 
 ELSE 005: 
 
 IF ROOIFAN(SOPDCSTRUCTURFTAP,CURRENTFORMALPAPAMETERLISTPDINTFR - 005: 
 
 CURRFNTACTUALPARAMETERCOUNT>PROCEDURF)) 005: 
 
 THEN . 005: 
 
 BEGIN 005: 
 
 SEMANTKTEST «- TRuEl 005' 
 
 IF NOT (IF BUOLFAN(SOPD(MSTACK/STOP»PROCEDUPEPTRISINTOIDSTACK))005: 
 
 THEN EQUAL IDSTRUCT($OPDCMSTACK» JTOP^PRnCEDURFPTR)* 005: 
 
 CURRENT FORMAL PARAMETFRL I STPOINTER "005: 
 
 CURRENT A CTUAL PAR A METE RCOUNT) 005: 
 
 ELSE EOUAl STRUCTURE TAB (tOPLH MS TACK » STOP* PRUCEDUREPtPO* 005: 
 
 CURRENT FORM A I PARAMETFRLIST POINTER -005: 
 
 CURRENT AC TUALPARA ME TFRCDUNT)) 005: 
 
 THFN 005: 
 
 BEGIN 005: 
 
 errms "procedure id oofs mot match the procedure f0rmal"#005: 
 
 " parameter in the procedurf declaration."; 005: 
 
 writemesout 005: 
 
 end 005; 
 
 END 005: 
 
 ELSE SEMANTKTEST «■ FALSFJ 005: 
 
 END) 005: 
 
 kCT ION (CHECK I FNEXTFP IS ACCESS)* 005: 
 
 DROP 005: 
 
 IF CURrFNTACTUALPARAmETERCOUNT i CURRENTNUMPEROFFORMALPAPAMETEPS 005; 
 
 THEN 005: 
 
 BEGIN 005: 
 
 ERRMS "NUMBER OF ACTUAL PARAMETERS EXCFEDS NUMPER ALLOWED." i 005; 
 
 WRITEMESOUTj 005: 
 
 SEMANTKTEST <■ TRUE» 005; 
 
 END y 005: 
 
 ELSE 005: 
 
 SEMANTKTEST «■ FALSE) 005: 
 
 END) 005' 
 
 .ACTlONf CHECKIFNEXTFPISPOOLEAN)! TFSTFPTYPE ( POOL ) i 005: 
 
 ACTION(CHFCKIfNEXTFPISCODE )« TESTFPTYPECOSLCODE); 005: 
 
 .ACTlON(CHECKIFNEXTFPISFVENT )t TFSTFPTYPE ( F VNT >; 005: 
 
 ■ ACTlOMChFCKlFNExTFPISFILE )* TFSTFPTYPE ( DSLFILE ) J 005: 
 
 ACTIOMCHFCKIFNEXTFPISINTEGFR)! TFSTFPTYPE ( I NT )J 005; 
 
 ACTION(CHFCKIFNEXTFPISPATTERN) » TFSTFPT YPE( PATT )J 005; 
 
 ACTlON(CHFCKTFNEXTFPlSPniNTER): TFSTFPT YPE ( PTP )J 005' 
 
 ACTlON(CHECKlFNEXTFPISPROCESS)l TF STFPT YPE ( PROS )J 005: 
 
 ACTlOK(CHFCKlFNFXTFPISSTRING )» TFSTFPT YPE ( STR )J 005: 
 
 ■ACTIONCCHFCKIFNEXTFPISSTRUCTURE)! 005: 
 
 COMMENT THIS ACTION PRINTS AN ERROR MESSAGE IF THE SCANNED 005: 
 
 ACTUAL PARAMETER WHICH WAS A STRUCTURE* IS MOT STRUCTURALLY 005: 
 
 IDENTICAL TO THE pROCEpUPE FORMAL PARAMETER OR IF THF FORMAL 005: 
 
 PARAMETFR IS NOT A STRUCTURE; 005; 
 
 DROP 005: 
 
 IF CURRFNTACTUALPARAMETERCOUNT * CURRENTMUMPERDFFORMALPAR AMETFPS 005: 
 
 THEN BEGIN 005: 
 
 ERRMS "NUMBER OF ACTUAL PARAMETERS EXCFEDS NUMPFR ALLOWED." ; 005: 
 
 WRITEMFSOUT 005: 
 
 FND ELSF RFGIN 005; 
 
 IF SOPP(STRUCTuRETAPj» 005: 
 
210 
 
 cuprenteopmalparameterl istppintfr - 
 currentactualpafametercdunt*typf) * struct 
 thfn begin 
 
 eprms "a structure is mot allowed as an actual m * 
 
 "parameter at this paramftep position,"* 
 wpitemesout 
 end else begin 
 
 if not offsfteoual(sopp(mstack>stpp»stpuctl.irfptr>> 
 
 $ppp( ms tack* stop #numprsurstruct)> 
 currentformalparameterlistpointer + 
 current ac tu alp arameterc punt) 
 then begin 
 
 does not match formal parameter "> 
 in procedure declaration. "i 
 
 ERRMS 
 
 "STRUCTURE 
 "STRUCTURE 
 WRITEMESOUT 
 
 ENP 
 
 END 
 
 CHECKS THAT A 
 AND TURNS OFF 
 
 STATEMFNT PODY TO A PROCEDURE 
 THE FORWARD BIT IN BIGTAR 
 
 FPPMAL "' 
 ONLY USE 
 
 END* 
 
 end; 
 {.action(chfcknotformal) » 
 
 cumkfnt this action 
 declaration was allowed 
 if it v as pn; 
 
 DROP 
 
 IF SCANNINGFORMALPARAMETEPDECLARATIPNS 
 
 THEN 
 
 BEGIN 
 
 ERRMS "PROCEDURF DECLARATIONS USED TO PEFINF 
 
 "PARAMETERS IN A PRPCFDUPE Hf/iDING MAY 
 
 """♦"FORMAL"*""'''" AS A BODY."* 
 WRITEMESOUT 
 END 
 ELSE 
 BEGIN 
 
 sopd( b i gt ab*sopd( i dstac(<* current procedure i d*p i gtapptr)* 
 f0rwarddefined5 ♦ 0j 
 end; * 
 
 end; 
 
 SACTION(CHfCKSuBSCRIPTFDFORUPPER)« 
 4ACTI0NC CHFCKSURSCRIPTMATCH M 
 
 COMNFNT THIS ACTION PRINTS AN ERROR MESSAGE IF THE NUMBER 
 
 SUBSCRIPTS DOES NOT MATCH THE DECLARATION 
 
 DROP 
 
 if (if currentstructurfptr = 
 
 then sppd(idstack*$0pd(rigtap*sppdcm<:tack*$t0p-2*entry>* 
 
 idstackptr>>-numbpofsubs) 
 else sppd(structuretab'currentipptr*numpp0fsups)) # 
 curpentnumbrofsdps 
 
 THEN 
 BEGIN 
 
 ERRMS "NUMBER OF SU P SCRIPTS DOES NOT MATCH DECLARATION."; 
 
 WPTTEMESOUT 
 END» 
 
 SPLP(SuPSCRlPTSTACK'JCUPRFNTNliMPROFSliRS); 
 fPOP(SuP$CRlPT$TACK:CUPRFNTSTRUCTURFFTR); 
 JP0P(SUPSCRIPTSTACK:CUPRFNTNLIMPER0FSUBSTPUCTURES)I 
 
 NONAMECALL * TRUE) 
 END; 
 SACTI0K(CHECKTHATIDISTYPED)I 
 
 COMMENT THIS ACTION SETS SFMANTTCTEST TRUE If THE PROCEDURE 
 ON THE TOP OF THE STACK IS A TYPED PROCEDURE ID; 
 
 OF 
 
 ID 
 
 00515600 
 
 00515700 
 
 005l5t00 
 
 00515900 
 
 00516000 
 
 00516100 
 
 00516200 
 
 00516300 
 
 00516400 
 
 00516500 
 
 00516600 
 
 00516700 
 
 00516600 
 
 00516900 
 
 00517000 
 
 00517100 
 
 00517200 
 
 00517300 
 
 00517400 
 
 005l7bOC 
 
 00517600 
 
 00517700 
 
 00517600 
 
 00517900 
 
 00516000 
 
 00516100 
 
 00516200 
 
 00518300 
 
 00518400 
 
 00516500 
 
 00516600 
 
 00516700 
 
 00516600 
 
 00518900 
 
 00519000 : 
 
 005J9100 , 
 
 00519200 i 
 
 00519300 ' 
 
 00519400 
 
 00519500 
 
 00519600 
 
 00519700 ' 
 
 00519600, 
 
 00519900; 
 
 00520000 , 
 
 00520100' 
 
 00520200 ] 
 
 00520300 
 
 00520400 
 
 00520b00 
 
 00520600 
 
 00520700 
 
 00520600 
 
 00520500 
 
 00521000 
 
 00521100 
 
 00521200 
 
 00521300 
 
 00521 400 
 
 00521500 
 
 00521600 
 
211 
 
 INTOinSTACK)) 
 R), 
 
 R)# 
 
 IF THE FUNCTION ON THF TOP 
 
 OROP 
 SENANHCTEST «■ 
 
 (IF BOOLE AN(SPPD(NSTACK,*TPP*PRPCEDURFPTR IS 
 THEN SOPD(IDSTaCK, 
 
 SOPD(MSTACKj.tTOP»PROCEDURFPT 
 TYPE) 
 ELSE $OPD(STRUCTURFTAP, 
 
 $OPD (MST AC K* STOP* PROCEDURE PT 
 TYPE)) * unoecl; 
 end; 
 
 COMMENT 
 
 THF FOLLOWING ACTIONS ALL TEST 
 OF HSTACK IS OF THF IKDKATFD TYPE; 
 tACTIONCCHFf KTHATPARPSNOTRFQDJPEDt 
 
 COMMENT THIS ACTION INSURES THAT A PROCFDURF ID 
 ALLNE SHOULD NOT HAyE ACTUAL PARAMETERS. IF ACTUAL 
 ARE REOUIRFD'AN ERROR MESSAGE IS PRINTED? 
 DROP 
 
 IF (IF POOlEAN(SLipP(MSTACK>STOP>PROCFDURFPTRISlNTOln 
 THEN $0PD(J.[;StACK>S0PD(MSTACK>M0P>PR0CFPUREPTR) 
 ELSE SOPD(STRUCTURETAH>SOPO(MSTACIOSTOP>PROCFDUP 
 NUMBROFPARNS)) * 
 THEN BEGIN 
 
 ERRMS •'THIS PROCEDURE REQUIRES ACTUAL 
 WRITEMESOUT 
 
 STANDING 
 PARAMETERS 
 
 STACK)) 
 ,NUMBROFPaRMS) 
 
 FPTP)# 
 
 PARAMETERS,"* 
 
 IF A RFTU 
 DFCLARATI 
 
 UMDECL 
 
 RN IS USED 
 ON) 
 
 THE ",""« ^"RETURN" 
 
 ALL SET SEMANTICTFST 
 PEING DECLARED IS OF 
 
 TRUE 
 THE 
 
 INDICATED 
 
 END; 
 END) 
 SACTIONC CHECKTHATPROCEDUREISNOTTYPED )J 
 
 CUMMFNT THIS ACTION GENERATES An ERROR 
 WITHOUT AN EXPRESSION IN A TYPED PROCEDURE 
 DROP 
 
 IF SOPDdDSTACtwCURPENTPPOCEDUREID'TYPE) * 
 THEN 
 BEGIN 
 
 ERRMS "AN EXPRESSION IS EXPECTED FOLLOWING 
 w « tt f »t ti j 
 
 WRITEMESOUT; 
 END) * 
 
 COHMENT 
 
 the following actions 
 if the procedure currently 
 type; 
 
 END) 
 
 iactlon(checkthatreturnstructurematchesprocedurfstructur 
 comment in a rfturn 5tatfmfnt* this action chfck 
 declarfd procedure structure matches the returned st 
 if it does not an errop mfssage is printed; 
 
 FE&IN 
 
 DEFINF ERROR = BEGIN ERRMS "RETURNED STRUCTURE 
 "MATCH THE DFCLARED PROCEDURF ST 
 WRITFMFSOUT FND f! 
 LAFEL LOOP; 
 INTEGER PROCEDURE STRUCTURE POINTER* 
 
 NUMB EROFPROCE DURE SUP STRUCTURES* 
 RE T URNST RUC TUPE POINTER* 
 NUMBEROF RFTURN SUBSTRUCTURES) 
 IF CURRFNTSTRUCTUPEPTR = 
 THEN 
 BFGIN 
 
 PROCEDURESTRUCTUREPOINTER «■ 
 
 SOPDC IDSTACK»CUPPFNTPROCEDUREID*STRUCTUREPTR); 
 
 )» 
 
 S WHETHER ThE 
 
 RUCTURE. 
 
 DOES NOT "> 
 'RUCTURE.") 
 
 00521700 
 00521600 
 00521900 
 00522000 
 00522100 
 00522200 
 00522300 
 00522400 
 00522500 
 00522600 
 00522700 
 00522800 
 00522900 
 00523000 
 00523100 
 00523?00 
 00523300 
 00523400 
 00523500 
 00523600 
 00523700 
 00523600 
 00523900 
 00524000 
 0052^100 
 0052^200 
 00524300 
 00524400 
 00524500 
 00524600 
 00524700 
 00524600 
 00524900 
 00525000 
 >00525l00 
 00525200 
 00525300 
 00525400 
 00525500 
 00525600 
 00525700 
 00525600 
 00525900 
 00526000 
 00526100 
 00526200 
 00526300 
 00526400 
 00526500 
 00526600 
 00526700 
 00526600 
 00526900 
 00527000 
 00527100 
 00527200 
 00527300 
 00527400 
 00527500 
 00527600 
 00527700 
 
212 
 
 EN 
 EL 
 BE 
 
 EN 
 PF 
 Nu 
 IF 
 
 TH 
 RE 
 LO 
 
 NUMBERDFPROCFDURESUBSTRUCTURES «■ 
 
 $OPD( IPSTACK*CURRFNTPROCEDUREID#NUMBRSUBSTRUCT) 
 
 N 
 pROCEDURESTRUCTUREPOINTER «■ 
 
 SOpDt STRUCTURE TAB* CURRENT I DPTR> STRUC TUREPTP ) ; 
 NUMBEROFPROCfOI'PF SUBSTRUCTURES «■ 
 
 SOPDC STRUCTURE TAP#CUPRFWT I DPTR#NUMBPSUBSTRUCT) 
 
 RNSTRUCTuPFPUtNTER «■ *OPD(MSTACK*STOP,STRUCTURFPTR); 
 ER0FRETURNSUPSTPUCTURFS«-$0PD(MSTACK#ST0P»NUMBRSUBSTRUCT); 
 UMPEROFPRnCFDURF SUB STRUCTURES a 
 UHPFROF RETURNS (^STRUCTURES 
 
 FOR 
 IF N 
 
 THEN 
 BEGI 
 
 I «■ 1 STEP 1 UNTIL NUMPFROFRETURNSUBSTRUCTURES 
 OT EOUALSTRUCTURFTAR 
 
 (PROCFOUPESTRUCTUREPOlNTEP+l-I# 
 RETUPNSTRUCTUREPOINTER+I-I) 
 
 DO 
 
 N 
 
 END; 
 
 Error; 
 leavf lciup 
 
 LOOP! 
 
 EN 
 
 end; 
 
 COMMENT 
 
 TH 
 INDICAT 
 FRtiM BI 
 THE CUR 
 SACTlOKC CH 
 CGMM 
 INSURE 
 ARRO^ A 
 BEGIN 
 
 IN 
 LA 
 DE 
 
 RI 
 RI 
 LE 
 LF 
 IF 
 TH 
 BE 
 
 ; in 
 
 ESE FOLLOWING ACTIONS ALL CHFCK THAT AN in IS OF THE 
 
 ED TYPE. IF CUPRFNTSTRUCTtlRFPTR = |»;E GO RIGHT TO IDSTACK 
 
 GTAB. OTHERWISE WE TRY TO FIND THE ID IN STRUCTURETAB IN 
 
 RFNT AREA OF THF SUBSTRUCTURE; 
 
 FCKTHATSTRUCTURFSAPETHESAME )l * 
 
 FNT THIS ACTION IS INVOKFD TN A STRUCTURE ASSIGNMENT TO 
 
 THAT THE STPUCTuRFS ON THE LFFT And RIGHT OF THE ASSIGNMENT 
 
 RE IDENTICALLY TYPFD AND IDENTICALLY STRUCTURED j 
 
 TEGE 
 
 PEL 
 
 FINE 
 
 GHTP 
 GHTN 
 FTPT 
 FTNu 
 LEF 
 EN 
 GIN 
 OP» 
 F 
 P 
 
 EN 
 EL 
 
 F 
 P 
 SE ERROR 
 
 R rightptr>pightnumper*lfftptr>leftnumber; 
 loop; 
 error = begin errms "structures do npt match." 
 
 V.'RITFMESOUT fnd #1 
 TR «- SOPD(MSTACK»tTOP*STRUCTUPEFTP); 
 UMBER <- SPP0CMSTACK»£T0P»NUMPRSURSTRUCT); 
 R * SOPDf MSTACK#*TOP-?»STRUCTURF.PTR)) 
 MPFR <■ JOPD(MSTACK»*TPP-P#NUMfRSUFSTRUCT)) 
 TNUMBER = RIGHTNUMBFR 
 
 OR I <• 1 STEP 1 UNTIL LFFTNUM&ER PO 
 EGIN 
 
 IF NOT FQUALSTRUCTURFTA8(LEFTPTR+1-I#RIGHTPTR-H-I) 
 
 THEN 
 BEGIN 
 
 eppoo; 
 leavf loop 
 
 END 
 ND; LOOPt 
 
 00527600 
 00527900 
 00526000 
 
 oo5?aioo 
 
 00526^00 
 00528300 
 00526400 
 00526500 
 0052b b 00 
 00528700 
 00526600 
 005289*10 
 00529000 
 00529100 
 00529200 
 00529300 
 00529400 
 00529500 
 00529600 
 00529700 
 00529600 
 00529900 
 00530000 
 00530100 
 00530200 
 00530300 
 00530400 
 00530500 
 00530600 
 00530700 
 00530800 
 00530900 
 00531000 
 00531100 
 00531200 
 00531300 
 00531400 
 00531500 
 00531600 
 00531700 
 00531600 
 00531900 
 O0532000 
 00532100 
 00532200 
 00532300 
 00532400 
 00532500 
 00532600 
 00532700 
 00532800 
 00532900 
 00533000 
 00533100 
 00533200 
 00533300 
 00533400 
 00533500 
 00533600 
 00533700 
 00533600 
 
213 
 
 ACTION 1 REMOVES A LABEL 
 RIGHT ONE* IT TRIES TO 
 
 FROM THE IDSTACK. 
 FIX IT up; 
 
 end; 
 &actionc closelapel 
 comment this 
 label is not the 
 
 DROP 
 
 IF SOPD(MSTACK,$TOP»ENTRY) s SPPDC IDSTACIOSTPP, BI f,T ABPTR ) 
 
 AND $OPD(IDSTACK,STOP>TYPF) ■ LAPL 
 THEN 
 ELSE 
 BEGIN 
 
 ERPMS "THIS CLOSING LAREL DOES NOT MATCH THE OPENING 
 
 KRTTEMESOUT; 
 
 END; 
 
 MILE $OPD(LEAVESTACK>*TOP>MARK) # 1 DO 
 
 BEGIN 
 
 BR A'NCH C *OPD C LE A VEST A CK> STOP* ADDRESS)* 
 CURRENT ADDRESS* "BRANCH"); 
 
 tPOPCLEAVESTACK); 
 
 end; 
 
 $plp(leavestack); 
 sexeccfndofblock); 
 fnd; 
 
 $ACTlON(CODFABS)« 
 DROP 
 
 oplratorcars"); 
 
 end; 
 jaction(codfaccessdeclaration)» 
 jactlon(codeaccessidactualpapametep)l 
 $actlon(codeallocatefumctlpn) : 
 saction(codeallocateprocfdurf) t 
 
 $ACTlONCCODEAND)» 
 
 DROP 
 
 oplratorcand"); 
 end; 
 !*acti0n(c0deany)» 
 
 tACTlONCCODEANYDFFAULT) t 
 pCTlON(CODEBEGlNAPPEND)« 
 ISACTlON(CODEbEGlNBOOLEAMlNITlALlZATlPN) ! ■/ 
 
 sexfcccodepfginintegerinitializatio^); 
 saction(codfbegincause) t 
 iaction(copfbegindostatememt)j 
 $actu1n(c0pfbeginfventactidndecl)i 
 
 ;JACTIDN(COrFBFGlNFOREY) J 
 bACTlON(CODFBEGlN'FORLlMlT) J 
 IACTlON(COrFBEGlNFPRSTEP)» 
 % ACT ION (CODF BE GlNFOR UNTIL) « 
 SACTlONrCCDFBFGlNFORWHILE): 
 JACTlON(CODEBEGlNlNlTIATE)! 
 FACTION (CODF BEG IN I NTEGER I N I T I AL I 2 AT ION ) J 
 BEGIN 
 
 IMTEGFR I»J; 
 
 I «- CURPENTMAXIMUMDISPLACEMFNT - IDL ISTCOUNTFR; 
 
 J <- I + IDLISTCOUNTFR-i; 
 
 for i * i step 1 until j 00 
 couplf( m name-call«>currentlevel> i » " ") ; 
 end; 
 
 ''action(codfbfginlowerpounp) t 
 
 i act i on (codf bfgtnp at tern initialization) i 
 
 !>ACTlON(COpFBEr.INP{lINTFRlNlTIALIZATlnN)l 
 
 *EXEC(CPDEPt GININTFGFRINITIALIZATION); 
 !'ACTlON(CODFbEGlNPROCEOURFBUPY) l 
 
 v 00533900 
 
 00534000 
 
 IF THIS 0053^100 
 
 00534200 
 
 0053^300 
 00534400 
 00534500 
 00534600 
 00534700 
 00534800 
 LApEL. M ;00534900 
 00535000 
 00535100 
 00535200 
 00535300 
 00535400 
 005355P0 
 00535600 
 00535700 
 00535600 
 00535900 
 00536000 
 00600100 
 00600200 
 00600300 
 00600400 
 00600500 
 00600600 
 00600700 
 00600800 
 00600900 
 00601000 
 00601100 
 00601200 
 * 00601300 
 0060H00 
 00601500 
 00601600 
 00601700 
 00601800 
 00601900 
 00602000 
 00602100 
 00602200 
 00602300 
 00602400 
 00602500 
 00602600 
 00602700 
 00602600 
 00602900 
 00603000 
 00603100 
 00603200 
 00603300 
 00603400 
 00603500 
 00603600 
 00603700 
 00603600 
 00603900 
 
2lU 
 
 $ACTlON(COnFBEGlNPR0CESSTERMlNATE)t 
 t ACT I ON (CC)DEPEG ^'RESTART)! 
 tACTlON(COCEBEGlN'SPAWN)l 
 *ACTI0N(C0DFBEGINSTRINGIMTIAIIZATI0N)I 
 
 SEXFC<C0DEPEGINIMFGERINITIALIZATI0K'>J 
 SACTlON(CODFbEGlMSTRlNGLFNCTM) t 
 tACTlPNCCODFBEGlNSTRlNGMZE)! 
 tACTinKCCOoFBEGlNSTRUCTURtDECDl 
 4ACTinN(C0nFBFGP' SUSP END): 
 tACTlON(CODFBEGlNUPPERROUNP) I 
 t ACT ION (CODF BEG IN VALUE)! 
 SACTIOK(CODFBEGINWAIT)! 
 *AC7I0N(C(JDFBEGINWHILESTATEMFNT)I 
 SACTIOK(CODEBLPCKEND) » 
 
 DROP 
 
 tPDP(BLnCKSTACK*CURRENTMAxlMUMDISPLACEMENT); 
 
 JPOP(BLPCKj;TACK/CURRFNTAnDRFSS); 
 
 SPUP(BLOCKSTACK»CUPRENTSEGMEMT)J 
 
 sdecrccurrentleved; 
 
 END J 
 tACTlONCCODFBOOLEANACTllALPARAMETER)! 
 jACTlON(CLDFBnoLFANFUNCTION)t 
 tACTION(CDDFBOCLFANVALUECALLlt 
 
 DROP 
 
 OPERATOPC^LPAO-BOOLEAN")} 
 
 ENDJ 
 *ACTION(CODFBOoLFANVARIARLF)l 
 
 DROP 
 
 if not nonamecall then 
 
 cooplef "name-call"»$opp(ipstack>t «■ *opo(bigtab# 
 sopd ( ms tack, stop 'FNTry),idstaCkptR),lfvfL)* 
 
 sppd(idstack»i*displacement>#ppintid)j 
 lasttypf <- bool; 
 nonamecall «■ false) 
 end; 
 *action(codfbranchbackfop)» 
 
 tACTlON(CODEBRANCHBACKFORTlMES)» 
 
 tACTION(CODFBRANCHPACKTODOlFFALSE)! Y 
 
 *ACTlON(COnEBRANChBACKTnWHTLF>« 
 tACTlOK(COnFBRANCHPASTELSE)i 
 *ACTlON(COpEBRANCHPASTSTATFMENTlFFALSE)i 
 $ACTI0K(C0DFBRANCHPASTTHEMFFALSE)I 
 SACTlONCCOpECASE BRANCH) » 
 *ACtION(CODFCASFSTATEMENTENtRY)I 
 SACTlON(CODFCAsFWAITSTATEMENT3t 
 S AC T I ON (COrE CAUSE TERM I NATE) I 
 JACTION(CODECDIV)! 
 DROP 
 
 operatorccdiv"); 
 
 fnd; 
 
 fACTlON(CODFCHARSIZEOFSTRlNG)» 
 DROP 
 
 OPERATORCCHARSIZE")* 
 
 END? 
 *ACTlON(CODFCDnEACTUALPARAVETFR)l 
 
 SEMNTJCTEST «• FALSE) 
 SACTIONCCODECONVERT)! 
 
 DROP 
 
 operator ( "translate" )j 
 end; 
 
 *ACTlONCCODFPEcLARATlnN)l 
 
 00604000 
 00604100 
 00604200 
 00604300 
 00604400 
 00604500 
 00604600 
 00604700 
 00604800 
 00604900 
 00605000 
 00605100 
 00605200 
 00605300 
 00605400 
 00605500 
 00605600 
 00605700 
 00605600 
 00605900 
 00606000 
 00606100 
 00606200 
 00606300 
 00606400 
 00606500 
 00606600 
 00606700 
 00606800 
 00606900 
 00607000 
 00607100 
 00607200 
 00607300 
 00607400 
 00607500 
 00607600 
 00607700 
 00607800 
 00607900 
 00608000 
 00608100 
 00608200 
 00606300 
 00608400 
 00606500 
 00606600 
 00606700 
 00608600 
 00606900 
 00609000 
 00609100 
 00609200 
 00609300 
 00609400 
 00609500 
 00609600 
 00609700 
 00609600 
 00609900 
 00610000 
 
215 
 
 COMMFNT THIS ACTION SETS CURPENTDECLT YPF = OSLCOPE TO INDICATE 006 
 
 THAT A CODF DECLARATION IS BEING SCANNED ; 006; 
 
 CURRENTDECi TYPE ♦• OSLCPDFJ 006 
 
 $ACT10N(C0DEDFCT0INTEGFR)« 006; 
 
 DROP 006' 
 
 OPERATnR("CONVERTDFCIMALTOINTEGER">l 006: 
 
 END! 006: 
 
 *ACTlON(CODFDFFAULTACCESSlnACTUALPARA METER)! 006: 
 
 $ACTlOKCCOrFDFFAULTROniEAK'ACTUALPARAMETER)« 006: 
 
 fACTlON(CODFDEFAULTCDDFACTliALPARAMFTFR)i 006: 
 
 $ACTlOMCODFDEFAULTFVENTACTUALPARAMETER) » ' 006: 
 
 $ACt I ON ( COpFDFFAULTF I LF ACTUAL PARAMETER)* 006: 
 
 SAC T I ON ( C ODF DEF A ML TFOR INCREMENT)! 006: 
 
 $ACTlON(CODFDEFAULTlNTFGFRACTUALPARAMFTFR)t 006: 
 
 JACTIOMCOPFDEFAULTPATTFPNACUIAIPAPAMFTFR)! 006 , 
 
 $ACT10N(C0DFDFFAULTP0INTERACTUALPAPAMFTFR) t 006: 
 
 fACTl0N(C0DEDEFAULTPR0CEDUPETDACTOALPARAMFTEP)« 006: 
 
 $ACTION(CODFDEFAULTPRnCFSSACTUALPARAMFTEP)J 006: 
 
 $ACTI0N(C0DECEFAULTSTRINGACTUALPARAMFTER)I 006; 
 
 $ACTlON(COrE0EFAl'LTSTRUCTUPEACTUALPAPAMFTER)l » 006; 
 
 $ACTlON(CODEDEFAULTTERMINATE)l 006: 
 
 $ACTI0N(C0DECIVIPE)J 006: 
 
 DROP 006: 
 
 0PERAT0P( M DIVIDE W )I 006: 
 
 ENDI 006: 
 
 JACTION(CODEENDAPPEND)» 006: 
 
 &ACTI0N(C0DEENDF00LEANINITIALIZATI0N)I 006; 
 
 BEGIN 006: 
 
 Integer ij 006: 
 
 fop i * 1 step 1 until idl i stcdunter-1 do 006: 
 
 opf r a tpr(" st ore -boolean- partial-destructive"); 006: 
 
 operator("stope-booi ean")j 006: 
 
 ENDI 006; 
 
 SACTlON(CODFF.NpPRANCHiFFALSE)» 006: 
 
 fcACTlON(CODEENpRRANCHPASTELSF)l * 006: 
 
 SACTIONCCODEENDCAUSE)! 006; 
 
 MCTIONCCODFENDCAUSFTFRMINATF)! 006: 
 
 &ACTlON(COpFENDEVENTACTlONnECL)l ■ ■* 006: 
 
 IACTI0N(C0DFENDF ALSE BR AnCHP ASTTHfN ) J 006: 
 
 BACTlONCCODEENpFORBY)! 006: 
 
 JACTIONCCODFLNDFORLIMIT): 006: 
 
 {.ACTlON(COpEENpFPRLIST)! 006' 
 
 ^ACTION(COnFLNpFnRSTEP) t 006: 
 
 t.ACTlON(COpE'FNpFORUNTlL) t 006: 
 
 RACTlON(CODFENpFORWhlLF): 006: 
 
 tACTlON(COpFENDlMTlATE)l , 006: 
 
 tACTlON(CODFEMpINTEGERlNlTIALlZATlON)J 006: 
 
 6EGIN 006: 
 
 integer i; 006: 
 
 FDP T «■ 1 STFP 1 UNTIL I D 1. 1 STCHUNTeRM DO 006; 
 
 operatpr("stope -i ktfger- partial-destructive")* 006: 
 
 opfratprcstore-hteger")) 006: 
 
 end; 006: 
 
 &ACTlOK(COnFENDMATCHASSIGN*'ENT)l 006: 
 
 SACTIONCCOPFENPPFCASE)! 006: 
 
 FACTION (CODF E'NDPFCASEWAIT)! 006' 
 
 &ACTlON(COPFENDOFEXPCASE)J 006: 
 
 DROP 006: 
 
 FOR I <- CURRENTCASFCOUMT STEP -1 UNTIL 1 DO 006: 
 
 BEGIN 006: 
 
 BPANCH(CURRENTADDPESS>SPPn(CASFSTACK>STnP-(2xI)),«PRANCH")j 006: 
 
216 
 
 $INCR(CURPE.MADDRFS£)J 
 L^RANCHC ? 'OFU(CASFSTAfK»J.TOP+l-<?xT>D* 
 
 $DPD ( C ASF STACK* STOP )+CUPHFNTCASrCOl'NT» ♦'BRANCH"); 
 
 END) 
 
 BRANChC J-OPDC CASE STACKS fTnp-l-(?xCUPRF NIC ASFCTUNT))* 
 
 SpPD (C ASF STACK, STOP )>" I KDEXEO-PRANCH"); 
 PTCASKSTACK f PUASESTACk - ( 2xCURRFN TC ASECOuNT+3 ) ; 
 CUhRt'NTCASFCnUNT *■ SOPp C C ASESTACK, STOP* 1 ) i 
 END) 
 t ACT JON ((.(jpFt NppATH RNlN'ITIAL I Z AT ION) « 
 JACTlONfCDDFLNDPniNTFRlNlTIALlZATlON)! 
 BEGIN 
 
 IMTEGFP i; 
 
 FDR I < 1 STEP 1 I'NTTL I DL T STCPUNTfR- 1 DO 
 DpERATPR("5TORE-PPirTER-PARTlAl-DESTRUCTlVE»); 
 OPERATOR ("STORE-POINTER")) 
 END) 
 JACTlOf (CDpEENpPROCEDUREPOpY> t 
 SACTlNNf cnpELNpPROCl. SSTERMINATE)! 
 $ACTIC3N(C(3DFENDRFSTART) J 
 SACTIONCC ODFENpSKIPFACTOR) t 
 $ ACTION CCPPFE. MP SPAWN) t 
 
 SACTinKfCOpFENDSTMNGINITlAL IZATION)! 
 BEGIN 
 
 INTEGER U 
 
 EPP I <• 1 STEP 1 I'NTiL lDLlSTCOUNTfTR-1 PO 
 
 OpFRATPR( "ST PRE- INTEGER-PARTIAL -DESTRUCTIVE"); 
 
 OPER AT PR ("STORE- INTEGER"); 
 END J 
 JACT IONCCOPEENPSTPUCTUREDECDI 
 SACTI0N(C0PEENDSUSPEND)» 
 SACTlONf CUpFENpVALUE) I 
 
 SACTlCJK(COrEE-NpWAIT) » + 
 
 $ACTI0N(C0PFENP?NDABYSKIP) t 
 SACTIONCCDPEEQL )' 
 
 RELOB <- 3) 
 SACTIONCCOPFEQV)) 
 
 DROP 
 
 OPE PATPP("F0\'"); 
 
 ENID J 
 SACTIONfCOpEEVFN'TACTUALPARAMFTER)! 
 
 SACtION(COOEFVfNTLIST)» 
 $ACT IOKf COpFEXCEPT): 
 SACTIONCCOPEEXCFPTDE FAULT)t 
 SACTlONf CODFEXPCASEBRANCH): 
 
 DROP 
 
 £push(casestack>currentcasecount); 
 
 $push(casfstack^currfntaddress); 
 
 0peratcp( w *** ( indfxed-bpanch instruction will be here) ***"); 
 
 cuKREMCAsrcnuNT «■ o; 
 s»push{casestack#currentapdpess); 
 
 END J 
 SACTlONfCODEtXpCASE ENTRY)) 
 PROP 
 
 spush(casestack'curpentapdress); 
 
 ope fatppc"*** (branch instruction will be hfpe) ***"); 
 splsh(casestack/currentaddress); 
 j ■incr(curpf ntcaslcount); 
 end; 
 sactionccopeexpskipelse)! 
 
 PROP 
 
 00616?C0 
 
 00616300 
 
 00616400 ! 
 
 00616500 
 
 00616600 
 
 00616700 
 
 006j6ftOO 
 
 00616900 
 
 00617000 
 
 00617100 [ 
 
 00617200 
 
 00617300 
 
 006-17400 j 
 
 00617500 
 
 00617600 | 
 
 00617700 j 
 
 00617800 
 
 00617900 
 
 00618000 ■■ 
 
 00618100 J! 
 
 00616200 j 
 
 00618300 
 
 00618400 j 
 
 00618500 : 
 
 00618600 I 
 
 00618700^ 
 
 00616800 
 
 00616900; 
 
 00619000' 
 
 00619100 
 
 00619200,. 
 
 00619300 
 
 00619400 
 
 00619500 
 
 00619600 
 
 00619700' 
 
 00619600, 
 
 00619900^: 
 
 00620000; 
 
 00620100 
 
 00620200 
 
 00620300 
 
 00620400 
 
 00620500' 
 
 0062060CJ 
 
 0062070C 
 
 0062060C 
 
 0062090C 
 
 00621000 
 
 0062110C 
 
 0062120C 
 
 0062130C 
 
 0062U0C 
 
 0062150( 
 
 0062160C 
 
 0062170C 
 
 0062180C 
 
 0062190C 
 
 0062200C 
 
 0062210C 
 
 00622201 
 
217 
 
 BRANCh(?OPD<EXPRSNlFSTACK,STOP)i>CUR»ENTADDRFSS + l, 
 "PPANCH-IF-F ALSF")! 
 
 FxPRSMFSTACK»STOP) * CURRENTADDRESS } 
 TPPC"*** (BRANCH INSTRUCTION WILL BE HFRE) *** M )J 
 
 ,AC 
 
 ,AC 
 
 AC 
 
 $OPD( 
 OPERA 
 
 end; 
 
 TlONCC 
 DROP 
 BRANC 
 $POP( 
 END) 
 
 TlONCC 
 DROP 
 
 spush 
 
 OPERA 
 
 end; 
 
 TlONCC 
 
 TlONCC 
 
 DROP 
 
 OPERA 
 
 END) 
 
 TlONCC 
 
 TlONCC 
 
 TlONCC 
 
 TlONCC 
 
 TlONCC 
 
 TlOK(C 
 
 TlONCC 
 
 TlONCC 
 
 TI0N(C 
 
 RELOP 
 
 TlONCC 
 
 RELOP 
 
 TlONCC 
 
 DROP 
 
 OPERA 
 
 END* 
 
 TlONCC 
 
 TlONCC 
 
 TlONCC 
 
 DROP 
 
 OPERA 
 
 END; 
 
 TlONCC 
 
 DROP 
 
 ;AC 
 
 AC 
 
 ,AC 
 
 -AC 
 
 END; 
 TlONCC 
 TlONCC 
 
 drop; 
 
 OPERA 
 
 end; 
 
 TlONCC 
 
 OUTPU 
 TlONCC 
 DROP 
 OPERA 
 
 end; 
 
 TlONCC 
 DROP 
 
 odffxpskippastelsffound)t 
 
 h c *opd c e xprsn i f st ac k>ttop)# current address* "pr anch«)j 
 exprsniestack);. . 
 
 opeexpskipthenonfalse)! 
 
 (f xprsn if stack* current address) i 
 
 TORC*** (BRanCH-IF-FALSE INSTRUCTION WILL BE HFRE) *** w )>" 
 
 OnFtXPSKlPTOELSEFOUND)! 
 
 OPFF ALSE)I 
 
 TOR("FALSE")J 
 
 ODFFIFLDLENGTH)! 
 
 OpFF IFLDSTART)J 
 
 ODEFIlFACTUALPARAMETER)! 
 
 OPFFIXEDMATCH5! 
 
 ODFFLDATlNGfoATCH): 
 
 OpFFPRCOUNTFR)« 
 
 OpFFPPLlSTEXP): 
 
 OnFFORVARIAbLE)! 
 
 ODFGEO) « 
 
 «- 4; 
 OpFGTR)» 
 
 <- 5; 
 
 OPE I MP) I 
 
 TpRClMP")! 
 
 ODF INI T I ALF OR ASSIGNMENT) I 
 
 DoFlNTEGERACTUALPARAHETER)» 4 
 
 0DEINTEGERADD)» 
 
 TnR("ADD w ); 
 
 odfintegerconstant)! 
 
 opf rf i rstpart*" integer-literal-call "# 
 
 printidj 
 
 operlastpart; 
 
 odeintegerfunftton) i 
 opeintegermultiply)! 
 
 tcpcmultiply"); 
 
 OpElNTEGERRELOP)! 
 
 TPFLOPCINTEGFR"); 
 OpElNTEGERSUBTRACT) « 
 
 TpP("SUBTRACT M ); 
 
 ORFINTEGERVALUECALDJ 
 
 00622300 
 00622400 
 00622500 
 00622600 
 00622700 
 00622600 
 00622900 
 00623000 
 00623100 
 00623200 
 00623300 
 006?3400 
 00623500 
 00623f,00 
 00623700 
 00623600 
 00623900 
 0062*000 
 00624100 
 00624200 
 00624300 
 00624400 
 00624500 
 00624600 
 00624700 
 00624600 
 00624900 
 00625000 
 00625100 
 00625200 
 00625300 
 00625400 
 00625500 
 00625600 
 00625700 
 00625600 
 00625900 
 00626000 
 00626100 
 00626200 
 00626300 
 00626400 
 00626500 
 00626600 
 00626700 
 00626600 
 00626900 
 00627000 
 00627100 
 00627200 
 00627300 
 00627400 
 00627500 
 00627600 
 00627700 
 00627600 
 00627900 
 00626000 
 00626100 
 00626200 
 00626300 
 
218 
 
 flP£RATOR( n LPAD-lNTFGfR")J 
 
 end; 
 
 SACIIONCCOpElNTFGERVARlABLF )« 
 
 DROP 
 
 IF NOT K'ONAMFCALL THFN 
 
 COUPLEC ,, NArE-CALL M >SPPP( IDSTACK»I * SOPDCBIGTAB* 
 *DPD(K<STACK*tTnP>F'WTRY)*inSTACKPTR)»LFVFL}* 
 *ClPD(lDSTACKM»niSPLACEMFMT)/PRINTlD); 
 
 las1typf «- intj 
 nokakecall * falsfj 
 end; 
 
 $ACTlt)NCCODflNTGPFROMSTRING)» 
 DROP 
 OPLRATpR("CONVERTSTRJNGTPlNTEGER")J 
 
 FND) 
 tACTIOMCODFlNTGRTOBOOL) t 
 DRUP 
 
 operator ("convert i ntfgfrtoboolf an* ); 
 
 fni; 
 
 tACTlOK(CODFINTGRTODEClMAL)J 
 DROP 
 
 OPERATORCCONVFRTINTFGFRTODFClMAL ,, )J 
 
 END; 
 *ACTlONCCOpFlNTGRTOSTRJNG)J 
 
 PROP 
 
 OPERAToRCCONVERTINTEGFRTPSTPlNG"); 
 
 END; 
 tACTlON(CODFLENGTHOFSTRlNG): 
 
 PROP 
 
 OPFRATOPC*LFNGTH*)J 
 
 END; 
 *ACTlON(CODFLEO)« 
 
 RELPP «■ 21 
 SACTlON(COpFLONFTERMiNATE)> 
 SACTIONCCOpFLPwER) t 
 tACTlOK(CODFLnwERBOUND)l 
 $ACTlON(COpFLSS)» 
 
 RELOF #- lj y 
 
 tACTlONCCODFMATCHASSlGNMFNT)t 
 $ACTlON(CODFMOD) J 
 
 DROP 
 
 OPERATORC-MOD")* 
 
 END) 
 $ACTlON(CODFMT)» 
 
 DROP 
 
 OPERATORCMT"); 
 
 END; 
 ftACTlON(COpENEGATlVE) J 
 
 DROP 
 
 OPERATpR("NEGATE")J 
 
 END; 
 
 $ACTI0N(CDPFNE0)« 
 
 RELOP «- 6) 
 $AClION(COpFNOMATCHASSIGNf'TNT)l 
 tACTlONf CODE NONDE STRUCT BOOLE A NSTORF)t 
 
 DROP 
 
 SDECRC CURRENT ADDRESS); 
 
 XOPER ATPRCSTPRE-BOOL LAN-PART I A L-DF STRUCT I VE" )J 
 
 FND; 
 ^ACTION(COpFNOKDFSTRUCTlKTFGFRSTPRF) t 
 
 PROP 
 
 00626400 
 00628500 
 00626600 
 00626700 
 00626600 
 00626900 
 00629000 
 00629100 
 00629200 
 00629300 
 00629400 
 00629500 
 00629600 
 00629700 
 00629BP0 
 00629900 
 00630000 
 00630100 
 00630200 
 00630300 
 00630400 
 00630500 
 00630600 
 00630700 
 00630B00 
 00630900 
 00631000 
 00631100 
 00631200 
 00631300 
 00631400 
 00631500 
 00631600 
 00631700 
 00631800 
 00631900 
 00632000 
 00632100 
 00632200 
 00632300 
 00632400 
 00632500 
 00632600 
 00632700 
 00632800 
 00632900 
 00633000 
 00633100 
 006332C0 
 00633300 
 00633400 
 00633500 
 00633600 
 00633700 
 00633600 
 00633900 
 0063^000 
 0063^100 
 00634200 
 006343C0 
 OO6344OO 
 
$Df LCRCCURPFNTAPDRESS); 
 X0f-EhATrRCST0RE-lNTEGrR-PARTlAL-DESTRUCTIVE M )j 
 
 END) 
 
 ICTlONCCOpFNONPESTRUCTSTRlNGSTORE)! 
 
 DROP 
 
 tDtCR(CURRENTADORESS)J 
 
 xop e kattrc "st ore-string-part i al-destpikt i ve"); 
 end; 
 
 iCTlONCCOpFNOSTEPFORCONDlTIPNAL)! 
 kCTlONCCODENOT)' 
 
 DRIP 
 
 OPERATpPC"NOT"); 
 
 end; 
 icti0k(c0pfnull)« 
 
 DROP 
 
 OPERATDPCNULL"); 
 END) 
 
 ICTlON(COpEOR)t 
 DROP 
 
 0peratpr("pr")j 
 end; 
 
 \CTlON(COpFPATTERNACTUALPARAMETER)l 
 
 iCTlOK(CODFPATTEPNHATCH)« 
 
 »CT I ON (COpF PATTERN VARIABLE)! 
 
 DROP 
 
 COIPLE("NAmE-CALL"*SOPP(IDSTACK>I *" SOPD(BIGTAB* 
 
 sopo(mstack,»stpp>fntry),idstackptr),lfvfl)> 
 $ppd(idstack>i#dispi- ace kent)* ppintid); 
 end; 
 
 iCTlON(COpFPOlNTERACTUALPARAMFTER)« 
 iCTIONf CO pFPO I NTFRF UNCTION )t 
 »CTION(COpEPOINTERRELOP)« 
 
 OUT PUT RF L OP ("PO INTER"); 
 *CTlON(COpEPOlNTERVALUECALL)» 
 
 DROP 
 
 ope rat pr ("load-pointer"); 
 end; 
 
 iCTION(CODEPOlNTERVARIABLE): ■ * 
 
 DROP 
 
 COUPLEC w NAME-CALL"#SOPp(IDSTACK#T «■ $OPO(BIGTAB* 
 tOPD(MSTACK/STnP/FNTRY)>lPSTACKPTR)*LEVED* 
 
 s0pd(idstack»i*dispiacement).*printid); 
 
 end; 
 
 *CTION(COpEPOR)t 
 
 iCTION(COpFPOsTDECLARATIONBLOCKHEAD)t 
 
 ^CTlON(CCpEPOwER)! 
 
 DROP 
 
 OPERATpP("PPWER")j 
 
 END; 
 *CTlON(COpFPREPECLARATIONpLOCKHEAD)t 
 
 DROP 
 
 spush(blockstack»currentsfgment); 
 
 spush(blockstack#currfnt address). j 
 
 *push(bloc«staciocurrentmaxlmumdisplacement); 
 
 cuhrfntsegment «■ ( max i mumsegment * max i mumsfc-ment 
 
 curre ntaddrfss «■ current^ax i mumdi spl acemfnt «- 0; 
 
 sincr(currf^tlfvel); 
 
 end; 
 
 iCTlONCCODFPRpCEDUREIDACTllAl PARAMETFR)! 
 
 ICTIONCCODFPROCESSACTUALPARAMETER)! 
 
 iCTlON(COnFPRpCESSDECLARATIPN)l 
 
 i ); 
 
 219 
 
 OO6345PO 
 00634600 
 
 00634700 
 00634600 
 0063^900 
 00635000 
 00635100 
 00635200 
 00635300 
 00635400 
 00635500 
 00635fe00 
 00635700 
 00635600 
 00635900 
 00636000 
 00636100 
 00636200 
 00636300 
 00636400 
 00636500 
 00636600 
 00636700 
 00636b00 
 00630900 
 00637000 
 00637100 
 00637200 
 00637300 
 00637400 
 00637500 
 00637600 
 00637700 
 00637600 
 00637900 
 00636000 
 00636100 
 00636200 
 00636300 
 00636400 
 00636500 
 00636600 
 00636700 
 00636600 
 00636900 
 00639000 
 00639100 
 00639200 
 00639300 
 00639400 
 00639500 
 00639600 
 00639700 
 00639800 
 00639900 
 00640000 
 00640100 
 00640200 
 00640300 
 00640400 
 00640500 
 
220 
 
 $ACTI0KCC0PFPTRSUBSCRIPTFD)I 
 
 iACTlON(CCDFPTPl | NSUBSCRlPTFD)» 
 
 SACTlON(COpFRPlV)! 
 
 PROP 
 
 0PERA7pR("RPl V); 
 
 fnd; 
 
 SACTlON(COpFRELEASE)! 
 SACTlQNCCOpF RETl'RNBOOLFAN)! 
 SACTlON(COPERETURNINTEGEP)| 
 SACTlONCCOpFRF'TURNPATTFRNJj 
 SACTIONCCGPFRFTURNPOINTFR) t 
 SACTlONCCODEKCTilPNSTRIHr. )» 
 SACTIONCCOPFSAND) : 
 PROP 
 
 0PERATpR("sANd m ); 
 
 end; 
 
 SACTlON(COpFvSIf,N)r 
 
 DROP 
 
 0PERA1pPC"sIGN"); 
 
 FND; 
 SACTlON(COpFSlNGLEFORASSlGNMENT)| 
 
 SACTlONCCOnFSKIPFACTORTFTRUFli 
 
 SAC T I ON ( COP F SKIP2NDARYIFFAISF)» 
 SAC! lON(COp,F SNPT) I 
 
 DROP 
 
 OPERATpR("SNOT"); 
 
 end; 
 
 £ACTlON(COpFSPR)» 
 DROP 
 OPERATpR("SPR f1 ); 
 
 end; 
 
 SACTlON(COpESPAN) : 
 SACTlOMCOpESPANPEFAuiT)t 
 SACTIONCCODFSTRINGACTUA I. PARAMETER)! 
 SACTlON(CODESTRlNGCONSTANT)j 
 
 DROP 
 
 opfrflrstpart#«string-literal-call ",»««, 
 printid>"" m ;operlastpart; 
 end; * 
 
 SACTlON(COpFSTPlNGDEFAULT)! 
 
 SACTIONCCOPFSTRINGFUNCTION)! 
 
 SACTIONCCOPESTRINGRELPP)! 
 
 OUTPUT RFL OPt "STRING"); 
 «ACTlON(COnFSTRINGVALUFCALl )l 
 
 DROP 
 
 ope. rat or ("load-string") j 
 end; 
 
 SACTlON(COpFSTRlNGVARIARLE)! 
 
 DROP 
 
 IF NOT NOMAMECALL THEN 
 
 COUPLEf"NANE-CALL"»SOPp(IDSTACK#I ♦ SOPPCBIGTAB* 
 SpPO(mSTaCK/STpP#fnTRY)#IPSTaCkPTR)#LEVFL)# 
 SpPD(IOSTACK#I#DlSPIACENENT)#PRINTIP); 
 
 LASTTVPF «- STR; 
 
 NONAMFC.ALL * FALSE; 
 
 END; 
 SACTlON(CPrFSTPUCTUREACTUALPAPAMETER)! 
 SACTION(COpF SXpR) « 
 
 DROP 
 
 0PERATpR("SX0R")J 
 
 end; 
 
 OO64O6OO 
 00640700 
 006/10600 
 00640900 
 00641000 
 00641100 
 00641200 
 00641300 
 00641400 
 00641500 
 00641600 
 00641700 
 00641600 
 00641900 
 00642000 
 00642100 
 00642200 
 00642300 
 00642400 
 00642500 
 00642600 
 00642700 
 00642600 
 00642900 
 00643C00 
 00643100 
 00643200 
 00643300 
 00643400 
 00643500 
 00643600 
 00643700 
 00643600 
 00643900 
 00644000 
 00644100 
 00644200 
 00644300 
 00644400 
 00644500 
 00644600 
 00644700 
 00644tt00 
 00644900 
 00645000 
 00645100 
 00645200 
 00645300 
 00645400 
 00645500 
 00645600 
 00645700 
 00645600 
 00645900 
 00646000 
 00646100 
 00646200 
 00646300 
 00646400 
 00646500 
 00646600 
 
221 
 
 OR MESSAGE IF 
 S TYPE ID OF T 
 
 JACTIOMCODETRUE) J 
 DROP 
 
 OP£RATnR<"TRUE"); 
 END J 
 tACTlON(CODFUPPER)t 
 tACTlOMClirEUPPERBDUND)! 
 JACTION(CODEXOR) J 
 DRCJP 
 
 OPERATpRCxOR H ); 
 ENDJ 
 $ACTlON(CURPF.NTACCESSID)l 
 
 COMMENT THIS ACTION' PRINTS AN ERR 
 SCANNED MS NOT THE SAME AS THE ACCES 
 CUKRENTLY BEING DEFINED; 
 DROP 
 IF SOPD(BIGTAB,*OPD(MSTACK>*TOP> ENTRY )>IDSTACKPTR) 
 
 * CllPRENTPROCLDURElD 
 THEN 
 BEGIN 
 
 ErRMS "THIS IDENTIFIER SHOULD HAVE pEEN ",»»", 
 POINTER ($OPD(PIGTAB*(I**OPDCIDSTACK, 
 
 CURRENTPROCE 
 BlGTAPPTRm 
 
 for s0pd(pigtap>i-1>idlength), «»«,",«; 
 writehesout 
 end; 
 end; 
 
 SACTIONCENDOFACCESSBODY)! 
 
 COMMENT THIS ACTION 
 STRUCKlRETAB AND POINTS 
 THE LIST. FURTHERMORE, 
 PROCEDUPF-S POINTED T0(IN 
 DROP 
 
 FOR I ♦ 1 STEP 1 UNTIL IDCOUNTER 
 BEGIN 
 
 IF BOOLEANCtOPPdDSTACK^tTO 
 
 THEN 
 
 BEGIN 
 
 $PUSH(STRUCTURETAR,*AL 
 
 SlNCR($OPO( IDSTACK#CUP 
 
 NUMBRSUBSTP 
 
 IF POINTEP(*OPDCBIGTAB 
 
 (J ♦ * 
 
 THE ID JUST 
 HE ACCESS TY 
 
 PE 
 
 DUREID' 
 )*SALL>) 
 
 ENTERS THE AC 
 
 THE STRUCTURE 
 
 THE FETCH AND 
 
 STRUCTURETAB 
 
 CESS PROCEDURE 
 POINTER AND C 
 STORE TYPES A 
 
 )FOP DOING FFT 
 
 S IN AN ARRA 
 OUNTER FIELD 
 RE SET AND T 
 CHES AND STO 
 
 DO 
 P+ 1»I> ACCESS-PROCEDURE)) 
 
 LOF(IDSTACK,$T 
 RENTPROCEDUREI 
 UCT)); 
 » 
 
 OPD( IDSTACK>$T 
 BIGTABPTP) 
 BlGTAB/J-lMDL 
 
 OP+i-I)); 
 
 OP+I-I* 
 
 + 1 )>*ALD) 
 
 ENGTH) = 5 
 
 e "FETCH" AND «OPP( 
 THEN 
 BEGIN 
 
 IF SOPD(STRUCTURETAR,STOP>NUMPROFPAPMS) = 1 
 
 THEN 
 
 BEGIN 
 
 SENTEPCIDSTA 
 FETCH 
 FETCH 
 
 IEOUREID* 
 
 • TRUCTURETAB' 
 
 1> 
 
 CK*f URPFNTPPOC 
 
 PROCEDUPEl PTS' 
 
 TYPE! 
 
 SOPDC STRUCTURETAB** TOP, TYPE)) 
 
 END 
 
 ELSE 
 
 BEGIN 
 
 errms "a fft 
 "no par 
 writemesout 
 
 ch procedurf may have "# 
 ameters."; 
 
 end; 
 
 go 
 oo 
 oo 
 oo 
 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 Y INOO 
 S ATOO 
 HE 00 
 
 res;oo 
 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 
 oo 
 
 00 
 
 6^6700 
 646600 
 646900 
 647000 
 647100 
 647200 
 647300 
 647400 
 647500 
 647t,00 
 700100 
 700200 
 700300 
 700400 
 700500 
 700600 
 7007P0 
 700600 
 700900 
 701000 
 701100 
 701200 
 701300 
 701400 
 701500 
 701600 
 701700 
 701800 
 701900 
 702000 
 702100 
 702200 
 702300 
 702400 
 702500 
 702600 
 702700 
 702600 
 702900 
 703000 
 703100 
 703200 
 703300 
 703400 
 703500 
 703600 
 703700 
 703600 
 703900 
 704000 
 704100 
 704200 
 704300 
 704400 
 704500 
 704600 
 704700 
 704b00 
 704900 
 705000 
 705100 
 
222 
 
 "STORE* 
 ■ 5 
 
 END 
 ELSF 
 
 IF POINTE"P(*OPDCBTGTAB»J»SALL)> ! 
 AND fC)PD(RlGTAP> J-WIDLEKGTH) 
 THEN 
 BEGIN 
 
 IF $PPD(STRUCTUPETAB*STOP»NUMBROFPAPMS> = ? 
 
 THFN 
 
 BEGIN 
 
 SENTEPCIDSTACK»CURRFNTPROCFDURFlD' 
 
 STORE PROCEDURE I PtStPUCTURETAB-1 > 
 STDPETYPFI JrPD(STRtlCT(lHt TAB> 
 
 s.opdcsthucturetab* 
 
 stop* 
 
 FORMALPARMPTR)+l' 
 TYPE)) 
 END 
 ELSE 
 BEGIN 
 
 FRRNS "STORE PROCEDURES ARF ALLOWED '"» 
 "TO HAVE AND MUST HAVE EXACTLY "> 
 "ONE FORMAL PARAMETER."; 
 WRITEHESOUT 
 
 ENT 
 
 END 
 
 end; 
 
 end; 
 
 SOPD(lOSTACK»CllRRFNTPROCEDUREln*STRuCTHPEPTR) 
 PTSTRUCTHPLTAB-i; 
 
 sexeC(FNdofprocfdurfbody); 
 
 END) 
 tACTlON(ENDOFACCESSHEADING)! 
 
 COMMENT 
 A CHECK IS 
 DROP 
 
 FOR I 
 BFGIN 
 
 THIS ACTION CLEANS UP AfTER AN ACCESS HFADING. 
 MADE TO INSURE THAT ALL FORMAL PARAMETERS WERE DECLARED; 
 
 ♦ 1 STEP 1 UNTIL IDCOUNTER DO 
 
 $PV SH(STRUCTiiRFTAR,SALLOFfIDSTAC^#*TOP+l-I))j 
 TF NOT BOOLEAN($OPD(lDSTACK,$TOP*H/sSBEENSPFO) 
 THEN 
 BEGIN 
 
 ERRMS "FORMAL PARAMETER % PO I NTER ( $PPD C P I GT AB t 
 $OPD(IDSTACK.$TpP,BIGTaPPTR)+1,$aLL))FOR 
 $OPDfBlGTAP*SOPDClDSTACK,$TOP*BIGTABPTR)/ 
 
 IDLFNGTH)* 
 " NOT DECLARFD IN ACCESS HEADING."; 
 WRITEMESOUT 
 
 END) 
 
 IF IDCOUNTER > 
 
 THFN 
 
 BEGIN 
 
 $fnter(idstack,currentprocedureid» 
 
 formalparmptrl ptstpucturetab-1, 
 numprofparms) idcounter) 
 Enid; 
 
 sfxeccscansubstructorf); 
 end; 
 sactlon(endofaccfssparametfrscan)« 
 ccmmfnt this action cleans 
 declaration have been scanned) 
 
 UP ArTER THE PARAMETFRS IN AN ACCESS 
 
 00705200 
 00705300 
 00705400 
 00705500 
 00705600 
 00705700 
 00705600 
 00705900 
 00706000 
 00706100 
 00706200 
 00706300 
 00706400 
 00706500 
 00706f 00 
 00706700 
 00706600 
 00706900 
 00707000 
 00707100 
 00707200 
 00707300 
 00707400 
 00707500 
 00707600 
 00707700 
 00707600 
 00707900 
 00706000 
 00706010 
 00706100 
 00706200 
 00706300 
 00706400 
 00706500 
 00706600 
 00706700 
 00706600 
 00706900 
 00709000 
 00709100 
 00709200 
 00709300 
 00709400 
 00709500 
 00709^00 
 00709700 
 00709600 
 00709900 
 00710000 
 00710100 
 00710200 
 00710300 
 00710400 
 00710500 
 00710600 
 00710700 
 00710600 
 00710900 
 0071 1000 
 00711100 
 
223 
 
 $EXEC(FNPOFACTUALPARAMFTFRSCAN) 
 tACTlONCFNOTF ACCFSSPROCFDUPEPODY) J 
 CLMMFNT THIS TFRMlNATFS AN 
 $FXEC(F!^DOFPPOCEDUREBOrY); 
 lACTlON(ENpOFACTUALPARAMETFRSCAN)» 
 COMMENT THIS ACTION POPS TH 
 VARIABLFS OFF OF ACTUAl P ARMST AC 
 PARAMETER SCAN; 
 DROP 
 
 IF currentactualparametepcount 
 
 THEN 
 BEGIN 
 
 errms "too few actual para 
 writemesout 
 end; 
 
 $POP( ACTUALP ARMST ACKfCliRPENT ACT 
 
 tpop( actual p armst a c io current num 
 spop( ac tualp armst ack^curpentfor 
 end; 
 
 |ACTlON(ENDOFRLOCK)« 
 
 COMMENT THIS ACTION POPS AL 
 AND STRUCTliRETAB THAT ^ERE DECl 
 DROP 
 
 SPCPdDCOUNTFRSTACKt IDCOUNTER); 
 FOR I «- 1 STEP 1 UNTIL IDCOUNTE 
 BEGIN 
 
 SFNTER(PlGTAB»$OPD(IDSTACK 
 
 SEMI $OPD(TDSTACK 
 
 IF $OPD(IDSTACtoSTOP>PROCF 
 
 or topdcidstack»stop#tv 
 thfn ptstructurftab «■ sopp 
 jpop(idstack); 
 end; 
 
 idcounter <■ 0; 
 end; 
 &ac t i on (endof dat a declarations 
 
 comment this action cleans 
 may have bfen left on vhtlf sca 
 currentdecltypf «■ currfntdfclow 
 cuprentdeclmacro «■ current 
 ^actlon(enoofdfclist): 
 
 commfnt reset isdefh'ed and i 
 each id encountered. thfn push 
 
 DROP 
 
 tPUSHUPCOllNTERSTACKl IpcPUNTER) 
 
 FOR I t 1 STEP 1 UNTIL IDCOUNTE 
 
 BEGIN 
 
 $fntercbigtab»sdpd(idstack 
 isdefinedh > 
 ispeingdffinedjO); 
 end; 
 
 IDCOUNTER f 0; 
 
 end; 
 tact i on ( e ndof entire structure decl ar a 
 commfnt this action cleans 
 declaration has been scanned; 
 structupeisown ♦ false; 
 
 fcACTION(ENPPFFOPHALS)! 
 
 comment this action resets 
 switches; 
 
 SPOP( F OPM ALSW I TCHSTACK i SCANNING 
 
 J 
 
 ACCESS PROCEDURE BODY; 
 
 E ACTUAL PARAMETER SCANNING 
 K AND TERMINATES AN ACTUAL 
 
 < CUPRENTNUMnEROFFORMAL PAP A METERS 
 
 METERS HAVE BEEN SUPPLIED." J 
 
 ualpapametercpunt5; 
 
 rfrofformalpapamfters); 
 
 malparameterlistpointer); 
 
 L OF THE VARIABLES OFF OF IDSTACK 
 ARFD IN THE LAST BLOCK; 
 
 R DO 
 
 ,ST0P,RIGTARPTR)> 
 
 >$TOP#OLOSEMFIELD))J 
 
 DMRE)=1 
 
 PF)=STRUCT 
 
 (IDSTACK,$TOP,STRl)CTPTRBEFORE) I 
 
 UP ANY OWN/ NODE* ETC. FLAGS THAT 
 NNING A DATA DECLARATION ; 
 N ♦ CURRFNTDFCLNODE * 
 ACCESSID «- 0; 
 
 SPEINGDEFINEO BITS IN BlGTAB FOR 
 THE ID COUNT ; 
 
 ; 
 
 R DO 
 #$T0P*1-I*BIGTABPTR)# 
 
 T TON 5 I 
 
 UP AFTER AN ENTIRE STRUCTURE 
 
 ALL FORMAL PARAMETER SCANNING 
 FPRMALPARAMFTFRDECLARATIONS); 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 007] 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 007l 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 007i 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
 0071 
 
22i| 
 
 *ACT I 
 
 R 
 D 
 J 
 
 $ 
 
 S 
 
 F 
 
 SACTI 
 
 D 
 
 P 
 H 
 D 
 F 
 B 
 
 ON(EN 
 
 com 
 
 ESETS 
 RGP 
 PUP(P 
 F.XFCC 
 EXEC( 
 NDJ 
 ON(E.N 
 CUM 
 FCLAR 
 ROCED 
 EADIN 
 ROP 
 OR I 
 EC IN 
 $ 
 I 
 T 
 B 
 
 PPFPROCEDUREPODY) t 
 
 MEM THIS ACTION POPS THE FORMAL PARAMETER DECLARATIONS AND 
 IDSTACK TO ITS CONDITION PRIOR TO CALLING THIS pKOCEDOREj 
 
 ROCEnUREIDSTACK»CUFRENTPPOCEDuREID)J 
 ENDOFSTRUCTUREDECLARATiON)! 
 
 fmdofstructure declaration)) 
 
 dofproceooreheadtng); 
 
 ment this action tests that all formal papamfters were 
 fo and does an eno of block thing pefhre entering the 
 i're pddy. it also checks that forward declarfd procedure 
 gs are compatible with the final declaration; 
 
 4- 1 step 1 until idcounter do 
 
 PUSH(STRUCTURFTAp,SALLOF(lDSTACK*$TOP+l-I ))) 
 
 F SOPD( IDSTACK>$TOP>HASBEENSPEC) = 
 
 HEN 
 
 EGIN 
 
 ERRMS "FORMAL PARAMETER NOT DECLARFD IN PROCEDURE ", 
 "HEADING."* 
 
 writemesout; 
 no; 
 
 E 
 NO) 
 
 F IDCOUNTER > 
 HEN 
 EGIN 
 
 $ 
 
 E NTER (IDSTACK* CURRENT PROCEDllRP ID* 
 
 FORMALPARMPTR » PTSTRUCTl'RETAB-1* 
 NUMBROFPARMS t IDCOUNTER) 
 ND) 
 F $OPD(BlGTAB,$OPr>uDSTACK*CURRFNTPROCEDURElD,PlGTAPPTR)* 
 
 FOPWARDDEFINED) = 1 
 OMMENT NOTE THAT FOP W A RDDE F I NFD IN IDSTACK IS FROM THE 
 LDSEMFIELD OR PREVIOUS DEFINITION OF THIS IDENTIFIER? 
 HEN * 
 
 EGIN COMMENT CHECK THIS DUDE OUT FOR COMPAT Ab IL I T Y WITH HIS 
 FORWARD DEFINITION) 
 
 IF $0PDCIDSTACK*CURPENTPRPCFDUPEID, NUMBROFPARMS) # JDCOUNTER 
 THEN NPFORWAROMATCH 
 ELSE 
 BEGIN 
 
 LABEL LOOP) 
 
 I <- PTSTPUCTliRF-TARj 
 
 J * SGPDf IDSTACK»CURRENTPROCEDt!REID*FORNALPARMPTR) + U 
 
 FOR K <- 1 STEP 1 UNTIL IDCOUNTER DO 
 
 BEGIN 
 
 IF NOT FQUALSTRUCTURFTABf I-K> J-K) 
 
 THEN 
 
 BEGIN 
 
 noforwardmatch; 
 leavf loop 
 
 END 
 END) LOOPt 
 END) 
 END) 
 
 f EXEC (SCANSUB STRUCTURE)) 
 END) 
 SACTI ON (ENDOFSTRUCTUREDECLARATION) I 
 
 COMMENT THIS ACTION TERMlNATFS THE SCAN OF A STRUCTURE 
 
 00717200 
 
 007J7300 
 
 0071 7400 
 
 00717500 
 
 007J7600 
 
 00717700 
 
 007l 7800 
 
 00717900 
 
 00716000 
 
 0071M00 
 
 00716200 
 
 0071 6300 
 
 00718400 
 
 00716500 
 
 00716600 
 
 007J6700 
 
 00716600 
 
 00716900 
 
 00719000 
 
 00719100 
 
 00719200 
 
 00719300 
 
 00719400 
 
 00719500 
 
 00719600 
 
 00719700 
 
 00719800 
 
 00719900 
 
 00720000 
 
 00720100 
 
 00720200 
 
 00720300 
 
 00720400 
 
 00720500 
 
 00720600 
 
 00720700 
 
 00720600 
 
 00720900 ; 
 
 00721000 
 
 00721100 
 
 00721200 
 
 00721300 
 
 00721400( 
 
 007?1500 
 
 00721600 
 
 0072170 
 
 00721800 
 
 00721900 
 
 00722000 
 
 00722100 
 
 00722200 
 
 00722300 
 
 00722400 
 
 0072250 
 
 0072260 
 
 0072270 
 
 0072280 
 
 00722900 
 
 00723000 
 
 00723100 
 
 00723200 
 
225 
 
 DECLARAT 
 STACK AN' 
 THE ID L 
 ENTRY rr 
 OF ID FN' 
 THE IDS 
 IN TNE S 
 STRUCT UP 
 STRUCTUF 
 STRUCTliR 
 ARE PDPP 
 TO PEIKG 
 
 jMMENT 
 
 ION LIST, THE IDL I STCHUNTER IS POPPFD FROM STRUCTUPFPApM- 
 D IDENTICAL ENTRIES ARF MAOF IN STRIICTuRFTAp FOR FACH ID I 
 1ST ASSOCIATED WITH THIS STPUCTURE, THE RESULT IS ONE ID 
 R THE STRUCTURF IN THE ID STACK AND A POINTFR TO AN ARRAY 
 TRIES IN STRUCTURFTAP. THE ID ENTRIFS IN STRUCTURETAR ARE 
 IN THE SUP-STRUCTURE IN THE ORDER IN WHICH THEY OCCURRFQ 
 UP-STRUCTURE DECLARATION. SHOULD AMY OF THFSE IDS IN 
 ETAP REPRESFNT SUBSTRUCTURES WlTHlM THE CURRENTLY DEFINED 
 l> THEY WILL POINT TO ANOTHFR SUR-STPUC TURF ID ARRAY IN 
 ETaB. BIGTAP ENTRIES POINTING TO THF SUP-STRUCTURE IDS 
 ED AND ALL IDS IN THE CURRENT LIST OF DECLARATIONS ARE SET 
 DEFINED AGAINJ 
 
 STRUCTURF ACINTEGEP A>PJ STRUCTURF XCPOINTER LEFT*RIGHT) 
 STRING NAMF) 
 STRUCTURE ENTRIFS: 
 
 BIGTAB 
 
 STRUCTURETAR 
 
 IDSTACK 
 (PIGTAFPTR) 
 + .... ................. .............. 
 
 t 
 
 I (PIGTAPPTR) 
 ,<.... ........ ... + 
 
 t t 
 
 V (IDSTACKPTR) J ( STRUCTURFPTR ) 
 A , ....... ---..-> M .....-..-.........> Al(INTEGER) 
 
 (STl'CT-fl FNTRIFS) 
 (BIGTAPPTP) 
 
 t t 
 
 V (IDSTACKPTR) I 
 £),.-..... — -.--> (N uLL) Bl(INTEGER) 
 
 (BIGTAPPTP) 
 
 + . ............. ..........I 
 
 ( 
 
 V (IDSTACKPTR) 
 
 x , ....... --.-.-> (NULL) 
 
 (BTGTAPPTR) 
 
 Xl/STRUCT-? ENTRIES)---* 
 
 (IDSTACKPTR) 
 ♦ •-> LEFT t ---> (NULL) 
 
 I 
 
 « (PIGTAPPTR) 
 
 4......... ............... ...... 
 
 I 
 
 NAHEUSTRIWG) 
 
 (IDSTACKPTR) 
 
 ♦ — > RIGHTI— """ > (NULL) 
 
 I 
 
 t (PIGTAPPTR) 
 
 +•--- ............. ............. 
 
 (TDSTACKPTR) 
 — > NAME ,----------> (NULL) 
 
 I 
 
 I CSTPUCTUREPTR) 
 
 , + .......... ......< 
 
 ! 
 
 : 
 t 
 t 
 t 
 
 4.... 
 
 1 
 
 1 
 
 t 
 1 
 t 
 
 +..--> LEFTI(POINTER) 
 
 Q07P3300 
 N00723400 
 00723500 
 00723600 
 00723700 
 00723800 
 00723900 
 00724000 
 0072*100 
 0072^200 
 00724300 
 00724400 
 00724500 
 J007246O0 
 00724700 
 00724600 
 00724900 
 00725000 
 00725100 
 00725200 
 00725300 
 00725400 
 00725500 
 00725fc00 
 00725700 
 00725800 
 00725900 
 00726000 
 00726J00 
 00726200 
 00726300 
 00726400 
 00726500 
 00726600 
 00726700 
 00726600 
 00726900 
 00727U00 
 00727100 
 00727200 
 00727300 
 00727400 
 00727500 
 00727e00 
 00727700 
 00727600 
 00727900 
 0072b000 
 00726300 
 00728200 
 00726300 
 00726400 
 00726500 
 00726600 
 00728700 
 00726800 
 00726900 
 00729000 
 00729100 
 007292C0 
 00729300 
 
226 
 
 WHE 
 ENT 
 THE. 
 HAV 
 WIL 
 DRL 
 SPU 
 SPD 
 SPO 
 SPD 
 SPD 
 $PD 
 
 FOR 
 BEG 
 
 N THIS 
 RV FPR 
 
 1CSTAC 
 F BEEN 
 
 l exist 
 
 p 
 
 P( STPUC 
 PC STPUC 
 P(STPIC 
 PCSTRUC 
 P( STPUC 
 P(FPPM 
 CcMMFNT 
 
 I «- 1 
 IN 
 
 FDR J 
 BEGIN 
 
 end; 
 
 SEME 
 
 END? 
 
 FOR 
 BEG 
 
 COMMENT 
 
 I <- 1 
 IN 
 
 SENTE 
 
 END; 
 
 SpPP( 
 SdECR 
 
 BLL 
 SPD 
 FOR 
 BEG 
 
 END 
 
 END 
 
 SACTION 
 
 FOR 
 PAR 
 OUE 
 QUE 
 STA 
 DRD 
 SEN 
 SPD 
 
 COMMENT 
 
 ck ids; 
 
 PdDCDU 
 
 I «- 1 
 IN 
 
 SEN7E 
 
 ; 
 ; 
 
 CENTFRA 
 COMMENT 
 
 LATFR 
 AHETFR 
 UE TYPE 
 HE NAME 
 TEMENT 
 P 
 
 TERflOS 
 Sh( IDST 
 
 ACTION IS COMPLETE, T 
 
 EACH ID IN THE ID PAP 
 
 K AND ALL IDS CONTAIN 
 
 PEHOVFD FROM THE STAC 
 
 IN SThUCTURF TAB FOP 
 
 TUREPARM^TACKtCURRENT 
 TUREPARS'STACKlCUhRENT 
 TDREPAHMSTACKt CURRENT 
 TUPEPAKMSTACK* IDLISTC 
 TUREPAhMSTACH iCURRENT 
 LSWlTCHSTACKiSCAMNINT, 
 MAKE ENTRIES IN STR 
 STEP 1 UNTIL IDLISTCn 
 
 «• 1 STEP 1 UNTIL IDC 
 
 *PUSH(STRUCTURETAP>$A 
 
 P(IDSTACK,STpP+l-lDCO 
 STRUrTUREPT 
 NU^BPSUPSTR 
 
 PUT SEN FIELDS BACK 
 STEP 1 UNTIL IDCPUNTE 
 
 R(RlGTAR*fOPDClDSTACK 
 
 SEHJ sdpdcidstack 
 
 IDSTACK); 
 (CURRENTMAXIMUMDISpLA 
 
 RESET ISPEINGDEFINE 
 
 RIC.HTKPOINTER) 
 
 he idstack will contain one new 
 t, thesf ids will pf on the top 
 ed within the sub-struc turf wili 
 k. a completf stpucturf descrip 
 fach id in the id part; 
 
 dfcltype); . 
 
 declmacro); 
 dfclnode); 
 
 OUNTFR); 
 
 DECLOKN); 
 
 FORMAl.PARAMETERDECLARATIONS)j 
 
 UCTURETAP; 
 
 UNTER DO 
 
 OUNTER DO 
 
 LLOFrlDSTACK»STOP+l-j)); 
 
 ID 
 
 OF 
 
 UNTER-I* 
 Rt PTST 
 UCTIIDCO 
 
 RUCTUPETAP-1# 
 UNTER)) 
 
 INTO bigtab; 
 
 R DO 
 
 >$TOP>Rl 
 *STOP*OL 
 
 GTABPTR)* 
 DSEMFIELD)); 
 
 cfmend; 
 
 D PITS IN BIGTAb FOR ALL CURR*ENT 
 
 NTERSTACKt iDCOUN 
 STEP 1 UNTIL IDC 
 
 RCBlGTAB'SOPPdD 
 ISDEFI 
 ISPEIN 
 
 CCESSFPOCEDUPEID 
 
 THIS ACTION MA 
 
 COLLECTION IMP 
 
 FNTRY OF THE FlP 
 
 DOING THIS FO 
 
 APPEAR IN THE F 
 
 OR FUNCTION CALL 
 
 TACK, STOP, ACCESS 
 ACK* SAL I OJ 
 
 SALL 1» 
 
 SALl 2» 
 
 SALL 3S 
 
 BIGTAPPTRl 
 
 TFP)I 4 
 
 OUNTFR DO 
 
 STACtoSTOP + l-I>BIGTABPTR)> 
 
 NED»0» 
 
 GDEFINEDM )J 
 
 )t 
 
 RKS A 
 STRUC 
 ST PA 
 RCES 
 IRST 
 
 ; 
 
 PPOCF 
 
 
 
 
 
 c 
 
 OLDSEMFIEIDI 
 
 PROCEDURF TO BE AN ACCESS PRPCE 
 TURETAR, IT ALSO MAKFS A FORMAL 
 RAMETER. THTS PARAMFTFR IS THE 
 LATER SYNTAX TO RFGUTPE THAT THF 
 PARAMETER SLDT IN THE PROCEDURE 
 
 DURE i 1 )J 
 » 
 
 > 
 t 
 
 I«-$OPD(IPSTACK> 
 
 SOPDCPFOCEDURFIDSTACK>STP 
 BIGTAPPTR)), 
 *OPD(RIGTAp# I»SEM), 
 
 
 00 
 00 
 
 00 
 00 
 
 TIONOO 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 
 DUREOO 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 • 00 
 00 
 00 
 00 
 00 
 00 
 00 
 
 P>> 
 
 729400 
 
 729500 
 
 7?9600 
 
 729700 
 
 7296.00 
 
 729900 
 
 730000 
 
 730100 
 
 730200 
 
 730300 
 
 730400 
 
 730^00 
 
 730600 
 
 730700 
 
 730600 
 
 730900 
 
 731000 
 
 731100 
 
 731200 
 
 731300 
 
 731400 
 
 731500 
 
 731600 
 
 731700 
 
 731600 
 
 731900 
 
 7320C0 
 
 732100 
 
 732200 
 
 732300 
 
 732400 
 
 732^00 
 
 732600 
 
 732700 , 
 
 732600 
 
 732900" 
 
 733000; 
 
 733100' 
 
 733200; 
 
 733300. 
 
 733400; 
 
 733500, 
 
 733600i 
 
 733700' 
 
 733600^ 
 
 733900: 
 
 734000'. 
 
 73^100 
 
 734200 
 
 734300 
 
 734400 
 
 734b00 
 
 734600 
 
 734700 
 
 73^600 
 
 73490C 
 
 735000 
 
 735100 
 
 73520C 
 
 735300 
 
 73540C 
 
227 
 
 formalparmi 
 
 HASREENSPECl 
 
 TYPE* 
 ACCFSSTYPFl 
 
 DUMMYPARMI 
 $INCR(iPCOliMER); 
 END* 
 ,CTlOMENTFRlDlNDECLSTACK)l 
 DROP 
 IF SCANNINGFORMALPARAMFTFRDF. 
 
 THEN 
 BEGIN 
 
 IF NOT BOOLEANCSOPDf BIG 
 ISFEIN 
 THEN 
 BEGIN 
 
 FPRMS "THIS ID IS 
 WRITEMESOUT 
 END 
 E| SE 
 BEGIN 
 
 $FNTER(IDSTACK»I** 
 
 1, 
 1, 
 
 ACCES5VAR, 
 
 CURRENTMAXACCESSNUMBER, 
 
 1)1 
 
 CLARATlONS 
 
 TAR,SOPD(MSTACK,STOP,FNTRY), 
 GOEFINED)) 
 
 NOT A FORMAL PARAMETER.") 
 
 TYPE: 
 
 NODE! 
 
 MACRO: 
 
 LEVFLt 
 
 DISPLACFMFNTl 
 
 HASPEENSPFCI 
 tlNCRCCUPRFNTMAXIM 
 IF CURPENTACCESSID 
 THEN 
 BEGIN 
 
 SENTER(IDSTAC 
 ACCESS 
 SOPDCI 
 STORET 
 SOPD(I 
 FETCHT 
 SOPPd 
 FETCHP 
 fOPD(I 
 STOREP 
 SOPDd 
 FETCHA 
 $OPD(I 
 STOREA 
 SOPDd 
 
 fnd; 
 $incr(idlistc0untf 
 
 OPPCBIGTAR, 
 
 SOPD(MSTACK,STPP, ENTRY), 
 
 IDSTACKPTR), 
 
 CURRENTDECLTYPF, 
 
 CURRENTDECLNODF, 
 
 CURRENTDECLMACPO, 
 
 CURRENTLEVFL, 
 
 CURRENTMAXIMUMDISPLACEMEnT, 
 
 1)1 
 UMDISPLACEMFKT)J 
 t AND CURPENTPECLTYPE = ACCESSVAR 
 
 K,I, 
 
 TYPEl 
 
 DSTACK'CURRENTACCESSID,ACCES 
 
 YPFl . * 
 
 DSTACK*CURREMTACCESSID/STORF 
 
 YPFJ 
 
 DST AC K# CURRENT AC CESS ID, FETCH 
 
 ROCEPURFI 
 
 DSTACK'CURRENTACCESS ID, FETCH 
 
 POCFOURFt 
 
 DSTACK,CURRENTACCESSID,STORE 
 
 UXPTRt 
 
 PSTACK,CL)RRFNTACCESSID, FETCH 
 
 UXPTPt 
 
 DSTACK,CURRENTACCESSID,STORF 
 
 R); 
 
 STYPE), 
 
 TYPE)* 
 
 TYPE), 
 
 PROCEDURE 
 
 PROCEDURE 
 
 AUXPTR), 
 
 AUXPTR)) 
 
 ENP 
 
 END 
 
 ELSE 
 
 IF POOl. FAN(SOPD(BlGTAB*$OPD(MSTACK> STOP, ENTRY), I SBEINGPF 
 
 THEN 
 
 BEGI 
 
 END 
 
 n comment if this iden 
 This block, then print 
 errns "id used twicf in 
 writemesout 
 
 TIFIFR HAS ALREADY BFFN DECL 
 A MESSAGE TO THAT EFFECT I 
 SAME BLOCK - ID IGNORED"; 
 
 FINED)) 
 A RED IN 
 
 v 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 
 ),007 
 007 
 
 ),007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 007 
 
 35500 
 35600 
 35700 
 35600 
 35900 
 36000 
 36100 
 36?00 
 36300 
 36400 
 36500 
 36600 
 36/00 
 36600 
 36900 
 37000 
 37100 
 37200 
 37300 
 37400 
 37500 
 37600 
 37700 
 37600 
 37900 
 36000 
 36100 
 36200 
 36300 
 36400 
 36500 
 36600 
 36700 
 36600 
 38900 
 .39000 
 39100 
 39?00 
 39300 
 39400 
 39500 
 39600 
 39700 
 39600 
 3 9900 
 40000 
 40100 
 40200 
 40300 
 40400 
 40500 
 40600 
 40700 
 40600 
 40900 
 41000 
 41 100 
 41200 
 41300 
 41400 
 41500 
 
228 
 
 ELSE 
 BEGI 
 
 N 
 
 COMMENT PUSH A NEW ID INTO THE ID STACK. PUT THF OLD 
 PIGTAR SEMANTICS FlFLD INTO THE NEW ID AND SET DEFAULTS E 
 THIS DATA TYPE. THEN SET THE RlGTAp POINTER IN THE NEW I 
 STACK TO POINT PACK TO THE RIGTAR ENTRY/ AND* FINALLY* AD 
 TO THE IDCOUNTER TO INDICATE HOfc MANY IDS HAVE PEEK PROCE 
 INTO THE ID STACK AT THIS BLOCK LEVEL > 
 
 SPUSHCIDSTACK, 
 
 SAl L 
 $A| L 
 SAIL 
 SALL 
 
 0» 
 1 I 
 21 
 3« 
 
 TYPE! 
 
 PIGTAPPTR1 
 
 LEVEt » 
 
 DISPLACEMENT 
 
 OWN l 
 
 NODES 
 
 OLDSFMEIELDl 
 
 MACROJ 
 
 0* 
 
 0* 
 
 0* 
 
 Of 
 
 CURRENTDFCLTYPE* 
 
 SPPD(MSTAfK*STDP*ENTRY)* 
 
 CURRENTLFVEL* 
 
 CURRENTMAXIMUMDISPLACEMENT» 
 
 CURRENTDFfLOWN* 
 
 CURRENTDFCLNGDE* 
 
 *0PD(PIGTAB* 
 
 SOP0(MSTACK» STOP' ENTRY 
 SEM)* 
 CURRENTDEfLMACRO); 
 SENTERCBIGTAB, SOPDCMSTACK, STOP, ENTRY)* 
 SEM» 0, 
 
 ISPEINGDEFINEDH* 
 IDSTACKPTRJ PT IDST ACKM ) ; 
 IF PRINTOBJECT 
 THEN 
 BEGIN 
 
 bl ankmesout; 
 
 REPLACE PMESOUT PY w ( "' CURRENTLE V'eL FOR ? DjGlTS* 
 "'"'CURPEMTMAXIMUMDISPLACEMENT FOP 4 DIGITS* 
 ") s "*POlNTEP(SOPD(PlGTAP*SnPD(MSTACK*STOP» 
 FNTRY) + l'S/iLD) FOR 
 
 sopd ( blgtab'*opd(mstack# stop* entry )#idlength) j 
 
 writemesout; 
 end; y 
 
 $INCR(CURRENTMAXIMUMDISPLACEMENT)J 
 
 IE CURRENTACCESSID * AND CURRENTDECL T YPE = ACCESSVAR 
 
 THEN 
 
 BEGIN 
 
 $ENTER(IDSTACK*I, 
 ACCESSTVPEt 
 
 SDPD ( I DST AC K' CURRENT ACCESS I D'ACCESSTYPE)' 
 
 STORETYPEI 
 
 SOPD ( I DSTACK* CURRENT ACCESS I D'STORET YPE)* 
 EETCHTYPEt 
 
 SDPD( I OSTACK* CURRENT ACCESS I D*EETCHT YPE)* 
 
 EETCHpROCEDUREt 
 
 SDPD C IDST AC K* CURRENT ACCESS I D'FETCHPPOCEDURE)* 
 
 STOREPRCCEDUREl 
 
 SOPD ( I OSTACK' CURRENT ACCFSS I D#STOREPPOCE DURE)* 
 FETCHAUXPTR » 
 
 $.nPD(IDSTACK*CURRENTACCESSIP*FETCHAUXPTP)* 
 STOPEAUXPTRt 
 
 sopd ( i dstack* current access id' store auxptr)) 
 
 end; 
 
 SlNCRf IDLISTCOUNTERW 
 
 *INCR( IDCOUNTER) 
 
 end; 
 end; 
 
 00741600 
 00741700 
 00741600 
 OR 00741900 
 D 00742000 
 DNE00742100 
 SSED 00742200 
 00742300 
 00742400 
 00742500 
 00742600 
 00742700 
 00742600 
 00742900 
 00743000 
 00743100 
 00743200 
 00743300 
 00743400 
 )* 00743500 
 00743600 
 00743700 
 00743600 
 00743900 
 00744000 
 00744100 
 00744200 
 00744300 
 0074^400 
 00744500 
 00744600 
 00744700 
 00744600 
 00744900 
 00745000 
 00745100 
 00745200 
 00745300 
 00745400 
 00745500 
 00745600 
 00745700 
 00745600 
 00745900 
 00746000 
 00746100 
 00746200 
 00746300 
 00746400 
 00746500 
 00746600 
 00746700 
 00746600 
 00746900 
 00747000 
 00747100 
 00747200 
 00747300 
 00747400 
 00747500 
 00747600 
 
229 
 
 it 
 
 CURRENTNUMBROFSUPS); 
 
 CURRENTDECLTYPE 
 BEING SCANNED) 
 
 a EVNT TO INDICATE 
 
 $ACT ION (ENTERNUMREPOF SUBSCRIPTS) J 
 DROP 
 
 FOR I «- 1 STEP 1 UNTIL IDL I STCOUNTER DO 
 EE&IN 
 
 SE.MTER(IDSTACK»tTDP*l-I» 
 
 SUPSCRIPTEDt 
 NUMRPOFSUBSl 
 
 end; 
 currentnumrrofsubs * 0; 
 
 END! 
 JACT I ON (EVENT DECLARATION) J 
 
 COMMENT THIS ACTION SETS 
 THAT AN EVFNT DECLARATION IS 
 CURRENtPEClTYPF <- FVNTJ 
 §ACTI0NCF REDECLARATION) J 
 
 COMMENT THIS ACTION SETS CURRENT DECLTYPF s OSLFlLEJ 
 CURRENTDECLTYPE ♦• PSLFRE) 
 SACTIOK(FORMALPARAMETFP) l 
 
 COMMENT THIS ACTION FNTERS A FORMAL PARAMETER INTO ICSTACK. 
 THE FORMAL PARAMETFR BIT IS TURNFD ON, ALSO, THF IS BEING DEFINED 
 BIT IS TURNED ON. IF THE IS BEING DEFINED PIT IS ALREADY ON THEN 
 AN ERROR MFSSAGE IS PRINTED) 
 DROP 
 
 IF BCOLEAN(SOPD(bIGTAB,$OPD(MSTACK>*TOP*ENTRY)>ISBElNGDEF I NED)) 
 THEN 
 BEGIN 
 
 ERPMS "ID USED TWICE IN THE SAME FORMAL PARAMETER LIST - % 
 "SECOND ID IS IGNORED. "J 
 
 END 
 
 ELSE 
 
 PEGIN 
 
 WRITEMFSOUT 
 
 SpUSHClOSTACK* 
 
 $Al L Ot 
 SAIL 1* 
 SAIL 2» 
 SALL 31 
 BlGTABPTRt 
 OLDSEMFlELDt 
 
 FOPMALPARMt 
 
 SFNTERCPIGTAB* SOPDf MST AC K> STOP, ENTRY ) > 
 SEMJ 0* 
 
 ISPEINGDEFINEDH* 
 IDSTACKPTRI PTIDSTACK 
 
 $INCR(IDCOUNTER)J 
 
 0* 
 0> 
 
 Ot 
 
 SOPDC M STACK, STOP >FNTRY)> 
 
 SOPDfBlGTAB* 
 
 SOPP(M$TACK,STOP,ENTPY)> 
 
 SEM), 
 1)1 
 
 1)J 
 
 end; 
 end; 
 
 saction(fonctipnisboolean) j 
 
 saction(functionisinteger) j 
 
 SACTlOI\(FUNCTIpN!SPATTERN): 
 jACTlON(FUMCTIONlSPOINTER)t 
 *ACTlON(FUNCTIpNISSTRING)l 
 
 SEMANTICTFST 
 SEMANTICTEST 
 SEMANTICTEST 
 SEMANTICTEST 
 SEMANTICTEST 
 
 «• FUNCTtONTFST(POPL)? 
 «■ FI'NCTIONTFST(INT); 
 «■ FUNCTIONTESTfPATT); 
 
 <- FUNCTIONTEST(PTR); 
 FUNCTIONTEST(STR); 
 
 SACTlON(FUNf TIPMSSTPUCTURF)! SENA^T ICTFST«-FUNCT I ONTEST f STRUCT ) J 
 
 sactlon(getnfxtparm)j 
 
 comment this action updates the actual parameter count) 
 sincr(currfntactualparametercount); 
 siction(idisaccess)! 
 
 comment this action sets semantictest true if thf identifier 
 just scannfp is an accfss variable) 
 semantictest <• sopp( id st ack , *opd( bigtab, jopdc mst ack, stop'fntry )> 
 
 00747700 
 00747600 
 00747900 
 007480C0 
 00748100 
 00748200 
 00748300 
 00746400 
 00746500 
 00746600 
 00746700 
 00748800 
 00748900 
 00749000 
 00749100 
 00749200 
 00749300 
 00749400 
 00749500 
 00749600 
 00749700 
 00749600 
 00749900 
 00750000 
 00750100 
 00750200 
 00750300 
 00750400 
 00750500 
 00750600 
 007507PO 
 00750800 
 00750900 
 00751000 
 00751100 
 00751200 
 00751300 
 00751400 
 00751500 
 00751600 
 00751700 
 00751600 
 00751900 
 00752000 
 00752100 
 00752200 
 00752300 
 00752400 
 00752500 
 00752600 
 00752700 
 00752600 
 00752900 
 00753000 
 00753100 
 00753200 
 00753300 
 00753400 
 00753500 
 00753600 
 00753700 
 
230 
 
 IDSTACKPTR)>TYPE) = ACCESSVARJ 
 SACTI0N( inlSPpOCEDURF )« 
 
 COMMENT THIS ACTION' SFTS SFMANTICTEST TRUE IF THF ID ON THF 
 
 OF MSTACK IS A PROCFDUPE ID j 
 
 DROP 
 
 IF CIRRFNTSTRUCTURFPTR s 
 
 THEN 
 
 BEGIN 
 
 if *opd<bigtap»*opd(mstack*stop>entry)»ldstackptr) = 
 
 then semantictest «■ false 
 
 else semantictest «• bciplean(S0pd(ID5;tac<<* 
 
 S0PD(FlGTAB* 
 
 *OPD(MSTACK,$T OP /ENTRY). 
 IDSTACKPTR5* 
 PROCEDURE))* 
 IF SEMANTICTEST 
 THEN 
 BEGIN 
 
 $ENTER(MSTACK*ST0P> 
 
 PROCEDUFEPTRt $OPO(BIGtaB> 
 
 tOPD(MSTACK»STOP»ENTRY)» 
 IDSTACKPTR)* 
 PROCEDUPEPTRISINTOIDSTACKI 1); 
 
 END 
 
 END 
 
 ELSE 
 
 BEGIN 
 
 INTEGER H 
 
 I <- FlNnSlJBSTRUCTURFjPC*OPD(MSTACK#tTOP»ENTRY))l 
 
 SEMANTICTEST «■ I F I = 
 
 THEN FALSE 
 
 ELSE POOLE AN (SOPDCSTRUCTURET ARM* PROCEDURE 5 
 IF SEMANTlCTFST 
 THEN 
 BEGIN 
 
 CURRENTIDPTR «- If 
 
 sentercmstack>*top# 
 
 PROCEDUPEPTRj 1/ 
 
 PROCEDUREPTPISINTOIDSTACKJ 0) 
 END 
 
 END 
 END) 
 SACTI0N( 
 
 SUBSCRIPT counter; 
 
 incrsubscript )» 
 
 comment this action adds one to the 
 
 DROP 
 SIKCRCCURRENTNUtobRDFSUBSJJ 
 
 operator ( w make- i ndfx w ); 
 
 end; 
 $actlon(integerdeclaratton): 
 
 comment this action sfts curpentdecl. t ypf = int to indicate 
 foe are now processing an intfger declaration ; 
 
 CUhRENTDtCLTYPE <■ HiTJ 
 SACTION(INTFGERPROCEDURE)« 
 DROP 
 SEMANTICTEST * (IF CURPEN'TSTRUCTlJREPTR = 
 
 THEN *oPDCIOSTACK*CURRENTPRnCFDliPnr*TYPE) 
 
 else sopdcstructurftab#currfntidptr*type )) 
 = I mt ; 
 end; 
 
 iACTlONC INTFGERSTORF ) » 
 DROP 
 
 00753600 
 00753900 
 T0P00754000 
 0075«j00 
 0075^200 
 00754300 
 00754400 
 0075^500 
 00754600 
 0075^700 
 0075^600 
 00754900 
 > 00755000 I 
 00755100 
 00755?00 | 
 00755300 i 
 00755/400 
 00755500 
 00755600 J 
 00755700 
 00755600 
 00755900 
 00756000 
 00756100 
 00756200 
 00756300 
 00756400 
 00756500 
 00756600 
 00756700 
 00756600 J 
 ); 00756900 1 
 00757C00 
 00757100 
 00757?00 1( 
 00757300 
 00757400' 
 00757500| 
 00757600 
 00757700 
 00757600 
 00757900; 
 00756000/ 
 00756100; 
 00756200'' 
 00756300; 
 00758400 
 00756500' 
 00756600 
 THAT00756700 
 00756C00 
 00756900 
 00759000 
 00759100 
 00759?00 
 00759300 
 00759400 
 00759500 
 00759600 
 00759700 
 0075960C 
 
231 
 
 OPERATOR ("STORE- INTEGER" J ; -007599 00 
 
 END; 00760000 
 
 I-CTIONUSIDANACCESSTYPE)! 00760100 
 
 COMMFNT THIS ACTION SETS SFMANTICTEST * TRUE IF THE ID JUST 00760?00 
 
 SCANNED IS AN ALLOWABLE ACCFSS TYPE/ 00760300 
 
 SEMNTlCTEsT ♦ *OPD( IDSTACK* SOPDC Bl GTAB/> SOPO( MST ACK> STOP'ENTR Y )# 00760400 
 
 IDSTACKPTR)>TYPF) = ACCESS J 00760500 
 
 &ACTlON( LFAVELAREL )« 00760600 
 
 COMMENT THIS ACTION CHECKS THAT THE LABEL IN A LEAVE STATEMENT 00760700 
 
 IS LEGITIMATE AT THIS TI^EJ 00760600 
 
 DROP 00760900 
 
 I «■ SOPD(MsTACK,$TrtP, ENTRY)) 00761000 
 
 J «• SOFD(BlGTABM»IOSTACKPTR)j 00761100 
 
 IF «0PD(IDSTACK*J*TYPE) * LAPL 007-61200 
 
 THEN 00761300 
 
 BEGIN 00761400 
 
 ERPMS "THIS IS NOT A LApEL."; 00761500 
 
 WRITEMESOUT; 00761600 
 
 END 00761700 
 
 ELSE IF J < CURRENTPROCEDUREID 00761600 
 
 THEN 00761900 
 
 BEGIN 00762000 
 
 ERPMS "THIS LAfiEL IS OUTSIDE THE RANGE OF THIS PROCEDURE."; 00762100 
 
 WRITEMESOUTj 00762200 
 
 END 00762300 
 
 ELSE 00762400 
 
 BEGIN 00762500 
 
 $PUSH( LEA VEST A CIO S ALL 10, ADDRESS! CURRENT ADDRFSS); 00762600 
 
 OPERATORC"*** (BRANCH INSTRUCTION WILL BE HFRE) ***"); 00762700 
 
 END! 00762600 
 
 END; 00762900 
 
 iACTlON(MACPODFFINlTinN)« 0076 3000 
 
 COMMENT THIS ACTION SETS CURRENTDFCLMACR0*1 SO IT MAY BE USED 00763100 
 
 TO INDICATF MACRO VARIABLES AND PROCEDURES; 00763200 
 
 CURRENTDECLMACRO «■ l j * 00763300 
 
 ;ACTlON(MAkFSURENOPARAMFTERSAPERFQUlRED) l 007 6 34 00 
 
 COMMENT THIS ACTION MAKES SURE THAT NO PARAMFTERS MUST RE ' 00763500 
 
 SUPPLIED TO AN ACCESS DECLARATION; ■* 00763600 
 
 DROP 00763700 
 
 IF $OPD( IDSTACK,CURRENTACCESSlD#NUMPROFPARMS) * 00763600 
 
 THEN 00763900 
 
 BEGIN 00764000 
 
 ERRMS "PARAMFTERS MUST RF SUPPLIED WITH ", 00764100 
 
 P0INTER(S0PD(PK.T/\B>(I«-S0PD( IPSTACK^CURRFNTaCCESSID* 007 64 200 
 
 RIGTAPPTR)) + 1>$AID) 00764300 
 
 FOR $OPP(PlGTAB>I>IDLFNGTH)> 00764400 
 
 " ACCESS DECLARATIONS."; 00764500 
 
 WPITEMESOUT 00764600 
 
 END; 00764700 
 
 END; 00764800 
 
 ACTl0N(M0vE0SL2SEMFIELDFR0MlTD4) j 007 64 900 
 
 COMMENT THIS ACTION MOVES THE 0SL2SFMFIELD IN MSTAC* FROM 00765000 
 
 TOF-1 TO TpP-4) 00765100 
 
 S0FD(MsTACK' J T0P-4,nSL2SFMFIFLD)«-S0PD(MSTACK*ST0P-l,0SL2SEMFlELD); 00 765200 
 
 ACTI0N(M0VFDSL2SEMF I FLDFROM 1 T06 ) 3 00765 300 
 
 COMMENT THIS ACTION MOVFS THF 0SL2SEMFIELD IN MSTACK FROM 00765400 
 
 TOP-1 TT TpP-6; 00765500 
 
 $0Fn(MsTAC(oST0P-6»nSL2SFMFIELD)*$PPDCMSTACKj>ST0P-l,0SL2SEMFIELD); 00 7 6 56 00 
 
 AC TI ON (MUSTBEUN SUB SCRIPTED)! 00765 7 00 
 
 COMMFNT THIS ACTION PRINTS AN ERROR MESSAGE IF A SUBSCRIPTED 00765600 
 
 VARIABLF APPEARS WITHOUT ITS SUBSCRIPT; 00765900 
 
232 
 
 DROP 
 IFC IF 
 
 CUFvRFNTSTRUCTljREPTP = THFN 
 
 ELSE 
 
 THEN 
 BEGIN 
 
 EpRMS "SUBSCRIPT PEOU I RED . " J 
 
 WRITFMFSOUT 
 END) 
 ENDJ 
 tACTION(NODEDF.CLARATlON)l 
 
 COMMENT THIS ACTION 
 ALL IDENTIFIERS IN THIS 
 CURRfNTDtClNODF *■ 1; 
 
 4acti0nc opfm.abel 
 
 comment this action 
 declaration; 
 
 $OPD( IDSTACK* 
 
 SflPD(HIGTAP» 
 *nPD(MST 
 IDSTACKP 
 
 SUBSCRIPTED) 
 $OPD(STRUCTURETAR* 
 CUPRENTIDPTR* 
 SUBSCRIPTED)) 
 
 &CK**TOP*ENTPY 
 r P ) >■ 
 
 SETS CURRENTDFCLNODE * 1 TO INDICATE THAT 
 DECLARATION ARE OF TYPE NODF ; 
 
 ENTERS A 
 
 51 
 
 LAPEL 
 
 IN IDSTACK AS IF IT WERE A 
 
 DROP 
 
 SPUSHC IDSTACK, 
 
 SALl 
 SALL 
 SALL 
 *ALL 
 TYPFi 
 
 0« 
 1 » 
 ?» 
 
 3» 
 
 0* 
 0* 
 0* 
 
 LARI 
 
 LABEL SEGMENT: CURRENT SEGMENT* 
 
 LAPEL ST ART ADDRESS I CURRENT ADDRESS* 
 
 BlGTABPTR«S0PD(M5TAClO STOP* ENTRY)* 
 
 OLDREMF IELD I *PPD(BIGTAR**DPDfKSTACK* STOP* ENTRY)* 
 SFH))j 
 
 SENTER(BlGTAB*SOPD(MSTACK*STOP*FNTRY), 
 
 SEMJ 0* 
 
 ISDFFINFDt 1* 
 
 IDSTACKPTPl PTIDSTACK-1 ); Y 
 $PUSH(lDCOUNTFPSTACKIl)j 
 
 OPE REIRSTPART* "LAPEL "* PRlNTlD; DPERLASTPART; 
 SpECR(CURRENTAonRFSS); 
 SpUSHcLFAVESTACK*$ALL«0*MARKll); 
 
 end; 
 saction(owndeclaration)! 
 
 cpmmfnt this action rfc0gni7es the reserved word own and sfts 
 currentdeclpwn = 1 to indicate that all identiftfrs in this 
 declaration are c'e type own) 
 cuprlntoeclown «- 1 ? 
 
 sactioncpatterndeclaration)! 
 
 comment this action sets currentdeclt ypf = patt to indicatf 
 that al.l following ids in this declaration ape oe tvpe pattern; 
 currentdecltype «- pattj 
 
 SACTION(EATTeRNPR0CEDURE)» 
 DROP 
 SENANTICTEST <• (Ir CURRENTSTRUCTUREpTR = 
 
 THEN JOPD(IDSTACK*CURRENTPROCFD|iRF.lP#TYPE) 
 ELSE JOPD (STRUCTURETAB* CURRENT I DPT P* TYPE )) 
 = PATT ; 
 
 end; 
 
 $ACTlON(PATTERNSTORF)l 
 
 DROP 
 
 OPERATOR ("STORE-PATTERN")/ 
 
 00766000 
 00766100 
 
 00766200 
 )*00766300 
 00766400 
 00766500 
 00766600 
 00766/00 
 00766600 
 O0766V00 
 00767000 
 00767100 
 00767200 
 00767300 
 00767400 
 00800100 
 00800200 
 00600300 
 00800400 
 00800500 
 00800600 
 00800700 
 00600b00 
 00800900 
 00601000 
 00601100 
 00601200 
 00801 300 
 00801400 
 00801500 
 00801600 
 00801700 
 00801600 
 00601900 ; 
 00802000 ! 
 00802100 
 00802200 ; 
 
 00602300 ; 
 00802400 : 
 
 00602500 i 
 00802600 
 00802700 ; 
 00802600 j 
 00802900 J 
 00603000 : 
 
 00803100.; 
 
 00603200 i 
 
 00603300 
 
 00603400 
 
 00603500 
 
 00803600 
 
 00603700 
 
 00803600 
 
 00603900 
 
 008C4000 
 
 00804100 
 
 00804200 
 
 00804300 
 
 00804400 
 
 00604500 
 
 00804600 
 
233 
 
 END J 
 SACTlOMriHNTERDECLARATlONOt 
 
 COMMFNT THIS ACTTOk SETS CURRENTO 
 A POINTER DECLARATION IS BEING SCANNE 
 CURRENTDECLTYPE *• PTRJ 
 JACTIONCPOTNTERPRPCLDIJREX 
 DROP 
 
 SEMANTlCTEST «■ (IF CURREN TSTRtlCTUREPT 
 THEN SO'-'DC IDSTACtOCU 
 ELSE JOPDCSTRUCTURE1 
 = PTR J 
 FUV) 
 SACTIONCPOINTERSTORL) J 
 DROP 
 OPERAToRCSTORE-POlNTER'n) 
 
 end; 
 6acti0n( procedure identifier) j 
 
 comment this action enters non-st 
 
 IDSTACk AND UPDATES STRUCTURF IDS TO 
 DRIP 
 
 IF scanningformalparametfrdeclaration 
 
 THEN 
 BEGIN 
 
 IF NOT B00LEAN(t0PD(BIGTAP*S0PP( 
 ISPFINGDEFTNEO) 
 THEN 
 BEGIN 
 
 ERRMS "THIS 
 WRITE^ESOUT 
 END 
 ELSE 
 BEGIN 
 
 IF CURRENTDECLTYPE « STRUCT 
 
 THEN 
 
 BEGIN 
 
 senter(idfntry»sallofc 
 
 spop(idstack); 
 
 senter(idstack*topd(pi 
 
 SO 
 
 TD 
 
 NUMBRSURSTRUCTJSO 
 
 STPUCTUREPTRJ f,0 
 
 STpUCTPTRREFOREtS 
 
 end; 
 
 senter( idstack »sopdcb i gtap* 
 
 SOPDCMS 
 IDSTACK 
 CURRENT 
 CURRENT 
 1# 
 1)1 
 STRUCT 
 
 ECI.TYPE = 
 
 d; 
 
 PTR TO INDICATE 
 
 R = 
 
 RRENTPR0CEDUREID#TYPE) 
 
 AB»CURRENTIDPTR*TYPE)) 
 
 RUCTURF PROCEDURE IDS IN T 
 
 RE current; 
 
 MSTACK#*TOP>ENTRY)> 
 
 ) 
 
 HE 
 
 ID IS NOT A FORMAL PARAMETER . "J 
 
 TYPE: 
 
 MACRO! 
 
 PROCEDURE: 
 
 HASPEENSPECt 
 IF CURRENTDECLTYPE 
 THEN 
 BEGIN 
 
 sentercidstack'sopdcms 
 stpuctptrbefopf 
 
 fND 
 
 IDSTACK>STOP))J 
 
 GTAP, -f 
 
 PD(MSTACK,STOP>ENTRY)* 
 
 STACKPTR)> 
 
 PD( IDE NT RY*NUMPRSUP STRUCT) 
 
 PD( I DENTRY* STRUCTURE PTR)* 
 
 OPD(lDFNTRY»STRUCTPTRBEFOP 
 
 TACK*$TOP*ENTRY>> 
 
 PTR), 
 
 DECLTYPE* 
 
 DECLMACRO, 
 
 TACK»STOP#ENTRY)# 
 S PTSTPUCTURETAB) 
 
 END 
 
 END 
 
 ELSE 
 
 BEGIN 
 
 00 
 
 ob 
 thatoo 
 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 , 00 
 
 00 
 
 E));oo 
 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 00 
 CO 
 00 
 00 
 00 
 00 
 00 
 
 804700 
 
 eoifcoo 
 
 804900 
 
 eosooo 
 
 805100 
 805200 
 805300 
 805400 
 805500 
 805600 
 605700 
 805800 
 805900 
 806000 
 806100 
 806?00 
 806300 
 806400 
 806500 
 806600 
 606700 
 806600 
 806900 
 807000 
 8071OQ 
 607200 
 607300 
 807400 
 807500 
 807600 
 607700 
 607600 
 607900 
 806000 
 608100 
 808200 
 808300 
 808400 
 808500 
 808600 
 808700 
 806600 
 808900 
 809000 
 609100 
 609200 
 809300 
 809400 
 809^00 
 609600 
 809700 
 809800 
 609900 
 810000 
 810100 
 810200 
 610300 
 810400 
 810500 
 810600 
 810700 
 
23h 
 
 IF CURRENTpFCLTYPE * STRUCT 
 
 THEN 
 
 BEGIN 
 
 SPUSHODSTACK* 
 
 SALL 0» Or 
 
 SAIL 1» 0* 
 
 SAIL 2» 0' 
 
 SALL 3t Of 
 
 TYPEt CURRFN 
 STRUCTPTF^BFFPREtPTSTR 
 
 MACR0» CURRFN 
 
 TpECLTYPE* 
 UCTURETAR* 
 TDFCLMACRO)) 
 
 LND) 
 SEKTER(IDSTA 
 
 ck*stop>bIgtarptr: 
 procedure : 
 
 OLDSFMFIFLDJ 
 
 SOPD(MSTACK'STOP,FNTRY)' 
 
 1' 
 
 SOPD(P 
 
 s 
 
 IGTAB* 
 
 OPDCMSTACK*STOP 'ENTRY)' 
 
 EM))) 
 
 SENTERfPlGTAB* SOP D(MSTAC*'ST DP 'ENTRY)* 
 
 ISDEFINEPI 0/ 
 ISPEINGDEFINEDH* 
 IDSTACHPTRI PTIDSTACK-1)) 
 TER)) 
 
 ACK* STPP'ISBEINGPEFINED) - 1 
 OOLEAn(SOPP(IDSTACK*StOP*FORW 
 CANNINGfORMALPARAMETERDFCLARA 
 
 SINCR( mcouM 
 
 IF S0PP(IDST 
 AND NOT B 
 AND K'OT S 
 
 THEN 
 
 BEGIN 
 
 ERRMS " 
 t? 
 
 WRITEME 
 END) 
 END! 
 
 SPlSH(pROCED 
 CURRENTPROCF 
 
 SEXECCSCANSU 
 END) 
 $ACTI0N(PRPCESSD 
 COMMENT 
 
 that a procf 
 
 currentpeclt 
 
 sactioncfushdumm 
 
 COMKFNT 
 NOTHING ELSF 
 DROP 
 SPOSHCIPSTAC 
 
 ARPPEFlNED)) 
 
 TIONS 
 
 THIS PPPCEPURE IpFNTIFlFR HAS 
 THIS BLOCK HEAD, THE PRFVTO 
 SOUT 
 
 BFFN USED PREVIOUSLY IN" 
 US IDENTIFIER IS LOST.") 
 
 UREIDSTACK, CURRENT PROCEDURE TO)) 
 
 PUREID «■ Sppp(flGTAR»SOPD(MSTACK,STOP'ENTRY)' 
 
 IDSTACKPTR)) 
 PSTRUCTURE)) 
 
 FCLARATION): 
 
 THIS ACTION SETS CURRENTDECLT 
 SS DECLARATION Is PEING SCANN 
 YPE <- PROS; 
 YIP): 
 
 THIS ACTION PUSHES AN Ip ENTR 
 IT IS USEP TO PLANT AN ID 
 
 YPE = PROS TO INOICATF 
 EDI 
 
 Y INTO IDSTACK AND DOFS 
 FOR STRUCTURE PROCEDURES) 
 
 K* 
 
 SALL 
 
 SALL 
 
 SALL 
 
 SALL 
 
 OWNJ 
 
 TYPE: 
 
 NODFj 
 
 0: 
 If 
 2» 
 3J 
 
 0* 
 
 0, 
 
 0/ 
 
 0* 
 
 CURRENTPECL 
 
 CUPRENTDECl 
 
 CURRENTPECL 
 
 STRUCTPTRREFPREtPTSTPUCTUR 
 
 MACROl CURRENTDECL 
 
 OWN, 
 
 TYPE* 
 
 NOPE' 
 
 ETAP* 
 
 MACRO)) 
 
 FND) 
 
 SACTlONCRESFTIpL 
 
 COM HEM A 
 
 MUST AT LEAS 
 
 IDLISTCOUNTF 
 
 SACTION( RF5ETSP 
 
 COMMENT 
 
 STRUCTURE HA 
 
 AN INITIALIZATIP 
 LIST COUNTFR BAC 
 
 N IN A DECLARATION, wF 
 K TO ZERO ) 
 
 ISTCOUNTER) J 
 
 T THE END OF 
 
 T SET THE ID 
 
 R <- 0) 
 
 T )l 
 
 THIS ACTION PFSFTS CURRE NTSTRUCTUREPTR AFTER A 
 
 S BEEN COMPLETELY SCANNFD) 
 
 008 
 008 
 008 
 008 
 008 
 008 
 008 
 008 
 008 
 008 
 008 
 008 
 008 
 008 
 006 
 008 
 008 
 006 
 008 
 008 
 006 
 008 
 008 
 008 
 008 
 008 
 '008 
 008 
 008 
 008 
 006 
 008 
 008 
 006 
 008 
 006 
 006 
 008 
 008 
 008 
 008 
 008 
 008 
 008 
 008 
 008 
 008 
 008 
 008 
 008 
 008 
 008 
 008 
 008 
 008 
 006 
 008 
 008 
 008 
 008 
 008 
 
235 
 
 CURR 
 
 $ACTlON( 
 
 C 
 
 USED 
 
 THIS 
 
 SPEC 
 
 DROP 
 
 SPUS 
 
 SCAN 
 
 END) 
 
 $ACTI0N( 
 
 JACTIONC 
 
 $ACTI0N( 
 
 C 
 
 IN A 
 
 INTO 
 
 IDEN 
 
 EXCL 
 
 BLOC 
 
 DROP 
 
 SPUS 
 
 SPUS 
 
 SPUS 
 
 SPUS 
 
 SPUS 
 
 SPUS 
 
 SCAN 
 
 IDLI 
 SEXE 
 SEXE 
 
 end; 
 sact ionc 
 
 IACTI0N( 
 C 
 CURR 
 DROP 
 IF C 
 THEN 
 BEGI 
 
 ENTSTRUCTURFPTR «■ 0} 
 SCANNINGFORMALPARAMETE 
 
 DMMENT AT THE END OF 
 
 Tp TURN ON THE SCANMl 
 
 switch signals thf de 
 
 IAl PROCESSING REQUIRE 
 H(FORMALSwITCHSTACXlSC 
 
 ningformalparameterdec 
 scanptrfunction)» 
 
 SCAK'RElEASE)i 
 SCANSUBSTRUCTUPE)» 
 OMMFNT THIS ACTION PR 
 STRUCTURE DECLARATION 
 STRUCTUREPARMSTACK AN 
 TlFlERS ARE SET TO OFF 
 UDFD FROM USE WITHIN T 
 K END OPERATION AND RE 
 
 HCSTRUCTUREPARMSTACKtC 
 H(STPUCTUREPARMSTACKII 
 H( STRUCTUREPARMSTACK I C 
 HC STRUCTUREPARMSTACK «C 
 H( STRUCTUREPARMSTACK »C 
 H(FORMALSwITCHSTACKtSC 
 
 mngformalparameterdec 
 stcountfr <• 0; 
 ccfndofdeclistw 
 ccendofoataoeclaratipn 
 
 RDFCl ARATIONS) 
 
 a formal param 
 ngfopmalparame 
 claration proc 
 
 d; 
 
 anmngformalpa 
 larations «• tr 
 
 EPARFS FOR THE 
 . ALL DECLARA 
 D THEN SET TO 
 INFO SO AS TO 
 HF STRUCTURE, 
 INITIALIZE AS 
 
 URRENTOECLOWN) 
 DI ISTCOUNTER)) 
 URRENTOECLNODE 
 URRENTDECLMACR 
 URPENTDECLTYPE 
 ANMNGFORMALPA 
 LARATIONS «- FA 
 
 )) 
 
 FTER LIST* THIS ACTION IS 
 TERDECLARATJPNS SWITCH. 
 FSSnPS THAT THERE IS 
 
 RAMETERDECLAPATIONS); 
 UEI . 
 
 SCAN OF A DECLARATION LIS 
 TION PARAMETERS ARE PUSHED 
 7EPO. ALL PIGTAB 
 PRFVFNT THEIR BEING 
 
 IN FFFECT* WE PERFORM A 
 IF. WE WERE IN A NEW BLOCK* 
 
 0); 
 >; 
 
 RAMETERDFCLARATIONS) ) 
 LSE* 
 
 SETCONVERTDFFAULT): 
 
 SFTCURRENTSTRUCTUPEPT 
 OMMFNT THIS ACTION 5E 
 ENTNUMBEROFSUBSTRUCTUR 
 
 URPENTSTRUCTURFPTR a 
 
 R )t 
 
 TS UP CURRENTS 
 ES FOR A STRUC 
 
 N 
 
 I «• S0P0(BlGTAp»SrPP( 
 $OPD(MSTACK,$TpP*STRU 
 
 CUPRENTSTRUCTUREPTR «• 
 SpPDCMSTACK/STpPnUMB 
 
 cuprfntnumperpfsubstr 
 
 MSTACK*STpP,EN 
 CTURFPTR) <• 
 
 SOPDdDSTACK* 
 RSUBSTPUCT) «■ 
 UCIURES «■ SOPD 
 
 TRUCTUREPTR AND 
 TURF FIRST PART; 
 
 TRY)>IDSTACKPTR)J 
 
 I/STPUCTUREPTRj; 
 
 (IDSTACK#I*NltMBPSUBSTRUC'T) 
 
 END 
 
 ELSE 
 
 BEGI 
 
 N 
 
 sop d (mst ac k,stpp»s tructureptr) *■ 
 currentstructurfptr «■ 
 iopd(struct 
 
 sopd(mstack*stpp»numb 
 
 current numperpf sup st p 
 
 soppcstruct 
 
 URFTARy CURRENT I DPT R* STRUCTURE PTR ) ; 
 RSURSTRUCT) ♦ 
 UC TURFS «■ 
 URETAR»CURRENTIDPTR*NUMBRSUBSTRUCT)I 
 
 end; 
 
 NONAMEcALL ♦ TRUE; 
 
 end; 
 sact ion c 
 
 SACTIOM 
 SACTION C 
 SACTlONC 
 SACTIONC 
 
 sftdefaultstringlength 
 
 setpefaultstringlength 
 
 SEtPFFaULTSTRINGSI7E)« 
 SETFIXFDSTRINGLENGTH3I 
 SETSTAROK) J 
 
 )» 
 
 ANDSIZE) t 
 
 00816900 
 00817000 
 
 00817100 
 00817200 
 00817300 
 00817400 
 00817500 
 00817600 
 00817700 
 00817600 
 00817900 
 00818000 
 00818100 
 
 T008 18200 
 00616300 
 00816400 
 00818500 
 00818600 
 00816700 
 00816600 
 00816900 
 00819000 
 00819100 
 00819200 
 00819300 
 00819400 
 00819500 
 00819600 
 00819700 
 00819600 
 00819900 
 00820000 
 00820100 
 00820200 
 00820300 
 00620400 
 00820500 
 00820600 
 00820700 
 00820600 
 00820900 
 00821000 
 00821100 
 
 ;00821200 
 00821300 
 00821400 
 00621500 
 00821600 
 00821700 
 00821600 
 00821900 
 00822000 
 00822100 
 00822200 
 00822300 
 00822400 
 00822500 
 00822600 
 00822700 
 00822600 
 00822900 
 
236 
 
 ASIFPISKAIIPWFD «- 
 
 *ACTI0N(SE.TS7RINr.SIZE 
 
 tACTIONCSE TUPACCE SSPA 
 
 COMMENT THIS 
 
 AN ACCESS DPCLARA 
 
 DRIP 
 
 *PUSH(ACTUAL 
 CuRRfNTFOPMA 
 SOPD'db 
 SpUSH(ACTUAL 
 CuRRENTNUMBL 
 SPPD( ID 
 $PUSH(A'CTUAL 
 CIJPREMTACTUA 
 IP CURRENTNU 
 THFN 
 BEGIN 
 
 FRRMS P 
 
 F 
 
 WRITEME 
 END 
 
 end; 
 
 tACTlONCSETUPACTUALPA 
 COMMENT THIS 
 PUSHING AND RESET 
 POINTERS AND COUN 
 DROP 
 
 tPUSHCACTUALPARMS 
 
 CURRENTFORHAIPARA 
 
 IF BOOL 
 
 THEN $0 
 
 ELSE $0 
 
 SPUSHUCTUALPARMS 
 
 CURRENTNUMPFROFFO 
 
 IF BOOL 
 
 THFN SO 
 
 true; 
 ) t 
 
 RAMETERSCAN)! 
 ACTION PREPARES 
 TIONJ 
 
 FOR AN ACCESS PARAMETER SCAN IN 
 
 PARMSTACK'CURRENTFORMALPAPAMETEPLISTPOINTER); 
 
 LPARAMETFPLlSTPniNTER «■ 
 
 STACK/CURRFNTACCESSID#FORMAlPARMPTR); 
 
 P ARM STACKS URRE NT Ml MBEROFFOPMALPARAMETFRS); 
 
 POFFOPMALPAPAMETEPS «■ 
 
 STACK^CI'RRPNTACCESSin/NUMpPOFPAPMS); 
 
 PARMST AC K 'CURRENT ACTUALPAPAMETEPCOUNT); 
 
 LPARAK'FTFRCGUNT * 0; 
 
 mperofformalparameters t. o 
 
 OlNTER(fOPD(BIGTAB,CI«-$rPD(IDSTACK» 
 
 CURRFNTACCE5Sin#BlGTABPTR)+l)#SAtL)) 
 OR SOPDf PIGTAPM* IPLENGTH)* 
 
 ACCESS DECLARATIONS DO NOT HAVE PARAMETERS."; 
 SOUT 
 
 RAMFTfRSCAN)! 
 ACTION PREPARES FOP 
 ING THE APPROPRIATE 
 TERS ; 
 
 AN ACTUAL PARAMFTEP SCAN PY 
 FORMAL AND ACTUAL PARAMETER 
 
 ELSE *0 
 
 TACK'CUPPFNTFORMALPARAMETEPI I ST POINTER); 
 METFRl ISTPOINTER «■ 
 
 EAN(Srpn(MSTACK,$TOP-l,pROCEDUREPTPISINTOlDSTAcK) 
 PD( IDSTACK* 
 
 SOPD (MST AC IO STOP- 1# PROCEDURE PTR)> 
 
 FORMALPARMPTR) 
 PD(STPUCTURETAB* 
 
 SOPDC MST A CIO STOP- 1 > PPOCFDUREPTR ) > 
 
 FORMALPARMPTR); r 
 TAcioCUPRENTNI'MPERnFFORMALPARAMFTERS); 
 
 rmalparameters «- 
 
 ean(sdpd(mstack*stop-l*procfdureptrisintoldstack) 
 
 pdcidstack* 
 
 sopdc mst ack/f top- 1>pr0cepureptr)» 
 
 numrppfparms) 
 pd(stpucturf.tap^ 
 
 sopd (ms tack* stop- 1 > procedure ptr ) > 
 
 numbpdfparms); 
 tack'currentactualparametercount); 
 mftercount «■ 0; 
 fformalparameteps = 
 
 spushcactualparms 
 cukrentactua.lpara 
 if currentnu^bero 
 
 THEN 
 BEGIN 
 
 ERRMS "THIS PROCEDURE MAY NOT HAVE PARAMETERS." ; 
 
 WRITFMESOUT 
 
 END; 
 
 end; 
 
 COMMENT 
 
 these action 
 sactioncsetvariablest 
 sactioncskipthrpughse 
 
 DROP 
 
 IS ALL TFST THE 
 RlNGLFNCTH) I 
 
 MlCOLPN) t 
 
 TYPE OF THE NEXT FORMAL PARAMETER; 
 
 00823000 
 008?3l00 
 00823200 
 00623300 
 00623400 
 00623500 
 00823600 
 00823700 
 00823600 
 00823900 
 00824000 
 00824100 
 00824200 
 00824300 
 00824400 
 00824500 
 00824600 
 00824700 
 00824600 
 00824V00 
 00825000 
 00625100 
 00625200 
 00625300 
 00625400 
 00625500 
 008?5600 
 00625700 
 00625800 
 00825900 
 00826000 
 
 )00626100 
 00826200 
 00626300 
 00626400 
 00826500 
 00826600 
 00826700 
 00826600 
 00826900 
 
 )00827000 
 00827100 
 00827200 
 00827300 
 00827400 
 00827500 
 00827600 
 00827700 
 00827600 
 00827900 
 00828000 
 00828100 
 00826200 
 00828300 
 00828400 
 00828500 
 00628600 
 00826700 
 00628800 
 00826900 
 00829000 
 
237 
 
 DO SKAN(l) UNTIL SPPD(M 
 
 END; 
 HCTlON(STAPNOTALLOWED)! 
 
 ASTERISKALLO^ED «• FALSF 
 ICTIOM STARTSURSCRIPT 
 
 COMMENT THIS ACTION 
 
 FUSHINf, AND CLEARING CU 
 
 DROP 
 
 $PtSH(SUfcScPlPTSTACKlCU 
 
 SPUSH(SUBSCPIPTSTACKICU 
 
 $PlSH(SUBScPIPTSTACKtCL l 
 
 currentnumppofsu&s «• cu 
 end; 
 ictiomstpingdfclaration)! 
 comment this action 
 that a strug declapati 
 currentdecltype «■ str; 
 
 iCTlON(STRlNGpPOCEDURF)! 
 DROP 
 
 SEMNTICTEST «■ (IF CURP 
 THEN" * 
 ELSE t 
 * STR \ 
 END) 
 ICTIONCSTRINGSTORE)! 
 DROP 
 
 operator ("store-string" 
 
 end; 
 
 ic t j on ( structure dec larat ip 
 
 comment this action 
 
 for latep use in a strl' 
 
 STPUCTliPElSPWN * CURREN 
 CURRENTDECLTYPE «■ STRUC 
 ACTION (STRUCTURE MUST BE NAME 
 COMMFNT THIS ACTION 
 JUST DFCLApED WAS NOT N 
 DEF IMTlONs; 
 DROP 
 
 IF $OPD(BlGTAB»(I«-$OPD( 
 OR P01NTER(S0PD(BIGT 
 THEN 
 BEGIN 
 
 ERRMS "THE FIRST S 
 "NAMED ",""" 
 
 writemesout; 
 end; 
 end; 
 action (structure must be name 
 commfnt this action 
 just dfclared was not n 
 
 DEF IMTIONs; 
 DROP 
 
 IF tOpD(BIGTAP#(U 
 OR POlNTER(SOPD 
 THEN 
 BEGIN 
 
 ERRMS "THE SE 
 #" BE NA 
 WRITEMESOUT 
 END 
 
 end; 
 
 STACK, PTMSTACK*PSYM) * ";"J 
 
 )» 
 
 PREPARES TO SCAN 
 RPENTNUMBROFSUBS; 
 
 RPFNTNUMBFROFSUBS 
 RPENTSTRUCTUREPTR 
 RPENTNUMBROFSUBS) 
 RPENTSTRUCTUREPTR 
 
 A SUBSCRIPT LIST BY 
 
 TRUCTURES); 
 )J 
 
 ; 
 
 ♦ o; 
 
 SETS CURRENTDECL 
 ON IS BEING SCANN 
 
 ENTSTRUCTUREPTR » 
 OPDdPSTACK'CURRF 
 OPD(STRUCTURFTAB* 
 
 >; 
 
 N5I 
 
 SFTS CURRENTDECL 
 CTURE DECLARATION 
 TTECLOWN * l; 
 
 t; 
 
 DPASE)! 
 
 PRINTS AN ERROR 
 AMED "BASE". THI 
 
 IPSTACK#$TOP#BIGT 
 AP>I*1#*AU>) * " 
 
 TYPE * STR TO INDICATE 
 EDJ 
 
 NTPRPCEDUREID>TYPF) 
 CURRENTIDPTR#TYPE)> 
 
 TYPE AND STRUCTUREISOWN 
 
 ; 
 
 MESSAGE IF THE STRUCTURE 
 S ONIY OCCURS IN ACCESS 
 
 ABPTR)),IOLFNGTH) * 4 
 BASE" 
 
 TRUCTURE IN AN ACCESS DEFINITION MUST BF "> 
 ,"BASE"#"""'"."J 
 
 DFNTRY)! 
 
 PRINTS AN ERROR 
 AMED "ENTRY". TH 
 
 SPPD(IDSTACK»STOP 
 (PIGTAB*I+1#SALL) 
 
 CPND STRUCTURE IN 
 MFD "#"""#"ENTRY" 
 
 MESSAGE IF THE STRUCTURE 
 IS OhLY OCCURS IN ACCESS 
 
 »BJGTABPTR))#IDLENGTH) * 5 
 ) * "ENTRY" 
 
 AN ACCESS DEFINITION MUST 
 
 00629100 
 00829200 
 00829300 
 00829400 
 00829500 
 00829600 
 00829700 
 00829600 
 008299P0 
 00830000 
 00830100 
 00830200 
 00830300 
 00830400 
 00830500 
 00830600 
 00830700 
 00830800 
 00630900 
 00831000 
 00831100 
 00631200 
 00831300 
 00831400 
 00831500 
 00631600 
 00831700 
 00831600 
 00831900 
 00832000 
 00832100 
 00832200 
 00632300 
 00832400 
 008325C0 
 0O8326P0 
 00832700 
 00832600 
 00832900 
 00833000 
 00833100 
 00633200 
 00833300 
 00833400 
 00833500 
 00833600 
 00833700 
 00833600 
 00833900 
 00634000 
 00834100 
 00834200 
 00834300 
 00834400 
 00834500 
 00834600 
 "OO8347OO 
 00834600 
 00834900 
 00835000 
 00835100 
 
238 
 
 *action(STructureprocedure)i 
 
 DROP 
 SEMANTlCTEsT 
 
 (IF CURPE> ! TSTPUC 
 THEN SOPOCIDST 
 ELSE fOPDCSTRU 
 * STRUCT I 
 
 end; 
 
 *ACTION(TEsTACCE 
 DRIP 
 SEKANTICTEJT 
 
 SS ) l 
 
 SOPDC IDSTACK»tOP 
 SOPD(MStaCK**tOP 
 ■ ACCESSVARj 
 
 TUREPTR a 
 
 ArK»CllRRENTPRPCEOUREID*TYPE) 
 C TURFT AB p CURRENT I DPTR> TYPE )) 
 
 P(BlGTAB> 
 
 > ENTRY )/lOSTACKPTR)# TYPE) 
 
 ENDI 
 
 &AC7IOKC 
 
 tACTlOKf 
 
 DRCP 
 
 SEMA 
 
 THEN 
 
 END) 
 
 SACTlONC 
 
 *ACTI0NC 
 
 SACT IOKf 
 
 1ACTIOM 
 
 I ACTIOM 
 
 DROP 
 
 SEMA 
 
 THEN 
 
 END; 
 
 JACTlONC 
 
 SACTIONC 
 
 SACTIONC 
 
 SACTlOM 
 
 SACTIOM 
 
 DROP 
 
 SEMA 
 
 THEN 
 
 end; 
 
 tACTlONC 
 $ACTlON( 
 C 
 MARK 
 DRCP 
 I ♦ 
 J 
 K 
 L 
 M 
 
 IF N 
 THEN 
 BEGI 
 
 TESTBODL 
 TE5T600L 
 
 NTlCTFsT 
 CPFRATO 
 
 TEsTCODE 
 
 testeven 
 testfile 
 testintf 
 testintf 
 
 NTKTEsT 
 
 OPFRATO 
 
 EAN )J SFMANTICTFST «• TESTT YPE C BOOL )j 
 EANSTARALLPWFD)! 
 
 * astfriskallowed 
 R( m duplicate-top-of 
 
 )t SEMANTIC 
 T )l SEMANTIC 
 
 )l SFMANTIC 
 GEP )» SFMANTK 
 GERSTARALLPWED)t 
 
 «• ASTFRISKALLOWED 
 R("DUPLlCATE"TOP-OF 
 
 TESTFATTERN )l SFMANTIC 
 TESTFOINTER )J SFMANTIC 
 TEsTFROCFSS )» SFMANTIC 
 TESTSTRING )t SEMANTIC 
 TESTSTRINGSTARALLOVED)! 
 
 NTKTEsT 
 OPERATO 
 
 TEsTSTpU 
 
 valueide 
 
 OMmFNT 
 S IT TO 
 
 S0PP(MST 
 *OpD(RlG 
 tOPPCBlG 
 JOpDC ITS 
 SOPP( IDS 
 OT(POOl E 
 
 ERPMS " 
 
 * ASTFRISKALLOWED 
 RCDUPLiCATE-TOP-OF 
 
 and lasttype=fool;if semantictest 
 -stack- and -l pad-boolean"); 
 
 test ♦ testtype(oslcode); 
 test «■ tfsttypecevnt ); 
 test «• testtype(oslfile); 
 
 TEST «■ TESTTYFEdNT )) 
 
 AND LASTTYPE = INTMF SFMANTlCTEST 
 -STACK -A NO -LOAD-INTEGER*); 
 
 TFST «■ TESTTVPE(PATT ); 
 
 TFST «■ TESTTYPECPTR )j 
 
 TFST «• TESTTYPE(PRDS )| 
 
 TFST ♦ TESTTYPECStR )J 
 
 AND I ASTTYPE = STRHF SFMANTICTFST 
 -STACK -AND -L PAD-STRING"); 
 
 CTURE )» 
 NTIFIEP)! 
 
 this action 
 be value; 
 
 SFMANTICTFST <■ TESTT Y&€< STRUCT ) ; 
 TESTS THAT AN ID IS A FORMAL PARAMETER AND 
 
 ACK>iTOP>EKTPY)J 
 
 TAB»I#ISBElNfiDfFINFD)l . 
 
 TAB* I#IDSTACKPTR)J 
 
 TACK*K*FPRMALPARM); 
 
 TACK#K#VALliEPAPM)j 
 
 AN(j) AND FOPLEAN(L)) OR BOOLEAM(M) 
 
 ID MAY NOT 
 
 paramfter 
 
 SOUT 
 
 BE SPECIFIED AS VALUF - IT IS NOT A FORMAL' 
 OR IS ALREADY MaDF VALUE."; 
 
 WRITEME: 
 END 
 ELSE 
 BEGIN 
 
 tOPD(lDSTACK#K»VAlUEPARM) «■ U 
 
 end; 
 end; 
 
 *ACTl0NCVEpIFYCAN6EP0INTEDT0)t 
 SEND 
 
 00835 
 00835 
 00835 
 00835 
 00835 
 00835 
 00835 
 00835 
 00836 
 00836 
 00836 
 00836 
 00836 
 00836 
 00836 
 00836 
 00836 
 00836 
 00837 
 00837 
 00837 
 00837 
 00837 
 00837 
 00837 
 00837 
 00837 
 00837 
 00838 
 00838 
 00838 
 00838 
 00838 
 OO838 
 00838 
 OO838 
 OO838 
 00838 
 00839 
 00839 
 00639 
 00839 
 00839 
 00839 
 00839 
 00B39 
 00839 
 00839 
 00840 
 00840 
 >00840 
 00840 
 00840 
 00840 
 00840 
 00840 
 00640 
 00840 
 00841 
 00641 
 00900 
 
 200 
 300 
 400 
 500 
 600 
 700 
 800 
 900 
 OPO 
 100 
 200 
 300 
 400 
 500 
 600 
 700 
 600 
 900 
 000 
 100 
 ?00 
 300 
 400 
 500 
 600 
 700 
 600 
 900 
 000 
 lOO 
 200 
 300 
 400 
 500 
 600 
 700 
 800 
 900 
 000 
 100 
 200 
 300 
 400 
 500 
 600 
 700 
 600 
 900 
 000 
 100 
 200 
 300 
 400 
 500 
 600 
 700 
 600 
 900 
 000 
 100 
 000 
 
232 
 
 0SL2 /PCMl 
 
 LISTED BY THESIS ON JANUARY 3* 1971 AT 12 1 13 P.H. 
 
 EG IN 
 iOPJFCT 
 
 INTFCFR 1»Jp(*> 
 POINUP p«- null 
 POGLEAn TFST1,T 
 STRUCTURE Jf>P( 
 JMTEG 
 STPUC 
 
 POINT 
 I * J ♦ (K ♦ *+ 
 TFST1 «■ TFST? «- 
 JOB.NUK'PEP «- IF 
 BEGIN 
 
 INTEGER If 
 
 BOOLEAN TE 
 
 TEST1 ♦ TE 
 
 X «■ JOP.NU 
 
 - JOB 
 
 7 «- TF TFS 
 
 THFN I 
 
 FL5F C 
 
 L>mho>x>y; 
 ; 
 
 EST?J 
 
 ER NUMBrR'PPTORlTYj 
 TUPE RErOPDSC 
 
 INTEGER TIMESTARTFD,TlMEFlNlSHEn* 
 NUVREROFLINES)J 
 ER NEXT, LAST); 
 1 )*I ♦ J/KJ 
 FALSFI 
 TEST1 THEN ELSE J FIJ 
 
 «■ K + i - IF TFST1 THEN, ELSE L + M FIl 
 
 S12*TFST3> 
 
 ST? «- TFST3 ♦■ TPUF; 
 
 ^BFP ♦ jOP.RFCnRDS.TTMEFlNlSMED 
 
 . RECORDS. TIMESTARTEDI 
 
 T? AND TFSTl 
 
 F Q >= 3 THFN L ELSE M FT 
 
 ASE J OF K#K>(OL»L#L»M>M,m» 
 
 IF I «■ (* + l) MOD 50 = 2 
 
 THEN T ELSE Fl 
 
 FSAC 
 
 FIJ 
 
 TfST1 «• TF 
 END) 
 TEST1 <- TFST2 «■ 
 
 ST2 <• FALSF 
 TRUE 
 
 ND 
 
 OOOOCJOO 
 00000200 
 00000300 
 00000400 
 0000050C 
 00000600 
 000C070C 
 
 ooocopoo 
 
 00000900 
 
 ooooiooo 
 
 00001 IOC 
 00001200 
 00001300 
 00001400 
 00001500 
 00001600 
 00001700 
 00001600 
 00001900 
 00002000 
 0000210C 
 0000220C 
 00002300 
 00002400 
 00002500 
 00002600 
 00002700 
 00002fc00 
 00002900 
 00003000 
 00003100 
 
2l+0 
 
 ULIAC IV TRANSLATOR WRITING SYSTEM 
 
 nsi_? coppiifr - version i januapy 3» J 9ri at 
 
 PROGRAM PAA /PAA 
 
 l?ll4 P.M. ill 
 
 FUGlr 
 SllPjF CT 
 
 INTEGFP I « J, f *»l »M)<-0»X»Y) 
 
 OOOOOlOO 1 
 00000200 2 
 00000300 3 
 
 (00,0000) 
 (00,0001 ) 
 ( f i > 2 ) 
 (00,0003) 
 (00,C00«) 
 001 1(000 
 001 ItOOl 
 001 lOOO? 
 
 ooi ioro3 
 
 001 tCOOA 
 001 :0005 
 00 1 |0006 
 (00,0005) 
 (00,0006) 
 
 mmf-cail (00,000?) 
 
 MiT-r ALL (00,0003) 
 f- M-r -CALL (00,000«) 
 
 jmtfofr-l itfpai -rM I o 
 
 STrt-F-lMFCFR-FAF-TlAl-OFSTRliCTlvF 
 STrPf-lMFOFP-PAPTlAl-PFSTPllCTIVF 
 STpPF-lNTFGFP 
 
 POINTER F » ^' ' 'L t > 
 
 P 
 
 (00,0007 ) 
 
 0CllC(07 KAMT-fAlL (00,0007) 
 
 001 loooe ^ mi t 
 
 00110009 STr-F-F-POlNTFR 
 POLLEAN TFST1 ,TFST?> 
 
 (00,0008) = TF ^Tl 
 (00,0009) = Tf ST? 
 
 STPUCTliPF JPPC 
 
 tl'TFGER NUMBFR'PPIfRITYJ 
 
 (00,0010) = J('P 
 (00,0011) = MWpFR 
 (00,001?) 
 
 PPTOPITY 
 
 STRUCTURE REoOPOJ( 
 
 INTFGFP TIMESTARTEO.TH'FFlNlSMEO, 
 
 (C0,CC13) = PFrpPOS 
 (00,0011) = TUT STARTED 
 (00,0015) = TlMpFlMSHFO 
 
 K'MPFROFLTNFS) J 
 
 (00,0016) - Nl'MpFROFLlNFS 
 
 POINTER NEXT,LAS.T)J 
 
 00000400 
 
 ■r 00000500 5 
 
 00000600 6 
 
 00000700 7 
 
 ooooonoo e 
 
 00000900 V 
 
 000C1000 lo 
 
 00001100 11 
 
 (00,0014) = HVT 
 
■2kl 
 
 0010 MMF-CALL (00,0000) T 
 
 0011 MMF-CALL (00,0001) J 
 
 0012 MMF-CALL (00,0002) K 
 
 0013 DUPLICATE -Tpp-rr-STACK-AWD-LOAD-INTFcER 
 
 0014 mrGfP-UTFPAL-CALl 1 
 
 0015 ADO 
 
 0016 STpPF-INTEGFR 
 0016*** STpPE-INTEGFP-pAPTlAL-PESTRUCTIVF 
 
 0017 MMF-CALL (00,0000) I 
 0016 LnAPMNTEGER 
 
 0019 MULTIPLY 
 
 0020 NAmF-CALL (00,0001) J 
 
 0021 IPAP-INTEGEp 
 
 0022 MmF-CALL (00,0002) K 
 
 0023 inAn-iNTEr,EP 
 
 0021 liTVTPE 
 
 0025 Anp 
 
 0026 STpPF-INTFGFP 
 0026*** STppF-INTEGFR-pAPTlAL-PESTRuCTlVF 
 
 0027 STpPE-INTEGER • 
 
 TEST1 <• TEST2 «■ FALSE) 000013001 13 
 
 001:0028 KAMF-CALL (00,0006) TFSTl 
 
 001:0029 NAME-CALL (00,0009) TEST2 
 
 00110030 . F Al SE 
 
 00110031 STpPE-RPOLEAN 
 
 001 j CO 31*** STpRF-ROPlFAM-pAPTIAL-rESTPdCTIvE 
 
 00110032 STpPF-RDOLFAM 
 
 JOB, NUMBER «- IF TFSTl THEN ELSE J FIJ OOOOlflOOj H 
 
 001:0033 NAME-CALL (00,0010) JOR 
 
 001 l 003A IMTEGER-LITFPAI -CALL 000 ! . 
 
 001:0035 MAKF-INDEX NUMEtFR 
 
 001:0036 NAMF-CALL (CO, 0008) TESTl 
 
 001:0037 LPAT-ROOLFAM 
 
 001:0036 *** (RRANCH-TF-FALSE INSTRUCTION WILL BE HEPF) *** 
 
 001:0039 I^TFGER-LTTEPAl -CALL 
 
 00110036*** fcRA^CH-lF-FALSF (OOllOOftl) 
 
 001:0040 *** (BRANCH INSTRUCTION WILL BE HERE) *** j 
 
 001 J 0041 MMF-CALL (00,0001) J 
 
 00110042 l.OAP-lNTEGFR 
 
 00110040*** P&ANCH (OOHO0A3) 
 
 001:0043 STpRF-INTEGFR ' 
 
 BEGIN 00001500 15 
 
 IMTEGFR Z'O «■ K+l - IF TESTl THEN ELSF L + M FT! 00001600 16 
 
 (01,0000) = 7 
 
 (01/0001) = 
 
 00210000 NAMF-CALL (01,0001) 
 
 002:0001 MMF-CALL (00,0002) K 
 
 002:0002 LHAP-INTEGFR 
 
 007:0003 IMTFGER-LITFRAL -CALL 1 
 
 002:0004 A^p 
 
 002:000b NAME-CALL (00,0008) TESTl 
 
 002:0006 L.n a n-PPnLFAN 
 
 002:0007 *** (BRANCH- 1 F-FALSF INSTRUCTION WIIL BE HERF) *** 
 
 002:0008 IN T EGEP-LITFPAi-CALL 
 
2^2 
 
 00?l0007*** FRANCH-IF-FALSr (00210010) 
 
 002:0009 *** (BRANCH INSTRUCTION WILL PE HEPF) *** 
 
 00?:0010 NAMF-CALL (00,0003) L 
 
 ? t C 1 1 LPAP-TNTEC.ER 
 
 002:0012 NAMF-CALL (00,0004) M 
 
 002:0013 LHAn-IMECFR 
 
 oopiooh Ann 
 
 002:0009*** BRANCH (002:0015) 
 
 002:0015 SMPTKACT 
 
 002:0016 STpRF-IMTFCFR 
 
 FOPLF AM TEST2,TFST3J 
 
 00001700 17 
 
 (01 ,000?) 
 (01>0003) 
 
 = TFST? 
 = TEST3 
 1FST1 «■ 
 
 TEST2 ♦ TFST3 * T"Ufl 
 
 00001600 16 
 
 00210017 
 
 00210016 
 
 002:0019 
 
 002:0020 
 
 002:0021 
 
 002:0021*** 
 
 002:0022 
 
 002:0022*** 
 
 002:0023 
 
 X 
 
 002: 
 002: 
 002: 
 002: 
 002: 
 002: 
 002: 
 002: 
 002: 
 002: 
 
 0024 
 0025 
 0026 
 0027 
 0026 
 0029 
 0030 
 0031 
 0032 
 0033 
 
 002:0034 
 002:0035 
 002:0036 
 002:0037 
 002:0036 
 002:0039 
 00?:004C 
 002:0041 
 002:0042 
 002:0043 
 
 002:0044 
 002:0045 
 002:0046 
 
 002:0047 
 002:0046 
 002:0049 
 00210050 
 002:0051 
 
 (00,0008) 
 
 TESTl 
 
 (01,0002) 
 
 TFST2 
 
 (01,0003) 
 
 TEST3 
 
 M^F-CAIL 
 MmFT all 
 n b v f - c a i l 
 TRliF 
 
 STPPF-PPDLEAM 
 
 STPPE-BIJOlEA ^-PARTIAL- PFSTRllCTIVF 
 STpf-F-POOLEAN 
 
 ST PRE -BOOLE A ^" FART I A L-PE STRUCT I Vf 
 STpRF-POOLFAM 
 • jpp. NUMBER + JOB. RECORDS. TTMEFTMSHFD 
 
 00001900 19 
 
 KAt/F-CALL (00,0C05) 
 NAMT-CALL (00,0010) 
 INTEOER-LITFRAL-f ALL 
 MkT-INPEX NUMREP 
 LPaP-INTEGEP 
 K*mF-CALL (00,0010) 
 
 integer-literai -CALL 
 mkf-tnpex pecppps 
 1m t fpfp-litfpal-call 
 
 MAKE-INL'EX TIMFFINISHED 
 - JOB. RECORDS. TIME5TARTED; 
 
 X 
 
 JOP 
 
 POO 
 
 JOP 
 00? 
 
 001 
 
 00002000 20 
 
 LPAP-INTEGER 
 
 APP 
 
 MVF-CALL (00,0010) JOP 
 
 IMtFGER-LITFRAL-CALL 002 
 
 Makf-index records 
 inte^fr-lttfral-call 000 
 MkE-TNOEX tihestarted 
 loap"h'teger 
 suptract 
 
 STpPE-lNTEGFR 
 ■ Tf TEST2 AND TFST1 
 
 MMF-PAlL (01,0000) 
 NAN-F-CALL (01,0002) 
 LPAP-PPULFAv 
 THEN IF C >= 3 THEN 
 
 7 
 TEST2 
 
 L El SE h FT 
 
 00002100 21 
 
 00002200 22 
 
 NAVF-CALL (00,0006) TESTl 
 
 LPAP-RPOLEAN 
 
 AND 
 
 *** (ppANCH-TF-FAt SE INSTRUCTION WILL 
 
 NAMF-CAIL (01,0001) 
 
 BE HEPF) *** 
 
2k3 
 
 0052 LOAD-INTEGER 
 
 0053 INTFGER-LTTFFAt -CALL 3 
 :C054 INTFGER-GRFATEP-PP-FCUAL 
 
 0054 *** (PRANCH-lF-FAt SE INSTRUCTION' WILL BE HERE) *** 
 
 0055 NAME-CALL (00,0003) L 
 
 0056 LPAP-H'TEGEP 
 
 005**** BPAN'CH-If-rALSF (00210058) 
 
 0057 *** (BRANCH INSTRUCTION WILL BE HERE) *** 
 
 0058 NAmF-CALL (00,0004) M 
 
 n se case j of k,k,k»l#l>l#m,m,m» 00002300 23 
 
 0059 LPAD-INTEgEr 
 
 0057*** BRANCH (002J0060) 
 
 ;0050*** BRANCH-ir-FALSF f00?t0061) 
 
 10060 *** (BRANCH ! NSTPUCT ION WILL BE hERF) *** 
 
 0061 NAMF-CALL (00,0001) J 
 
 0062 LHAD-lNTErER 
 
 0063 *** ( INDEXEP-l'PANCH INSTRUCTION vlLL BE HERF) *** 
 
 0064 NAME-CALL (00,0002) K 
 
 0065 LPAO-INTECEP 
 
 0066 *** (BRANCH INDUCTION WILL BE HERE) *** 
 
 0067 NAME-CALL (00,000?) K 
 
 0068 LPaP-INTEGEr 
 
 0069 *** (BRANCH INSTRUCTION WILL RE HERF) *** 
 
 0070 NAMF-CALL (00,0002) K 
 
 0071 LOAD-INTEGER 
 
 0072 *** (BRANCH INSTRUCTION WlLl BE HERF) *** 
 
 0073 NAf'F-CALL (00,0003) L 
 
 0074 L^aP-INTEGER 
 
 10075 *** (BRANCH INSTRUCTION WILL BE HERE) *** 
 
 0076 NAmF-CALL (00,0003) L 
 
 i0077 1.0AP-INTEGFR 
 
 0078 *** (BRANCH INSTRUCTION WILL BE HERF) *** 
 
 0079 NAMF-CALL (00,0003) L 
 ,0080 LOaP-INTEGER 
 
 :0081 **+ (BRANCH INSTRUCTION WILL BE HERF) *** 
 
 0082 NAMF-CALL (00,0004) M 
 
 0083 LOAP-INTEGER 
 
 0084 *** (BRANCH INSTRUCTION WILL BE HERE) *** 
 
 0085 NAMF-CALL (00,0004) M 
 
 0086 LOaP-INTEGEP 
 
 0087 *♦* (BRANCH INSTRUCTION WlLl RE HERF) *** 
 0086 NAMF-CALL (00,0004) M 
 
 IF I «■ (*+D MOO 50 e 2 00002400; 24 
 
 10089 LOAP-INTEGEP 
 
 0090 *** (BRANCH INSTRUCTION WILL BE HERF) *** 
 
 0091 K8MF-CALL (00,0000) T 
 
 0092 tinpLTCATE-TOP-PF-STACK-ANO-t OAD-INTEpER 
 
 0093 IK'TFGFR-LITEFAi-f AIL 1 
 :C094 APP 
 
 [0095 IMTFGFR-LITFPAi-CALL 50 
 
 10096 MPD 
 
 ;C097 STPFF-INTEGFR 
 
 ;0097*** STpPF-lNTFGFP-FAPTlAL- DESTRUCTIVE 
 
 0098 INTEr.ER-LITFRAL-CALL ? i 
 
 THFN I ELSE FI 00002500; 25 
 
 0099 IMTFGER-EOUAL 
 
 0099 *** (PRANCH-IF-FALSE INSTRUCTION WILL BE HERE) *** 
 
 0100 NAMF-CALL (00,0000) I 
 
2kh 
 
 00? : 01 01 
 00?: 0099*** 
 CO',' i 010? 
 00? (01 03 
 002:0102*** 
 
 002: 0101 
 
 I n^n-TNTEGFR 
 
 f-P/iMf H-IF-FALSF (002:0103) 
 
 *** (BRANCH T N ^TPt'CTIPf' WlU BE IJFPF) *** 
 IK'TFGFP-LITFRAl -CALL 
 bRAMCH (002J0104) 
 
 ESAC 
 
 *** (BRANCH IKSTRUCTIOfi WILL BF. HERF) *** 
 
 00002600 
 
 26 
 
 002:0105*** E-Pa^H 
 
 ? : 6 6 * * * h R A f* C H 
 
 00? 10 106*** P P a>' C H 
 
 007:0069**+ BRANCH 
 
 002:0107*** [RfiN'CH 
 
 00 7:007?*** b » A N C H 
 
 00?:010f*** PPANCH 
 
 002:0075+** p R a N C H 
 
 002:0109*** f-RAhCH 
 
 007:0076*** h&A^GH 
 
 007:0110*** [pamCH 
 
 002:0061*** FRANCH 
 
 00?:Clll*** pPAMCH 
 
 oo?:oo84*+* branch 
 
 00?:0112*** PPAt'CH 
 
 007:0067*** BRANCH 
 
 002:0113*** pRAK'OH 
 
 002:0090*** pRAN'Ch 
 
 007:0114*** PRanCH 
 
 002:0104*** PPAN^H 
 
 002:0063*** IMpFVEP-bRANCH 
 
 ft; 
 
 002:0060*** BRANCH 
 
 007:0115 STnRF-lNTFGFR 
 
 TFSIl ♦■ TEST2 <- FALSF 
 
 002:0116 
 002:01 17 
 02:0116 
 END I 
 
 NAMF-CAI L 
 NAtfF-CALL 
 
 f At SF 
 
 (00,0008) 
 (01,0002) 
 
 (002 
 (002 
 (002 
 (002 
 (002 
 (007 
 (002 
 (002 
 (002 
 (002 
 (002 
 (002 
 (00? 
 (002 
 (002 
 (002 
 (007 
 (00? 
 (002 
 (00? 
 (002 
 
 10064) 
 101 15) 
 :0067) 
 101 15) 
 :0070) 
 10115) 
 J0073) 
 J0115) 
 :0076) 
 10115) 
 10079) 
 10115) 
 :008?) 
 »0M5) 
 :00fl5) 
 «0115) 
 :00A8) 
 «01 15) 
 »0091 ) 
 * 01 15 ) 
 :0105) 
 
 (00?»nil5) 
 
 TESTl 
 TFST2 
 
 002:0119 STPPF-POOLEAN' 
 
 002:0119*** ST PRF -BOOLF A N-P APT I A L-DF STRUCT I VE 
 002:0120 STpPF-BOCLFAM 
 TEST1 <- TFST? «■ TRUE 
 
 001 :0C44 
 001 :0O45 
 001 :0046 
 
 F.KR 
 
 001 :0047 
 001 1 a 7 * * * 
 001 :0046 
 
 NAVF-CAI.L 
 NAME-CALL 
 TPl'F 
 
 (00,0008) TESTl 
 (00,0009) test2 
 
 STpRF- 
 STpPF. 
 STpRE' 
 
 BOOLEAN 
 
 BOOLFAN' 
 
 BOOLFAM 
 
 00002700 
 
 I 
 
 00002600 ; 
 
 00002900 
 
 00003000 
 
 00003100 
 
 27 
 
 26 
 
 29 
 
 30 
 
 31 
 
 PARTIAL -PFSTPMCT! VF 
 
 CONGRATULATIONS, MO SPUPCF PPOGRAM FPpOPS NFPE PFTFCTFD IN PASS 1. 
 
21+5 
 
 TMF TpTAL CPU TIME WAS 
 ThF TpTAL I/P TIME WAS 
 THE TpjAL ELAPSFO TIME WAS 
 
 MINUTES 30,0 SErPNOS. 
 
 MINUTES 37.5 SECPNPS. 
 
 1 MINUTES 9.7 SFCONpS. 
 
2h6 
 
 LIST OF REFERENCES 
 
 [l] Attached Support Processor System (ASP) System Programmers Manual , 
 H20-0323, IBM Technical Publications Department, White Plains, 
 N.Y. , 1968. 
 
 [2] Attached Support Processor System (ASP) System Description , H20-0H66, 
 IBM Technical Publications Department, White Plains, N.Y., 1968. 
 
 [3] Attached Support Processor System (ASP) Applications Programmer 
 Manual , H20-0322, IBM Technical Publications Department, 
 White Plains, N.Y., 1967. 
 
 [k] Attached Support Processor System (ASP) Console Operators Manual , 
 
 H20-0321, IBM Technical Publications Department, White Plains, 
 N.Y. , 1968. 
 
 [5] HASP-II , PID#360D-05.1.0lU, IBM Program Information Department, 
 Hawthorn, N.Y. , 1969 . 
 
 [6] IBM 7090/709^ IBSYS Operating System Version 13: System Monitor 
 (IBSYS) , C28-62U8, IBM Technical Publications Department, 
 White Plains, N.Y. 
 
 [7] PORTHOS User's Manual , Department of Computer Science, University of 
 Illinois, Urbana, Illinois, 1967 • 
 
 [8] A Narrative Description of the Burroughs B5500 Diskfile Master Control 
 Program , Burroughs Corporation, Detroit, 19 66. 
 
 [9] ESPOL Reference Manual , Burroughs Corporation, Detroit, 1966. 
 
 [10] E. W. Dijkstra, The Structure of the "THE" - Multiprogramming System , 
 Comm. of the Assoc, for Computing Mach. , v. 11, no. 5, May, 1968. 
 
 [ll] P. A. Alsberg and R. A. Wells, OSL-An Operating System Language , 
 
 CS ^97 special project, University of Illinois, copies available 
 from authors , May 2k , 1968 . 
 
 [12] P. A. Alsberg and C. R. Mills, The Structure of the ILLIAC IV Operating 
 System , Proceedings of the Second Symposium on Operating System 
 Principles, Princeton University, October 20-22, 1969 . 
 
 [13] P. A. Alsberg, et al, A Description of the ILLIAC IV Operating System , 
 
 ILLIAC IV Document No. 212, University of Illinois, November, 1968. 
 
 [ik] E. W. Dijkstra, Co-operating Sequential Processes , Math. Dept . , 
 Tech. University, Eindhoven, 1965. 
 
"21+7 
 
 A. N. Habermann, On the Harmonious Co-operation of Abstract Machines , 
 Ph.D. Thesis, Tech. Univ., Eindhoven, 1967. 
 
 J. V. Garwick, GPL, A Truly General Purpose Language , Comm. of the 
 Assoc, for Computing Mach., v. 11, no. 9, September, 1968. 
 
 J. V. Garwick, GPL , A General Purpose Language , SIGPLAN Notices, 
 v.U, no . 8 , August , 1969 . 
 
 A. V. Wijngaarden, et al , Report on the Algorithmic Language Algol 68 , 
 
 Math. Cent., Amsterdam, MR101, February, 1969. 
 
 B. J. Mailloux and J. E. L. Peck, Algol 68 as an Extensible Language , 
 
 SIGPLAN Notices, v.U, no. 8, August, 1969. 
 
 R. M. Balzer, EXDAMS -Extendable Debugging and Monitoring System , 
 
 AFIPS Conference Proceedings - Spring Joint Computer Conference, 
 v.3U, AFIPS Press, Montvale, N.J., May, 1969, pp. 567^-580, 
 
 B65OO Reference Manual , IOI+3676, Burroughs Corporation, Detroit, 
 
 W. A. Wulf, et al, BLISS Reference Manual , Department of Computer 
 Science, Carnegie Mellon University, Pittsburgh, 1970 . 
 
 B5500 EXTENDED ALGOL Reference Manual , 102802U , Burroughs Corporation, 
 Detroit, 1969. 
 
 B6700 EXTENDED ALGOL Language Information Manual , 5000128, Burroughs 
 Corporation, Detroit, 1971. 
 
 A. J. Beals , J. E. LaFrance , and R. S. Northcote , The Automatic 
 
 Generation of Floyd Production Syntactic Analyzers , Department 
 
 of Computer Science Report No. 350, University of Illinois, 
 Urbana, Illinois, 1969- 
 
 R. L. Mercer, TWINKLE-A Syntax Language for a Translator Writing 
 System , Master's Thesis, Department of Computer Science, 
 University of Illinois, Urbana, Illinois, 1970. 
 
 N. C. Machado, ISL-A Semantics Language for a Translator Writing 
 System , Department of Computer Science Report No. 367, 
 University of Illinois, Urbana, Illinois, 1967. 
 
21+8 
 
 VITA 
 
 Peter Allyn Alsberg received his B.S. in Engineering Physics 
 from the University of Illinois in 1966 . His M.S. in Mathematics was 
 completed at the University of Illinois in 19&1 > 
 
 Mr. Alsberg was elected to full membership in Sigma Xi , and 
 the undergraduate honorary Phi Eta Sigma. 
 
 While at the University of Illinois, Mr. Alsberg designed and 
 supervised the initial implementation of the supervisor and monitor 
 modules of the ILLIAC IV Operating System. In 1969, together with 
 Mr. C. R. Mills, he published "The Structure of the ILLIAC IV Operating 
 System" in the Proceedings of the Second Symposium on Operating System 
 Principles . 
 
IJNCLASSIFIED 
 
 
 Security Classification 
 
 DOCUMENT CONTROL DATA - R A D 
 
 ("Security elmmalllemllon ol till: <MMT/ *l •fcefmct and WNNMrwi0 mmmMm must b» enter*** vfMn M* ovrmll report (a elmteHlod) 
 
 ". PAGINATING ACTIVITY (Cotpotml* aulHcr) 
 
 Center for Advanced Computation 
 
 Mm. REPORT SECURITY CLASSIFICATION 
 
 UNCLASSIFIED 
 
 Jniversity of Illinois at Urb ana- Champaign 
 Jrbana, Illinois 61801 
 
 ae. GROUP 
 
 EPORT TITLE 
 
 3SL/2 AN OPERATING SYSTEM LANGUAGE 
 
 DESCRIPTIVE NOTES (Tfp* •/ Mpcrt m*4 BMfMSI** BMmJ 
 
 Re s e arch Report 
 
 iiUTHORUI (First mm, aitdWV* htlllml, Imml nam*) 
 
 Peter Allyn Alsberg 
 
 SPORT DATE 
 
 June 10, 1971 
 
 1m. TOTAL NO- OF PACES 
 
 256 
 
 7b. NO. OF REFS 
 
 27 
 
 1 CONTRACT OR GRANT NO. 
 
 JSAF 30(602Ml¥r 
 
 PROJECT NO. 
 
 \RPA Order 788 
 
 SO. ORIGINATOR'S REPORT NUMS)ER(S) 
 
 CAC Document No. 6 - 
 
 
 Se. OTHER REPORT NO(S) (Any etftor number* thmt atey ba •«•!**)•<? 
 Chi* raport) 
 
 DCS Report No. k60 
 
 DISTRIBUTION STATEMENT 
 
 Copies may be requested from the address given in (l) above. 
 
 SUPPLEMENTARY NOTES 
 
 done 
 
 tS. SPONSORING MILITARY ACTIVITY 
 
 Rome Air Development Center 
 Griffiss Air Force Base 
 Rome, New York 13^0 
 
 II ABSTRACT 
 
 OSL/2, an Operating System Language, was designed for the 
 coding of supervisory systems. OSL/2 is an ALGOL-based language that 
 nay be readily extended to a general purpose language with the addition 
 3f a few data types (e.g., floating point numbers). The language replaces 
 an interrupt concept with the P and V operators on semaphores described 
 )y Dijkstra. Concepts of multiple processes and system layers allow 
 OSL/2 to be used as a job control language for an OSL/2 coded supervisory 
 system. The system layering concepts provide for easy system extension and 
 lierachical structuring. A powerful method of specifying access techniques 
 Is used to implement queues, tables, etc. and treat them as primitive data 
 Items in the language. The language is presented in narrative and reference 
 formats. Hardware implications are discussed and an OSL/2 compiler which 
 ;uns on the Burroughs 5500 is briefly described. The implications of the 
 iLanguage on system measurement, simulation, and modification are also 
 discussed. ■■■■■■■■■■■»■ 
 
 FORM 
 
 » NOV SB 
 
 1473 
 
 UNCLASSIFIED 
 
 Security Classification 
 
UNCLASSIFIED 
 
 Security Classification 
 
 KEY WORDS 
 
 Procedure and Problem Oriented Languages 
 (Miscellaneous) 
 
 Compilers and Generators 
 
 Compiler-Compilers 
 
 Programming Lanugages 
 
 Supervisory Systems 
 
 Basic Monitors 
 
 ROLE W 
 
 UNCLASSIFIED 
 
 Security Classification