ELLIOTT ALGOL TRANSLATOR

This document is a lightly edited transcription of a type-written original document describing the Elliott 903 Algol Translator program. References to global identifiers in the text are hyperlinked the definition of that identifier in the document. (Global identifiers are used to name translator state variables and principal translator subroutines.)

The descriptions of each subroutine are annotated with a "flowchart" link and a "code" link. The flowchart link transfers to a scan of the hand drawn flowchart that accompanied the description document. The code link transfers to the declaration of the label in the source code. The source code is also in HTML and in each place where a global variable is referenced in the source, it is coded as a hyperlink to the place where that identifier is located.

To show where page breaks occur in the original document, page links are included in this document in the form [--PAGE nn--]. Clicking on these links transfers to a scanned image of the page from the original document.

To develop a full understanding the Elliott 903 Algol translator start reading this document linearly from the beginning, following the top down flow of the original document. Follow hyperlinks to refer to the definition of unfamiliar identifiers and the back button to return. For global subroutines use code links to see the corresponding source code and flowchart links to understand the logic of the code.

N.B. Additional explanatory text, like this, that did not appear in the original document, is coloured red.

The main body of the description starts here (Introduction).

(The initial pages initially following are notes about how to assemble the translator source.)

Andrew Herbert April 2024

[--PAGE i--]

ELLIOTT 903 ALGOL

Translator store map. December 1966

D. Hunter.

[--PAGE ii--]

ELLIOTT 903 ALGOL

How to add names to the built in namelist December 1966

1.  General

2.  Structure of a namelist entry

Only procedure names are considered here. If a procedure has parameters then extra space is required for their codewords e.g. the procedures P, CAT and FRED with 0, 1 and 5 parameters:-

It can be seen that although P occupies a single 4 word entry CAT requires two and FRED requires three entries of 4 words each.

[--PAGE iii--]

Parameters, if present, are described by codewords pl, p2 etc. where p1 describes the first parameter, p2 the second etc. Up to 4 parameters can be accommodated in a block of four words. Codewords are as follows:-

The block of 4 words holding the name and its details has the first six characters of the name stored left justified and space filled in words 1 and 2.

The third word wd 3 contains in its function part a l or a 2. If it contains a 1 then the procedure must be on the library tape and the address part of wd 3 must point to the name e.g.
                1 ;-2

One can arrange a shared group of names, see for example SIN, COS and ARCTAN sharing the name QATRIG. If this is done then the shared name must not start a block of four parameter entries. If it does then the "reset names" part of initialisation will treat the block as a name and reset the used bit to zero, spuriously.

If wd 3 contains a 2 in its function part then the 13 bit address part is treated as follows:-

The five most significant digits form the function part of a pord and the eight least significant digits form the address part with zeros between the functions and address parts.

The function part is usually /15 or 15 for a PRIM or INOUT operation. If an INOUT operation is involved and the procedure name is discovered to be inside a print or read list, eleven is added to the address part. In theory one could generate any pord one likes. If a PRIM operation is involved and the procedure is a type procedure the PRIM UP which is normally produced is suppressed as is required by the interpreter.

[--PAGE iv--]

The final word, wd 4, is constructed as follows:-

  E.g. a real procedure with ten parameters would be &036112

* The codeword for a real procedure with parameters is &036100; note that the number of parameters is left blank in the codeword.

3.  Assembly of the namelist

Use SIR at 512 to assemble the namelist. Then dump this by using the non-standard T22/23 to be found on the "USEFUL TAPES" tape and an appropriate data tape.

Adding namelist to translator

After input of the relocatable translator tape clear out the loader by using "CLEAR FROM 7168" on the "USEFUL TAPES" tape. Then dump the store from 88-7999 inclusive using the non-standard T22/23.

D. Hunter

[--PAGE 1--]

CONTENTS

1. INTRODUCTION


2. LIMITATIONS IMPOSED ON IFIP SUBSET ALGOL


3. DATA STORE


4. THE CHARACTER SET


5. PROGRAM STRUCTURE


6. TYPE HANDLING


7. NOTATION


8. REFERENCE LISTS


9. NOTES ON TRANSLATOR LISTING

Routines

CENTRAL LOOP
FAIL
TAKCHA
IDENTIFIER
EVALNA
NUMBER
BCR
UNSTAK
EXP
PRAMCH
SEARCH
SECODL
TAKE IDENTIFIER
TAKE
TYPCHK
ACTOP
ARRAY BD
DEC
DECL
ENDSTA
FORCOM
COLLAPSE FORMAL PARAMETERS (FCLAPS)
COLLAPSE NAME LIST (NCLAPS)
real, integer, boolean
begin
do
else
end
for
goto
if
procedure
step, UNTIL, while

[--PAGE 2--]

Routines continued

switch
then
:= (BECOMS)
; (SEMICO)
arithmetic operators
Relational operators
Logical operators
[ (LSBRAK)
] (RSBRAK)
: (COLON)
, (COMMA)
( (LRBRAK)
) (RRBRAK)
{ string opening quote

[--PAGE 3--]

GENERAL STRATEGY OF THE TRANSLATOR

1.  INTRODUCTION

The task of the Translator is to convert the ALGOL text into object program operations, which are assembled into object store by means of a loader/assembler, and obeyed interpretively at run time under the control of an Object Interpreter.

Lack of space necessitates the translator for 903 ALGOL to be one-pass, and object program operations are output as the source program is read in, Because insufficient store is available to hold the Translator, the translator Name List and subsidiary tables, and the object program, some such decision is imperative.

The object program is essentially a form of "Reverse Polish" notation, and the Translator uses a stack to perform the necessary re-ordering of the ALGOL symbols, The Translator also uses a "Name List" which holds details of the declaration and use of the various identifiers, During translation a great many checks-are performed on the legality of the ALGOL text, but it cannot be claimed that these are exhaustive.

The heart of the Translator is a routine called the "Basic Cycle Routine" (BCR) that extracts the next section of ALGOL text (a section being a string of characters ending with a delimiter such as "3" or begin ) ; control is then passed to a routine dealing with the delimiter concerned, and these routines may call further subroutines.

[--PAGE 4--]

2.   LIMITATIONS IMPOSED ON IFIP subset ALGOL

IFIP subset ALGOL restricts "full" ALGOL in several important ways (one of these being the exclusion of recursion). 903 ALGOL has further restricted IFIP subset ALGOL, in particular in the following two areas:

begin switch S1 := FRED, JIM;
	go to JIM;
	FRED: ---
	begin switch S2:= JIM;
		---
		go to JIM;
	JIM: =--
		go to FRED;
	end;
	JIM: --
end

if a+ b then ...
a := a > b

[--PAGE 5--]

3.  THE DATA STORE

The Translator requires the following storage areas:

3.1  The Name List (NL)

The name list contains the names and details of all the identifiers with a current valid declaration. This list is divided into blocks separated by block stoppers.

When a block closes, the Name list is then cleared back to its stopper.

A Name list entry is four words long and contains:

WORDS 1 and 2

WORD 3 (from most significant)

WORD 4 (from most significant).

A Block Stopper contains - 1 in word 1 and BN in Word 2.

[--PAGE 6--]

3.2  Constants List (CODL)

This list holds the constants used in the source program; to prevent every constant taking up space each time it is used (as it would if the constants were inserted as they occurred into the object program) CODL is searched as each constant occurs to avoid duplication.

The list also contains details of all switches and label declared during the source program. An example best illustrates its use;

(assume in block 54)

Switch S := LAB1, LAB2, LAB3;

sets up NL and CODL as follows:-

When a label is met preceding a colon, it is looked up in CODL is available, and the current program address is entered in CODL in place of the "+0", The block number must be in CODL to discover at run time how many entries should be unstacked on performing a jump to a label.

These addresses have base address added at load time so are distinguishable to avoid their being used as constants at translate time.

[--PAGE 7--]

3.2  The Stack

The stack is used as a holding store to enable expressions to be converted into Reverse Polish, and also to deal with the nested statement structure. The next page shows a table of the stack - and compare - priorities used for delimiters. In general, operands are compiled, and operators are stacked. Unstacking is controlled by the stack priority, and loops UNTIL a stack priority is met that is less than that with which the unstacking procedure is called.

3.4  Buffer Area

This area is 40 words long and stores source lines, the filling of this area is automatic. Once the Translator asks for a character either the next is supplied or it is found to be an nlcr and the buffer is refilled up to the next nlcr or a stopcode.

[--PAGE 8--]

TRANSLATOR STACK

[--PAGE 9--]

[--PAGE 10--]

4.  THE CHARACTER SET

There are 63 characters in the internal set. Their octal representation is shown below alongside the 503 flexowriter symbol. The 4100 Westrex character is shown alongside in brackets when different.

Note (i)   (/) represents acute [single] quote on a 4100 Westrex teleprinter, and (\) is grave [single] quote.

Note (ii)  In other publications the 4100 Westrex teleprinter code is referred to as "903 Telecode".

Note (iii) n the later "900 Telecode"", (/) becomes ' and (\) becomes @, ½ becomes £, ₁₀ becomes &, £ becomes \, ↑ becomes ^ and ← becomes _.

Note (iv) f interpreted as modern ASCII, (/) and (\) become ' and @ respectively, ½ becomes #, ₁₀ becomes &, £ becomes \, ↑ becomes ^ and ← becomes _.

e.g. The double character | overprinted by 2 in the 503 code corresponds to ½ in the 4100 code and is represented internally as 3.

Note nlcr is represented in the westrex code by carriage return, line feed and run out. This is handled on input to make line feed the operative symbol.

Stop code is treated in most respects as an nlcr. Lt is recognised in GETCHA (FILBUF) and terminates the buffer filling. When the line has been processed the increment line count is omitted and the program pauses.

Becomes (:=) is left stored as two characters but the routine GETCHA has a look ahead facility to cope with this as it does with parameter comments in procedures.

The colon equals sign must not contain a separator.

[--PAGE 11--]

5.   PROGRAM STRUCTURE

A compound statement consists of a set of statements preceded by begin and followed by end. A block, however, has one or more declarations between begin and the set of statements which are again followed by the delimiter end. On meeting the first declaration after a begin, therefore, a block is implied.

Whether or not an object block is set up depends entirely on the mode of storage used for the variables local to that block. The "wipe-off" mechanism at the end of an object block is best achieved by clearing back the stack pointer, without worrying whether to "block off" other areas of storage. There are two extremes to this problem:

This translator steers a middle course; all scalars are given addresses in store, and arrays, formal parameters etc., are kept on the stack. As a result, an object block is only set up for the latter cases, This approach should be contrasted with Randell & Russell's method, which keeps all variables on the stack.

For object program operations see the pord manual.

[--PAGE 12--]

6.   TYPE HANDLING

6.1   General

The conversion of variables and expressions from real to integer or from integer to real is handled by the translator. Basically, the rules for determining the type of an expression are as follows: -

[--PAGE 13--]

A := b + (if p < q then d else I);

a - z denote a variable of type integer
A - Z   "   "   "    "   "   "  real

[--PAGE 14--]

Since the else part produces a real result, the then part must also produce a real result. The object code in reverse polish is:-

* The conversion (I to RL) cannot be placed here since in a single scan the translator is unable to know that the else part will give a real result.

6.2   Rules for Type Determination

(i)   Assignment Right hand part converted to left-hand part.

a: = b+ D; (b + D) is converted to integer.

(ii)  Arithmetic or relational operation If either operand is real,

a := (b + D) * e; b and e are converted to real.

a := if B <d then p + q else y - R;

d is converted to real since B is real (p + q) and y are converted to real since R is real.

(iii) Subscript expression The subscript expression must give result integer.

a := A [b+ D] ; b is converted to real since D isreal. (b + D) is converted to integer since it is a subscript.

(iv)  For Statements The list elements must be converted to the same type as the controlled variable.

[--PAGE 15--]

for V := a,b step d until e, f while p < q do . . . .

a,b,d,e and f are converted to real since V is real.

(v)    Actual Parameters In a procedure call, the actual parameters must be converted to the type (real or integer) of the corresponding formal parameters.

[--PAGE 16--]

procedure P (a,B); value a,B; integer a; real B;

P (A,b); A is converted to integer and b to real to match the types of the formal parameters a and B.

(vi)   Division Except when specifically required through use of a special Algol word div, the result of a division is real irrespective of the types of the operands, though there are 2 division operations in the object code. This is best illustrated in the following table:-

(vii)  Exponentiation This is similar to division, but there are third and fourth object codes for exponentiation.

(A) Integer exponentiation giving result integer. This operation may only occur when the mantissa is integer and the exponent is a positive integer constant.

(B) A special primitive for R ↑ i stops the expression being failed out when the integer is negative.

The operations are illustrated below:-

6.3   Type determination in the Translator

A global variable TYPBOX contains the current type (real or integer) of an ALGOL arithmetic expression. This is set by every arithmetic identifier or constant when compiling the object code for the operand (in TAKE) and is stacked with the binary operator which follows. When the expression is unstacked this type is unstacked into LOKTYP, TYPBOX is set to the resulting type of the expression and any conversions necessary are compiled.

[--PAGE 17--]

Example

A := d + E * f;

On unstacking the decision of whether to compile a conversion or not, is made by comparing TYPBOX with the type stacked with the operator.

TRANSLATOR Conversion Rules

(i)   Each identifier or constant sets TYPBOX to its type (real or integer) in TAKE.

(ii)  The type from TYPBOX is stacked with + - * / , < <= = > >= ≠, :=, [, else, for comma, for:=, step, UNTIL, while. With the exception of [, the type stacked is that of the preceding variable or expression. In the case of [ it is the type of the preceding array identifier. Boolean is stacked as integer.

(iii)  In the subroutine UNSTAK, the type stacked with the operator (e.g. + i) is compared with the current type in TYPBOX. A conversion is compiled if necessary and the relevant operator compiled (e.g. + R). The current expression type is then placed in TYPBOX.

(iv)   Conditional Expressions The type of the then part is stacked with else. On unstacking the else part, the type stacked with else is compared with the type of the else part (in TYPBOX) and a conversion compiled where n necessary.

[--PAGE 18--]

(v)    The operators ↑ and / always leave TYPBOX set to real on unstacking except for div and I ↑ I as noted in 6.2(vi) and (ii).

(vi)   The assignment operator := requires a conversion to the type stacked with it.

(vii)  Array element On unstacking a subscript expression requires the type to be integer and a conversion is compiled if the expression is real. The type of the array, stacked with [, is then placed in TYPBOX.

(viii) Procedure call If the call is to a type procedure (i.e. it yields a value) the type of the procedure is set in TYPBOX after compiling the call at ) or TAKID.

(ix)   The expression bracket '(', if and then do not require a type to be stacked with them nor do they change TYPBOX on unstacking.

(x)    For statements The type of the controlled variable is stacked with the start of each list element. On unstacking the list element expression, a conversion to the stacked type is compiled if necessary, and the type again stacked with the start of the next list element.

(xi)   Actual Parameters These are dealt with in the subroutine PRAMCH which determines whether to compile a conversion or not by comparing type of the actual parameter with the type of the formal parameter (this information is found in the Namelist). TYPBOX holds the actual parameter type, if this is an expression.

COMPARISON between operator type and TYPBOX

[--PAGE 19--]

Note op R, op I denote an operator of type real or integer. Operand 1 is the variable or expression preceding the stacked operator, or the left part of assignment, or the then part and conditional expression, or the array identifier.

Operand 2 is the variable or expression following the stacked operand, or the RH side of an assignment, or the else part in a conditional expression or the array subscript.

[--PAGE 20--]

7.   NOTATION

The action of taking the item at the top of the stack and distributing the various constituent parts of the item into fixed locations is denoted by the procedure RESTO. The parameters to this procedure correspond to some or all of the constituent parts of the item at the top of the stack. Those parts that are to be stored in fixed locations are indicated by a parameter, enclosed in square brackets, giving the name of the location. The final action of RESTO is to decrease SP (the stack pointer) by one, and setting TS to be the current top of stack.

For example, if the item at the top of the stack is

begin TR, 53, 1026, O

then RESTO [.... BN , Q ]

deletes this item, having set BN to be 53 and Q to be 1026.

The procedure PRESTO is a variant of RESTO which does not decrease SP and TS then remains the same.

The subroutine STACK has, as parameters given on separate lines and enclosed in square brackets, any items which are to be added to the stack. The stack priorities are indicated by the final underlined integer.

For example,

will stack the item "DECSTAT, NLP, BN, PP" and then the item "proc begin , Q".

The subroutine COMPIL uses a similar notation to indicate any operations (and their parameters) to be added to the object program.

[--PAGE 21--]

A subscripted item has the subscript value enclosed in square brackets. If an identifier is enclosed in round brackets this may be taken as 'contents of', e.g.,

is putting a block stopper in the name list, -l is put where the name list pointer points and the Block Number goes in the next word, Replacing the Global Block Number;
BN := (NLP+1) rather than BN := NLP[1].

To make stacking easier, the Global variables take the values corresponding to the stacked position, E for example is stacked as the 9th significant bit of word one, and consequently the variable is carried about as O or +256 in the coding. The flowchart however refers to E as O or l. It is thought safer for other multistate variables to refer to their actual values (DECSTA := /0 0).

Values of masks are not shown in the flowcharts: GRPCOD := masked TABLE [LASTCH+1] implies the mask is the 12 most significant bits, and in agreement with SIR conventions the bits mean:

Also, similar to SIR, there exists a variable called OPTION which varies the action of the translator.

[--PAGE 22--]

The bits mean:

The method of testing is shown as e.g.:

Finally, in dealing with the flowcharts, certain abbreviations have been used, but it is hoped that in the main they are self evident, some examples are given below.

Note The symbols ∧ and ∨ are also used in logical tests, e.g.

(E=0) ∧ (M=1)

8.   Reference Lists

It has been found convenient to have certain lists available for immediate reference, These are:

[--PAGE 23--]

(i)   Types

[--PAGE 24--]

(ii)   Delimiter 8 bit Codes (internal entities)

[--PAGE 25--]

(iii)   Table of error numbers

[--PAGE 26--]

[--PAGE 27--]

[--PAGE 28--]

(iii)   GLOBAL VARIABLES

[--PAGE 29--]

[--PAGE 30--]

[--PAGE 31--]

[--PAGE 32--]

9.   Notes on Translator listing

[--PAGE 33--]

CENTRAL LOOP

The basic cycle routine (BCR) fetches the next ALGOL "section", which is in one of the following three formats, and sets the variable M to be

A delimiter being a basic symbol like 3 or +, or an ALGOL word like begin.

Depending upon the delimiter discovered, a transfer of control is made to the relevant routine, which will end with a jump back to OUT. In some cases BCR is called during the routines (e.g. in procedure it is called to check whether the procedure body is in ALGOL or in own code) and in these cases exit is made back to OUT2, and processing continues on that delimiter.

BCR is called with one parameter which can be either 0, 1, 2, 3 or 4. The first three require the section to comply with this forecast for M. BCR (3) is the general call which will accept any section, and BCR (4) is the call during subsequent discarding of the rest of an erroneous statement or declaration, or of a comment.

ERRORS

[--PAGE 34--]

FAIL    [Flowchart--] [Code]

This routine is accessed whenever a failure occurs which doesn't make continuation impossible, N.B. If the stack Pointer moves beyond the beginning of the stack this is considered impossible and the program jumps straight to ENDPRO. In general, the action taken is to throw away the remainder of the statement.

First the error message is printed which gives the error number, line number, line stored in INBUF and a pointer which shows which is the offending character (except in the case of an illegal character when the whole buffer is inspected and illegal characters replaced by ? or ← (westrex). The: error count is incremented and the program terminates if it reaches 20. The option is inspected and set to checking mode, followed by a pause in the 'halt on error' condition. It is here that a return is then made to NCLAPS if an unallocated label has been found, otherwise the stack is cleared back to a begin, and the global variables are reset.

The current delimiter is then inspected. If not a ;, end or begin, the next ALGOL section is brought in to replace it, and this is repeated until one of these delimiters occurs. FAIL then exits to either the routine BEGIN, or internally to END or SEMICO unless the text is found to be inside a procedure heading when the rest of the heading is discarded before processing.

[--PAGE 35-]

TAKCHA (Take Character)    [Flowchart] [Code]

This subroutine, called from BCR, places the next significant character in the source line into the global variable space. The current character is moved to LASTCH, the character just received is put to LASTCH+2 for the 'look ahead' facility, while the character currently there becomes the present character to be processed, and moves to LASTCH+1, "space" or "tab" are ignored; "newline" replenishes the source line in the buffer by the use of the subroutine FILBUF.

The only characters requiring further study are : and ). The former may be followed by = to produce :=, and the tests on this branch are used to ascertain whether this is the case.

The latter, closing round bracket, may be the start of a comment acting as an actual parameter delimiter.

E.G:

PROCCALL (a) this is a comment ; (b);
   is the equivalent of PROCCALL (a,b);

PROC is tested to see whether we are dealing with a procedure call, and if so, the next character in the line is tested to see if it is a letter. This differentiates between

    PROCCALL (a) this is
and PROCCALL (a

If this is a comment, the buffer is searched for the terminating colon ; when found, the next character is checked to be (, and THISCH is set to comma (the other valid form of parameter delimiter).

ERRORS:

[--PAGE 36-]

IDENTIFIER    [Flowchart] [Code]

This routine merely builds up the identifier character by character in the state variable NAM, ignoring any significant character after the sixth (an IFIP ALGOL subset restriction).

It is called from BCR when the next character is found to be alphabetic, and reads characters storing them in the most significant end of the double length pair NAM and NAM +1, It sets M to 1 and exits when a delimiter is found.

[--PAGE 37-]

EVALNA    [Flowchart] [Code]

This subroutine, called from BCR, converts a delimiter such as ~begin~ into an integer. The routine clears a location then adds successive characters to it multiplying each intermediate result by 67. When the closing character is met, the result is looked up in a table and replaced by the required delimiter.

ERROR

[--PAGE 38-]

NUMBER    [Flowchart] [Code]

This subroutine (written by C.W. Nott of N,P.L) ends by placing the binary equivalent of the decimal digits in the state variable CONSTA and CONSTA+1.

This routine calls its own local routines; STAND which standardises the floating point number in W3 and W4 (binary exponent in W5); POWER which multiplies the number by the accumulator to the power of 10. Bearing in mind also the uses of the variable space (below) the routine should be clear from the flowchart,

ERRORS

[--PAGE 39-]

BASIC CYCLE ROUTINE (BCR)    [Flowchart] [Code]

BCR itself uses several subroutines, First it calls TAKCHA, which brings up the next character which is tested to distinguish between delimiters, numbers and identifiers.

A ~ (or " in 903 ALGOL) announces an ALGOL word (see Notes on Internal Character Set), such as ~begin~. This is operated upon by the subroutine EVALNA to convert the string of characters into an integer, and the delimiter list is then searched. If the delimiter is comment, further characters are taken UNTIL ; is met, which ends the comment. If the delimiter is true or false CONS, M, and CONSTA are set. Otherwise this joins the basic symbol path.

If this character is a basic symbol, the symbol list is searched, P is checked where necessary and the routine finishes.

If this character is a digit, decimal point or 10, NUMBER is called to place this number in the variable CONSTA.

Similarly in the case of a letter, IDENT is called to place this identifier in the variable NAM.

ERRORS

[--PAGE 40-]

UNSTAK    [Flowchart] [Code]

This subroutine is used to unstack items from the top of the stack UNTIL an item is reached whose stack priority is less than the value given by the parameter, or UNTIL the stack is empty. In general, items are unstacked directly into the object program (in some cases after extensive typechecking) with the following exceptions:

ERRORS

[--PAGE 41-]

EXP    [Flowchart] [Code]

This subroutine is used to check the validity of use of the current delimiter and to change the state variable E to expression level if necessary.

The parameter P has the following meaning:

UNSTAK is called with a parameter of 12 to unstack IND (the parameter P deciding whether INDA or INDR is to be generated), and the top of the stack tested to see whether := necessitates a changing of E to zero, Logical, arithmetic and relational operators in statements other than procedure calls are failed here.

ERRORS:

[--PAGE 42-]

PRAMCH    [Flowchart] [Code]

This subroutine is called from ACTOP to check the actual parameter with the correcponding formal parameter and to compile the relevant object program operation which will access this actual parameter for the procedure that is being called.

TABLE 1 gives a list of formal parameter types with the possible actual paramete types. In general, the rules are :-

The choice is further complicated, in the case of scalars, by the fact that an actual parameter may itself be a formal parameter. Table 2 gives the possibilities for this case.

The subroutine uses the following variables:-

The first job of PRAMCH is to recognise whether the parameter is of a formal procedure or not, then W locations 7 to 10 are set up the formal entry, V formal, type of formal and type difference (actual type - formal type). Next in the cases PRAMCH (0) and PRAMCH (3) when parameter checking words are compiled W14 is set with the check word, then W11 is set with a bit pattern according to W7, the formal entry, which later helps with the processing of

[--PAGE 43-]

identifiers, non-formal function designators and array subscripts.

Little remains now except the somewhat tedious syntatical checking and to compile the parameter call. After this is compiled the parameter checking word if applicable and the routine exits to ) or comma.

ERRORS

[--PAGE 44-]

TABLE 1

[--PAGE 45-]

TABLE 2

[--PAGE 46-]

Actual Parameters which are Formal Parameter Scalars

Example

real procedure P (t) ; value t; integer t;
   begin real R;
    R := t
    end
     .
     .
     .
    procedure Q (a,b,c); value a; integer a,b; real c;
    begin real Y;
       Y := P (a) +P (b) + P (c);
    end
     ;
     .
     .
Q  (JIM, FRED, BILL) ;

The call of procedure Q with actual parameters JIM, FRED and BILL will give value, address, address on the stack since the formal parameters are value a, name b,c. However, the procedure P expects an integer value on the stack, since its formal parameters t is called by value. So the final two parameters are called by Take Formal Value which puts the result in the stack.

In the following table of actual parameter operations, procedure Q would be SOURCE and procedure P would be DESTINATION.

TABLE 2

[--PAGE 47-]

SEARCH    [Flowchart] [Code]

This subroutine searches the Name List for the current identifier, and is called with one of four parameters:

In the case of w = 0, each time a block stopper is passed, the block number stored with it is copied into BN+2 (Found Block Number).

When the identifier is found (and that is what is desired), it is marked as used (for later checking in NCLAPS (COLLAPSE NAME LIST) and, where necessary, resets TYPBOX, Certain checks then follow, such as, is the identifier preceding a [ an array or switch; is the identifier preceding a ( a procedure with parameters or a formal procedure zero.

ERRORS

[--PAGE 48-]

SECODL    [Flowchart] [Code]

This routine searches the constant area for a given constant. The global variable Q is used to search CODL; where the constant is not found it is entered, updating the pointer CODLP.

[--PAGE 49-]

TAKE IDENTIFIER    [Flowchart] [Code]

This subroutine is used to find the nanelist entry for the current identifier and to compile the correct object program Take Address or Take Value operation.

The subroutine SEARCH fails if the identifier is not found in the Namelist and leaves I pointing to the entry if found. An extra check is made that an identifier occurring in an array declaration is non local. The type of the identifier is then inspected to determine which object program operation should be compiled.

[--PAGE 50-]

TABLE 1

ERRORS

* TFA and TFV are the same interpreter primitive.

[--PAGE 51-]

TAKE    [Flowchart] [Code]

This subroutine is used to process an identifier or constant that is used in a statement or expression, However, if the current ALGOL section does not contain an identifier or constant, the last delimiter is checked, and if it is ] UNSTAK is called to generate INDA or INDR as required.

If the current ALGOL section contains an identifier, it is processed by the subroutine TAKE IDENTIFIER (which uses the P which is a parameter to TAKE).

It should be noted that P = 1 when on the right hand side of an assignment statement, otherwise it is 0.

Where the current ALGOL section contains a constant, P is checked to remove errors such as "2:=", and after a check that a Boolean constant is not used in an arithmetic expression CODL is searched, having the pointer Q set. CONS is set by BCR; to zero if real, to one if integer, and to two if Boolean, The test on CONS determines what instruction to generate before exit.

ERRORS

[--PAGE 52-]

TYPCHK    [Flowchart] [Code]

This subroutine, called during a for clause, checks the type of the controlled variable (held in LOKTYP) against the type of the current identifier (held in TYPBOX). It generates a conversion if necessary, and resets TYPBOX to the type of the controlled variable.

[--PAGE 53-]

ACTOP    [Flowchart] [Code]

This subroutine is used in conjunction with PRAMCH to check the legality of an actual parameter and to compile the appropriate object program instruction.

A count of actual parameters in the current procedure call is kept in PRMCOU which is checked, in the routine ')' against the number of parameters in the namelist entry for the procedure name.

If E is set to expression level, this actual parameter could be an expression or a procedure call.

The difference between these cascs is shwn by the top of the stack; in the latter case the top of the stack is '(' since each actual parameter unstacks back to the '(' of its procedure call; in the case of an expression, the top of the stack will be an arithmetic, relational or logical operator. If this actual parameter is an expression, TAKE and UNSTAK are used to complete the processing of the preceding expression, E is reset to 1, and PRAMCH is called to check that the corresponding formal parameter is a scalar called by value, and to compile a type conversion if necessary.

If this actual parameter is a procedure call, PRAMCH is used to check that the corresponding formal parameter is a scalar called by value.

If E is set to statement level, the last delimiter (LASTDL) is examined to determine between the three possible types for this actual parameter.

In the first case, the top of the stack is used to determine whether this is an array or switch subscript. If the former, PRAMCH is used to check that the formal parameter is a scalar called by value, and to compile a type conversion if necessary. If the latter, the top of the stack is GTS or GTFS and PRAMCH is used to check that the formal parameter is a label called by value.

In the second case, PRAMCH is used to check that the corresponding formal parameter is a string called by name.

[--PAGE 54-]

ACTOP (Contd)

In the third case, M is tested to determine whether the actual parameter is an identifier or a constant. If M = 1, this is an identifier and the Namelist is searched to find the declared entry. PRAMCH then checks the type of the actual parameter with that of the formal parameter and compiles the relevant object program operations.

If M = 2,this actual parameter is a constant. and SECODL is used to find or enter the constant in the constant list, and PRAMCH is used to compile the correct "Take constant" operation.

Calls of PRAMCH:

ERRORS

[--PAGE 55-]

ARRAY BD    [Flowchart] [Code]

This subroutine, called by the delimiters , and : , checks the validity of their use. TAKE and UNSTAK are called to complete the processing of the preceding subscript bound expression, at which time the top of the stack should be the opening square bracket introducing the subscripts.

If this is in an array declaration, XX is used to check that (e.g.) :

real array X [a:b: .....

        is caught as illegal, and the count of subscripts is incremented in DIM and restacked.

When this is during the use of the array, any necessary conversion is generated before restacking the incremented count of subscripts.

ERRORS

[--PAGE 56-]

DEC    [Flowchart] [Code]

This subroutine is used by any delimiter that starts a declaration (e.g. integer); it checks the validity of its use and sets up a block if this is the first declaration after a begin.

If begin ALL is on the top of the stack, no action need be taken.

If begin is top, a stopper entry is made in the Name List and the block number updated (begin TR would have already done this). The begin entry is unstacked, and P tested to see if this routine has been called from array. If so, a block entry is compiled into the object program. DECSTA is set to 8 0 before exit.

ERRORS

[--PAGE 57-]

DECL    [Flowchart] [Code]

This subroutine is used to enter all declarative information into the Name List.

After checking that the identifier has not already been declared during this block, name and type are entered. The parameter is then examined for the type, as follows:

ERROR

[--PAGE 58-]

ENDSTA    [Flowchart] [Code]

This subroutine is used to complete the processing of a statement. If an input/output statement is terminating the marker is cleared and E set to 1. DECSTA is set to statement level and EXP is used to change the state variable E to expression level if necessary. If E is zero, TAKE is called to generate the correct instruction, and ARITH, E, and EXPTYP are set up to deal with the next statement.

Otherwise, if the current section contains an identifier (which must be a procedure identifier), the Name List is scarched to discover whether this identifier is a formal parameter before generating the relevant instruction. EXPTYP is cleared before exit.

ERRORS

[--PAGE 59-]

FORCOM    [Flowchart] [Code]

This subroutine is called at the end of a for list element to compile the correct object program operation. TAKE and UNSTAK are used to complete the processing of the preceding expression and the top of the stack (TS) is then used to determine between the various kinds of list element.

N.B. if FORCOM is called by ',' this could be the delimiter between dimensions in an array subscript used in a list element.

In cases (i), (ii) and (iii) the type of the controlled variable is restored from the stack into LOKTYP, and TYPCHK is used to compile a type conversion if necessary. The relevant object program operation is then compiled and a check is made that the top of the stack is for, and an exit is made back to ',' or do.

In case (iv), the number of dimensions is updated and stacked with '[' and a return made to the CENTRAL LOOP, to read the next ALGOL section.

ERRORS

[--PAGE 60-]

COLLAPSE FORMAL PARAMETERS (FCLAPS)    [Flowchart] [Code]

This subroutine is called from the delimiter ; , such as in the following example:

integer procedure P (a,b,c); integer a,b,c ;
        P := a + b ;

At this stage the name list will look like this

The block stopper is erased, and for type procedures a check made that an assignment has been made to the procedure identifier during the procedure body.

The V bit in the procedure name list entry is cleared, as we are now no longer in the procedure body and recursion cannot occur. WM is set and a warning message is given for every paraneter not used, as these parameters are inspected and condensed to one-word entries containing type and whether by value or not.

ERRORS

[--PAGE 61-]

COLLAPSE NAME LIST (NCLAPS)    [Flowchart] [Code]

This subroutine, called from end, resets the Name List Pointer to the position it held before the current block began, and reinstates the previous block number. If any identifier is declared and not used, a warning message is produced, except in the cases of switch names which are ignored, and label names where the warning message is upgraded to a fail. The variable CNL is set on entry so that if more than one label is unallocated each will give a failure message.

ERROR

[--PAGE 62-]

real, integer, Boolean    [Flowchart] [Code]

W is set up with the corresponding type, and a check is made that DECTYP is zero. If not, this would mean that we were already in a declaration (as DECTYP is set to zero on ;) such as

begin real integer ......

DECTYP is then set up with the type from W, and DEC is called with a parameter of 1. This in effect looks back over its shoulder to see whether this is the first declaration in a block (if it is DEC will have to update Current Block Number, DECSTA etc).

ERRORS

array    [Flowchart] [Code]

The subroutine DEC is used as described above, and a check is made on DECTYP. The failure path is exactly like the one above, where we are already in a declaration other than real, integer or Boolean (e.g. "begin string array....").

If DECTYP is set to real, integer, or Boolean, it is further limited to array; if DECTYP is 0, ALGOL specifies that a non-type array is treated as a real array, and DECTYP is thus set. MAMPS (Make Array Maps) is then stacked.

ARRCOU becomes zero ready to count array names (see , (comma) which calls DECL (3))

e.g.: begin real array A,B,C,D, [ ......

ERRORS

[--PAGE 63-]

begin    [Flowchart] [Code]

This routine checks that begin has been used to start a block or statement and sets DECSTA to zero. Note that no block entry is compiled or set up in the Namelist since it is not yet known if this begin starts a compound statement or a block. This work is done in DEC by the first declaration following a begin.

ERRORS

[--PAGE 64-]

do    [Flowchart] [Code]

The subroutine FORCOM completes the object program instructions for the preceding for list element. The object program 'For Statement End' is then compiled and an instruction to update the address following 'For' in the object program to point to the controlled loop. A stack entry is made of for begin to show that this is a for statement, with the second address following 'For' which will be updated to point to the statement following the for statement. The block name is also updated to its highest value.

The 'for clause' is defined in ALGOL as being followed by a Statement (a construct wide enough to include a Block, or another for statement). E is therefore set to 1 (to show that a statement is expected); ARITH and F (the for clause marker) are cleared - the latter was only of use during the processing of the for clause.

[--PAGE 65-]

else    [Flowchart] [Code]

The object program for the preceding statement or expression is completed by TAKE and UNSTAK. If the top of the stack is 'then S' the subroutine ENDSTA is used to compile the procedure zero call.

e.g. if a < b then procedure else go to label;

The top of the stack is then tested for ‘then S' or 'then E' to differentiate between a conditional statement and a conditional expression. In each case a UJ operation is compiled which will be updated at the end of the statement, and the IFJ operation around the then part is updated.

Finally 'else E' or 'else S' is stacked, (in the case of an expression TYPBOX is stacked to show the type of the then expression), as is the address of the incomplete UJ operation around the else part.

In the case of conditional statements E, ARITH and EXPTYP are reset for the following statement.

[--PAGE 66-]

end    [Flowchart] [Code]

DECTYP is checked to make sure that this delimiter does not complete a declaration (e.g. begin real a end), and the subroutines ENDSTA and UNSTAK are used to complete the processing of the preceding statement, The top of the stack is then inspected; if end shows that we are ending a for statement (TS = for begin) we must cycle round (having compiled something into the object program using FSEND) and inspect it again, because ALGOL's definition of a for statement is recursive (see diagram) and therefore one end may terminate lots of for statements.

Having unstacked any lurking for begins, the top of the stack should now be a form of begin. If it is not it is a failure. e.g. for end.

Where the top of the stack is begin, this is the end of a compound statement. begin TR signifies that this is the end of a block containing no array (i.e. no block entry compiled), and begin ALL that this is the end of a block containing an array (and therefore there is an unconditional jump to be updated). For the relevant entries that are unstacked here, see DEC.

In the case of a block, the name list is collapsed back to the first entry for this block, as all the variables declared local to this block are now no longer valid.

A test is then made for the end of the program (is stack empty) and if so ENDPRO is accessed. Otherwise BCR is called to extract any comment following end

e.g. end of this routine;

A warning message is emitted if there is a delimiter in this section, which will catch

end
x := 1;

Final exit is to OUT2, as BCR will already have recognised

[--PAGE 67-]

one of the delimiters which terminate an end comment, namely end, else or ;.

ERRORS

[--PAGE 68-]

for    [Flowchart] [Code]

After checking that for is used at the start of a statement (using M, F and EXP) DECSTA is set to /0  0 since this is a statement. A stack entry is made of for together with its address in the object program. This address will be used by do to update the pointer to controlled statement. The current block name is stacked before being updated to the next highest block name for the for block.

The object program compiled contains two markers which will be updated by the addresses to the controlled statement and the statement following this for statement.

The subroutine BCR is used to read the next ALGOL section which should be 'controlled variable := '

e.g. for cv := 1 step 1 until n do _________ ;

TAKE compiles the correct object instruction for the controlled variable and a stack entry is made for the first list element with the type, held in TYPBOX, of the controlled variable. If the controlled variable is type real, the list elements must all be real and similarly when the controlled variable is type integer. The stack entry 'simple' is used to distinguish a simple list element from a 'step' or 'while' element.

Finally, ARITH and E are set for the following list element expression and F is set to 1 to show that this is a for clause.

ERRORS

[--PAGE 69-]

go to    [Flowchart] [Code]

After checking that the delimiter is used to start a statement, DECSTA is set to /0  0 to show this is a statement, The delimiter is stacked as GT since it is not yet known if this is a go to label or go to switch statement.

e.g. go to labelname;

go to s [a+b] ;

E and EXPTYP are set up for the following label or switch expression.

ERRORS

[--PAGE 70-]

if    [Flowchart] [Code]

The initial test removes as a failure such phrases as:

b := (a+b) if ...
b := A[b] if ...
if a > then if ...
b := a+b if ...

EXP is then called to set E to zero if the preceding delimiter was := as in

a := if ...

In the case of E being equal to 1, DECTYP is tested. It is normally zero (i.e. we are not in a declaration) and DECSTA is set to /0  0. It may however be set to array, as in:

real array A [1 : PROC (if ...

In this case of course DECSTA must not be changed. A test is then made to see if this is an actual parameter, and if it is E is set to zero.

If E was not equal to 1, a further test is made to remove constructs such as

y + if

The stack entry saves the state variables ARITH, E and EXPTYP and stacks if to be checked by the following then, ARITH and E are then set up for the Boolean expression in the if clause.

ERRORS

[--PAGE 71-]

Procedure    [Flowchart] [Code]

The subroutine DEC is used to set up a block if this is the first declaration in the block, a stopper is put in the name list, the marker PH is set to show that a procedure heading is being processed, and a call is made to BCR to read the next ALGOL section i.e. 'procedure name' (. A check is made that the preceding delimiter was real integer, Boolean or non-type. Unless the procedure is own code an unconditional jump is compiled to jump round the procedure body and a stack entry is made of proc. begin together with various state variables and the address (PP) of the incomplete UJ operation to be updated at the end of the procedure body.

DECSTA is set to statement level for the procedure statement following the specification part, the number of parameters (PRMCOU) is set to zero and the current block name (BN) is updated for the procedure block.

Tf the procedure has no parameters (delimiter is ;) DECTYP is set to procedure zero and the procedure name is declared in the namelist using the subroutine DECL. The procedure entry operation is compiled, DECTYP cleared and a call is then made to BCR to check whether the procedure body is ALGOL or own code.

If the procedure has parameters, DECTYP is set and the procedure name is declared in the namelist. PRCENT is used to hold the namelist address of the procedure name, and PROC is set to 1. The loop that follows reads a formal parameter, checks that it has not already been declared, enters it in the namelist and updates the count of parameters. When ')' has been read, the procedure entry operation can be compiled and the namelist entry completed with the number of formal parameters; PROC and DECTYP are cleared.

The next call to BCR should fetch ; which terminates the formal parameter part.

Another call is made to BCR to determine whether a value part or the specification part follows. Each identifier in the value part is checked for appearance in the formal parameter list. v:=l in the namelist entry. When the terminating ';' is read the next ALGOL section is read (specifier,) and the specification part is processed.

This consists of specifiers followed by identifier list(s) e.g. real a,c; There is-an inner loop to read each identifier in the list following the specifier, check that it is a formal parameter and complete the namelist entry. If the formal parameter is a switch the number of dimensions is set to 1 but if it is an array or procedure

[--PAGE 72-]

Procedure (Continued)

the number of dimensions or parameters is not yet known and is set to + 15, This number will be updated at the first occurence of this identifier with its parameters, and subsequent occurences must agree,.

If the delimiter is ';' this could be the end of the specification part or the end of this specifier list. In the former case, a check is now made that each formal parameter has been specified and if called by value that the type is not switch, string or procedure. The program then compiles the check words for the run time parameter checking.

Finally, a check is made to determine whether the program body is ALGOL or own code, If the latter DECSTA is reset to declaration level, the formal parameters are collapsed and the next delimiter is read to discard the ; 903 ALGOL requires the parameters of formal procedures to be called by name, this is checked in PRAMCH however, when a parameter is found to be of type procedure.

ERRORS

[--PAGE 73-]

step, until, while    [Flowchart] [Code]

The first test is to ensure that these delimiters are only used in a for clause, The arithmetic expression preceding the current delimiter is then completed by the subroutines TAKE and UNSTAK, when the top of the stack should then be simple, The variable G is set up with the quantity stacked with simple, and LOKTYP is also set up. TYPCHK is called to generate any conversion necessary, e.g.:-

real A, B ; integer c; for A := B+c step

and TYPBOX is then set to LOKTYP. The current delimiter is then examined.

In the case of the delimiter step, simple is restacked with a marker to indicate that the delimiter until is required, and an instruction compiled (an example of a compiled for statenent is given below). In the case of the delimiter while ARITH is set up for the algebraic expression following.

ERRORS

[--PAGE 74-]

switch    [Flowchart] [Code]

A check is made that we are not already in a declaration and then DECTYP is set to switch. The subroutine DEC is used to set up a block if this is the first declaration in the block. The next ALGOL section is fetched, which should be 'switchname :=', and LABCOU is cleared. DECL is used to declare the switchname in the namelist and make an entry in the label data area (CODL).

The loop is used to process each label in the switch list. (IFIP ALGOL allows only labels in the switch list).

e.g. switch S := TOM, DICK, HARRY;

Each label is declared in the namelist together with the address of the label in CODL and BN is entered in label entry in CODL. At the end of the switch list when ';' is read, the number of labels is entered in CODL and DECTYP is cleared.

e.g. layout of CODL for the above switch declaration.

When the left-hand label is declared, its object program address is placed in the CODL label entry overwriting the +0.

ERRORS

then    [Flowchart] [Code]

This routine first tests that we are at expression level (if not, it fails) and then completes the processing of the algebraic expression following if by calling TAKE and UNSTAK. If is then unstacked and ARITH, E and EXPTYP are restored. The state variable E is then used to decide whether then should be stacked as "then S" or ""then E", The pord pointer (PP) is also stacked, ready to update the IFJ when the delimiter else is met.

ERRORS

[--PAGE 76-]

:=    [Flowchart] [Code]

There are three possible uses of the delimiter := as follows:

The first two are dealt with under switch and for respectively, and this routine merely deals with assignment statements. After checking that we are not assigning to a constant or an expression and that we are not in a declaration, for clause or procedure call, DECSTA and SV set to /0  0 and TAKE deals with the variable (simple or subscripted) which precedes the delimiter.

As we require all left hand elements in an assignment to be the same type the top of the stack is then inspected to see if it is a :=. If not LHTYP is set to TYPBOX and the delimiter is stacked, otherwise LHTYP and TYPBOX are tested for equality and the multiple store function (STA) is stacked.

ERRORS

[--PAGE 77-]

;    [Flowchart] [Code]

Most of the processing for a ; in a declaration is dealt with in that declaration

e.g. switch or scalar do their own, and array declaration is done in RSBRAK

STATRM is then called to complete the processing of the read or print statement. ENDSTA is used to complete the processing of the constituents of the statement otherwise, and the top of the stack is then tested.

If this is for begin, the one or more for statenents are completed. If it is proc begin this is unstacked, the variables stacked with it are restored, and COLLAPSE FORMAL PARAMETERS is called to condense the formal parameter entries in the Name List to two parts - type, and whether the parameter is called by name or value.

If the top of the stack is any other form of begin, the routine is finished.

ERRORS

[--PAGE 78-]

Arithmetic Operators (+ - x / div )    [Flowchart] [Code]

As the treatment of these operators differs only slightly their stacking priority is recorded and then they share the routine. Their validity is checked using EXP which sets E to expression level. If the operator is not preceded by an identifier or constant and is not a closing bracket it is stacked with its type and associated priority, except for special cases unary plus which is ignored, and unary minus which is noted for special action.

Otherwise the identifier or constant is dealt with and TAKE and UNSTAK are called, or in the case of the closing bracket just UNSTAK.

ERRORS

[--PAGE 79-]

Relational Operators (< > ≤ ≥ ≠ =)    [Flowchart] [Code]

After checking the validity of the use of the operator, TAKE and UNSTAK are used to process the preceding identifier or constant, and to unstack any operators with priorities greater than or equal to the priority of the current delimiter.

The current operator is then stacked with its stack priority and the type of the preceding variable or expression. E is set to expression level.

ERRORS

[--PAGE 80-]

Logical Operators (⊃ ∨ ∧ ¬ ≡)    [Flowchart] [Code]

The stack priority of the present operator is stored and a check is made on the use of this delimiter. setting E to expression level, further checks are if the current operator is a ¬. Except in that TAKE and UNSTAK are used to process the preceding fier and to unstack any operators with priorities or equal to the priority of the current operator, the delimiter is stacked with its priority.

ERRORS

[--PAGE 81-]

[    [Flowchart] [Code]

This routine deals with the use of this delimiter for a subscripted variable, a switch designator or as the start of a bound pair list in an array declaration.

If DECTYP is clear, this can be a subscripted variable or a switch designator, and DECSTA is set to statement level, TAKE is used to process the switch or array identifier and leaves I pointing to the namelist entry. If the preceding identifier is type array, a stack entry is made of [ together with the current values of the state variables. E, ARITH and EXPTYP are then set for the following arithmetic expression.

If the preceding identifier is type switch a test is made that the previous delimiter is go to unlessthis is an actual parameter.

Example:    go to S [4] or FUNCTION (S[4],p)

GTFS or GTS is stacked depending on whether this is a formal parameter reference or not, together with address in the namelist entry. The current delimiter is then stacked.

If DECTYP is set, this delimiter is being used to start a bound pair list or to start a subscript expression inside a bound pair list.

Example:    array TABLE [1 : LIST [3], 2: n]

The former case is shown by the fact that the top of the stack is MAMPS (array map) and DECL is used to declare the array name in the namelist. '[' is stacked with a dimension count of 1, a marker of 0 to signify lower bounds and I to give the namelist address of the arrayname.

In the latter case, E is set to expression level and TAKE is used to process the preceding array name, before [ is stacked.

ERRORS

[--PAGE 82-]

]    [Flowchart] [Code]

The preceding expression is completed using TAKE and UNSTAK. The top of the stack then indicates whether this is an array or switch subscript expression, or an array bound pair list.

In the former case the top of the stack is [ and the TYPBOX is tested to determine whether the subscript expression is type integer or real. If real, a conversion to integer must be compiled. The values of the state variables as at [ are then restored from the stack. The number of dimensions counted on the stack with [ is checked with the array declaration in the namelist. If this is -1 in the namelist (formal parameter specifier) the number of dimensions is now entered.

Example:     procedure P (b) : array b ;
                      A := b[1,3,n] ;

When the array b is used, it is found that the number of dimensions is 3 and can therefore be placed in the namelist entry for b.

If this is a switch subscript, there must be only one dimension. Finally, if this is an array subscript, INDR is compiled in the case of an expression and IND is stacked in the case of a statement since it is not yet known if INDA or INDR is required.

Example:     A [2] := B [1, n] := ......

In the latter case, when this is an array declaration, the number of dimensions is placed in DIM, a lower/upper bound marker in XX and I is restored to the array namelist entry. A check is made that the bound pair ended with an upper bound (xx = 1), and E and ARITH are set for the following declaration or statement.

The top of the stack should then be MAMPS and this is compiled with the number of dimensions and arrays (ARRCOU). The namelist entries for each array are then updated with the number of dimensions and the address of the array map in the object program. Finally, the shared map is compiled.

Example:     array A,B,C [p;q, s:t]

ARRCOU will be 3 and number of dimensions will be 2.

ERRORS

[--PAGE 83-]

:    [Flowchart] [Code]

DECTYP is used to decide whether the current identifier follows a label or a lower bound in an array declaration.

in the latter case, ARRBND processes the current ALGOL section.

In the former case, EXP is used to check the validity of the use of the label, and DECSTA is set to statement level (as one cannot label a declaration without an intervening begin), The Name List is then searched for the label (which must have been declared in a prior switch list declaration), and the label entry in Label Object Data Load (CODL) should have an address part of zero. If not, this label has been met on the left-hand side of a colon twice and this is an error.

The next test is to see whether this label has been declared in the current block, If it hasn't, it is an error except in the case of procedure definitions or for clauses (see example below). In these cases, the existing entry in CODL is cleared and a new entry made.

ERRORS

begin real c; switch S:= LABEL;
procedure P (q,r,s); integer q,r,s;
LABEL: begin q := r+s;
       go to LABEL
end;

If the first begin sets the block number to (say) 52, LABEL is entered by its declaration in Block 52. But procedure P resets the block number to 53, and when LABEL is met on the left-hand side, the block numbers do not correspond.

[--PAGE 84-]

,    [Flowchart] [Code]

This routine deals with various uses of the delimiter , .

ERRORS

[--PAGE 85-]

(    [Flowchart] [Code]

After the initial checks to catch subscripted constants and ( immediately following a closing bracket DECTYP is tested to see whether we are in array declaration or in a statenent. The state variable M will tell us whether this delimiter is being used as an expression bracket or in a procedure call.

In the case of an array declaration, a failure is indicated if E is set to statement level, unless PROC shows that an actual parameter is being processed, e.g.

real array A [1: PROC (a, PROC2(....
or real array A (4: PROC (a, (b + c ....

The former example will cause M to be set at 1, and the latter zero, which is the subject of the next test. Where this is a procedure call, the flowchart joins with the path where DECTYP was zero and this was a procedure call (which has already called EXP to change I to expression level if necessary, and set EXPRES in the case of a read or print statement e.g. read reader (1)...)

The case of "go to S (..." is failed by the next test on EXPTYP; and the procedure name is then searched for in the Name List. If we are in an array declaration, we check that the array bounds are not local (illegal ALGOL), before discovering whether this is a type procedure, If so, space is reserved on the run-time stack (by compiling PRIM UP) for the result of the type procedure, Various variables are then stacked with the delimiter, and these variables are then set up to deal with the actual parameters of this procedure call.

In the case of expression brackets used in statements, the delimiter is stacked, and PROC set to zero while processing the constituents of the bracket.

ERRORS

[--PAGE 86-]

)    [Flowchart] [Code]

The state variable PROC indicates whether this delimiter is an expression bracket or a procedure call bracket.

If it is an expression bracket, we first check that we are in fact within an expression. This kills "a + (b)". The translation of the preceding expression is completed using TAKE and UNSTAK, after which the top of the stack should be the delimiter (. This is unstacked and discarded, having reset PROC to the stacked value.

If it is a procedure call bracket, ACTOP is called to complete the translation of the preceding parameter, PROCPO is saved in I after the top-of-stack test, and the stacked state variables restored. A test is now made to see whether the count of parameters in the call is equal to that in the declaration; if not, it may be that this procedure is itself a formal parameter. If so, the specifier in question has not told us how many parameters are required, and we must fill the count in from this call. However, we must first check that this count has not been filled in by some previous use, if so it must fail as in the last line of the following example.

real procedure JIM (a,b); integer a ; real
             procedure b;
begin integer q,r,s;
     b (a,r,s);
     b(q,r);

The test on f [I] determines what sort of instruction to compile for this procedure call. Finally, if E is set to statement level a check is made that the next delimiter is an "end-of-statement" delimiter, otherwise in the expression case TYPBOX must be set.

ERRORS

[--PAGE 87-]

{ (string opening quote)    [Flowchart] [Code]

This routine checks that this string is being used as an actual parameter, or in a print statement, and then compiles an unconditional jump around the string, which will be updated when the last character in the string is read. There is a count of nested string quotes, and the characters are packed for the object program. When the final closing string quote is read, the UJ operation is updated and '}' is stored as the last delimiter. If a parameter case the following call to BCR should fetch ' ,' or ')', and ACTOP is then called. If a print statenent INOUT is compiled, and the delimiter which may be end or else also decides the following action.

Example    PROCALL (a, {string}, {otherstring})

After compiling the actual operation for the string, ACTOP is used to check that the corresponding formal parameter is specified as string called by name. E is set to statement level and if the current delimiter is ')' exit from this routine is to ) entry 2 to complete the processing of the procedure call.

ERRORS

There are more subroutines / entry points in the source of the Translator than described above. Here is a list of these undocumented routines with links to their flowchart and corresponding code.

ADJI:   [Flowchart] [Code]

ARRBND: [Flowchart] [Code]

ARENT2: [Flowchart] [Code]

BLANKS: [Flowchart] [Code]

CHECK:  [Flowchart] [Code]

CODE:   [Flowchart] [Code]

COMP:   [Flowchart] [Code]

COMP2:  [Flowchart] [Code]

COMPIL: [Flowchart] [Code]

ENDPRO: [Flowchart] [Code]

FOMCOM: [Flowchart] [Code]

FILBUF: [No f]lowchart] [Code]

RESTO:  [Flowchart] [Code]

GETCHA: [Flowchart] [Code]

INOUT:  [Flowchart] [Code]

LINO:   [Flowchart] [Code]

LISTAD: [Flowchart] [Code]

MIDTRM: [Flowchart] [Code]

OUT:    [Flowchart] [Code]

OUT2:   [Flowchart] [Code]

PCHAR:  [Flowchart] [Code]

POWER:  [Flowchart] [Code]

PRESTO: [Flowchart] [Code]

PRINT:  [Flowchart] [Code]

PUNGLB: [No flowchart] [Code]

PUNGRP: [Flowchart] [Code]

PUNCHA: [Flowchart] [Code]

READ:   [Flowchart] [Code]

RESTO:  [Flowchart] [Code]

SETPRO:  [Flowchart] [Code]

STACK:  [Flowchart] [Code]

READ:   [Flowchart] [Code]

START:  [Flowchart] [Code]

STATRM: [Flowchart] [Code]

STRENT: [Flowchart] [Code]

TAKCHA: [Flowchart] [Code]

TITLE:  [Flowchart] [Code]

UPDATE: [Flowchart] [Code]

WMESS:  [Flowchart] [Code]