Software portability - Open Research Online oro.open.ac.uk

Open Research OnlineThe Open University’s repository of research publicationsand other research outputs

Software portabilityThesisHow to cite:

Smith, R P (1986). Software portability. MPhil thesis The Open University.

For guidance on citations see FAQs.

c© 1985 The Author

https://creativecommons.org/licenses/by-nc-nd/4.0/

Version: Version of Record

Link(s) to article on publisher’s website:http://dx.doi.org/doi:10.21954/ou.ro.0000f8fe

Copyright and Moral Rights for the articles on this site are retained by the individual authors and/or other copyrightowners. For more information on Open Research Online’s data policy on reuse of materials please consult the policiespage.

oro.open.ac.uk

http://oro.open.ac.uk/help/helpfaq.html

https://creativecommons.org/licenses/by-nc-nd/4.0/

http://dx.doi.org/doi:10.21954/ou.ro.0000f8fe

http://oro.open.ac.uk/policies.html

UNieesmcre.DISSUE 3

SUBMISSION TO THE OPEN UNIVERSITY AS A THESIS FOR THE DEGREE OF MASTER OF PHILOSOPHY

SOFTWARE PORTABILITY

AUTHOR : R P SMITH

ProQ uest Number: 27775912

All rights reserved

INFORMATION TO ALL USERS The quality of this reproduction is dependent on the quality of the copy submitted.

in the unlikely event that the author did not send a complete manuscript and there are missing pages, these will be noted. Also, if material had to be removed,

a note will indicate the deletion.

uestProQuest 27775912

Published by ProQuest LLC (2020). Copyright of the Dissertation is held by the Author.

Ail Rights Reserved.This work is protected against unauthorized copying under Title 17, United States Code

Microform Edition © ProQuest LLC.

ProQuest LLC 789 East Eisenhower Parkway

P.O. Box 1346 Ann Arbor, Ml 48106 - 1346


CONTENTS1 INTRODUCTION2 CONCEPTS OF PORTABILITY

2.1 The meaning of Portability2.2 Transporting Programs2.3 Tools

3 AN INTERMEDIATE LANGUAGE3.1 Ivor Abstract Machine3.2 Program Segmentation3.3 Definition Stream3.4 Declarations3.5 Operation Stream3.6 Constant Stram3.7 Example of Use

4 MULE4.1 The Mule Language4.2 The Pilot Implementation4.3 Test Programs4.4 Conclusions

5 REFERENCES APPENDIX

ACKNOWLEDGEMENTI gratefuly acknowledge the help of Mr M Taylor in the design of the Case operations of the Ivor abstract machine. I acknowledgealso the assistance of my OU tutor, Dr Max Bramer.

SUFTWAKE PORTABILITY

1. INTRODUCTIONThis thesis represents the submission to the Open University for the degree of Master of Philosophy.The research topic lies within the discipline of computer scienceand in particular problems associated with the transportabilityof computer software are investigated.The study period was organised into 3 parts :

- A literature search to look at what work had been done inthe area.- The design of an intermediate language for a compiler.- The specification, design and implementation of a functional programming language in order to develop a portable programming environment.

This thesis covers the work of the period Sep78 to Jun82, all of which was performed by part time study.The Thesis comprises 4 major sections and an appendix which shows program listings. The sections are as follows :

- Section 1 : The introduction- Section 2 : The result of a literature search.- Section 3 : A design for a compiler intermediate language,Ivor, covering the architecture of the underlying abstract machine and the structure of the intermediate language.- Section 4 : The design and implementation of a function based programming language. Mule, including the structure of the language and a description of the implementation.


2 CONCEPTS OF PORTABILITY2.1 The Meaning of PortabilityIn electronics hardware it is not surprising to talk about 'plug compatible' components developed by different manufacturers, performing identical functions and being completely interchangeable. Software has been treated differently and it is generally accepted that a program running on one computer will not run automatically on another.The problem of having 'plug compatible' software is usually one of specification. Hardware components can be specified (almost) precisely and the language used to specify the component and its environment are based upon basic scientific or engineering laws and with well understood parameters. For example : operatingtemperature, voltage levels, capacitance, ohmic resistance, frequency of applied signals, etc.A software item is usually specified in terms of : the functions the program is to perform, the acceptable inputs, the acceptable outputs, performance requirements, reliability requirements and (sometimes) environmental constraints. Acceptable inputs are often defined in some form of BNF with semantics definedinformally as English prose. Rarely are all of the possibleoutputs defined, particularly error cases which are left to the software designer to invent. The remainder of the specification is usually written in an informal way and some of the quantitative restrictions are not documented at all.The problem of transportability of software lies with the specification which inadequately addresses the requirements of the program and the definition of the operating environment.The following sections will look at some of the documentedmethods of reducing the problems associated with porting programs, in particular : high level programming languages,universal assemblers and abstract machines, specification methods.2.2 Transporting ProgramsA customer usually does not want a program transported from one environment to another, though he may express his requirements in those terms. What the customer wants is an (almost) identical set of facilities on the new environment. In [Reference 3 :Brown (Editor)] a program is defined as portable if the effort required to move the program is significantly less than that required to rewrite it. It seems that in practice if more than 20% of a program requires rewriting it is preferable to start again, unless the software is very well structured.Programs are not automatically transportable and portability needs to be designed into the program. The following sections


look at methods which may be employed to make programs moreportable.2.2.1 High Level LanguagesThe high level language is an important tool used in theproduction of software. The disciplined use of a suitable high level language ensures the production of a structured and well produced program which can be supported and enhanced. In addition a program written in a high level language can be (theoretically) transported to any computer system for which there are language support facilities.There are many high level languages ranging from simple languages like Fortran, Basic and Cobol through to systems type languages like BCPL, BLISS, Lisp and the block structured languages like Coral 66, Algol-68, Pascal, Ada and Chill. Some of these languages are specified rigorously but many are not. Techniques for specifiying languages better and with more precision are becoming available. This is discussed further in [Reference 2 : Lucas & Lauer 1970]. In addition mathematically based 'functional languages' aimed at specifying systems fully areappearing [Reference 1 : Backus 1978] and [Reference 37 : Allen].The lack of rigour tends to produce differing interpretations by language support implementors for some of the features of the language. As a consequence a facility which operates in one way on one machine may operate in a different way on another.

As an example of this figure 2.2.1-1 shows a part of a CORAL-66 program which has,in fact, been designed to be portable. Even so, it is unlikely that the program will operate without changes on another computer for the following reasons :

- The procedure uses names which are greater than 12 characters in length. The definition of CORAL-66 states that names are significant to the first 12 characters but some implementations restrict the implementation further allowing less characters for external-names and for macro-expansion names.- On line 109 (and elsewhere) the statement 'IF' ALPHABETIC M(CHAR IL) ... disguises in the macro call that the internal character set of the underlying machine is being used to determine a condition, in this case the ICL-George 3 6bit code. The macro definition would require changing if the program were moved to, say, an ASCII or EBCIDIC character set machine.- On line 162 the character string uses "visible spaces" which are expected by this particular compiler. The compiler removes all spaces, including those within text strings. As a consequence of this the "%" character needs to be used within a text string in place of a space. This is not the

DUT

case with all compilers.

- On lines 167 to 169 the procedure sets up a character string which uses an integer to store the character string's location. The character string packing and internal character set, including the storage of the length of the character string, assumes a particular compiler storage allocation strategy.- On line 257 the code assumes a 6-bit byte, as do lines 317, 318 and 319 though the use of a 6-bit byte is disguised by the use of macros.

bUFTWAKE FUKTABiLilTY

Figure 2.2.1-1002 PROCEDURE fetch element pg;098 BEGIN099 INTEGER ARRAY element dl[0:char lit length m];100 INTEGER char il,kl,hash il,string delimiter il;103 COMMENT read the element;105 char il := read a rel char pg;106 element dl[l] := char il;107 kl := 2;109 IF alphabetic m(char il) OR numeric m(char il) THEN112 BEGIN114 COMMENT the case of an element being an alpha-numeric

name or a literal value;118 FOR char il := read a rel char pg

WHILE alphabetic m(char il) or numeric m(char il) DO 121 BEGIN123 IF irrelevant skipped bg=true m THEN GOTO outl 11;125 element dl[kl] := char il;126 inc m(kl,1);127 END;129 outl 11:130 END ELSE132 BEGIN134 COMMENT case of the element being an operator type (ie

non alpha-numeric) name or character string;139 COMMENT check first for character string;141 string delimiter il := char il;143 IF string delimiter il = char lit 1 delimiter m OR144 string delimiter il = char lit 2 delimiter m THEN146 BEGIN148 COMMENT this is a character string literal;151 COMMENT fetch the string and return it ;153 kl := 1;155 FOR char il := ich m

WHILE char il <> string delimiter il DO157 BEGIN158 element dl[kl] := char il;159 inc m(kl,1);161 IF kl>char lit length m THEN162 errorhandler(LITERAL(e),

"Character%string%literal%is%too%long");

164 IF char il=new line m THENinc m(current line ig,l);

166 END;.he Figure 2.2.1-1 (Continued)167 element dl[0]:=kl-l; (Character string length)168 element type ig := ele char lit m;169 element ig := LOCATION(element dl[0]);


170 return m;171 END;173 FOR char il := read a rel char pg

WHILE non alpha numeric m(char il) DO175 BEGIN177 IF irrelevant skipped bg=true m THEN GOTO out211;179 element dl[kl]:=char il;180 inc m(kl,1);181 END;183 out211:184 END;185 back step m;186 char buff mark ig ;= char buff mark ig-1;187 element dl[0] := kl-1;188 COMMENT at this stage the array 'element dl' is set up such

that element-0 is the character length of the element andelement-1 to element-n contain the characters of theelement ;

195 IF numeric m(element dl[l]) THEN197 BEGIN199 COMMENT case of a numeric constant being returned ;

201 kl := element dl[0]+l;202 element ig := 0;204 FOR kl:=kl-l WHILE kl>0 DO206 BEGIN207 element ig := element ig+power of 10 dg[

element dl[0]-kl]^element dl[kl];208 END;209 element type ig := ele literal m;210 return m;211 END ELSE213 BEGIN215 COMMENT this is the complex part of the procedure where a

'name' is to be returned. Firstly it is necessary to searchthe object table to see if the name has been introducedalready;

221 hash il := 0;225 search for name 11:227 IF object string dg[hash il]<> empty m THEN229 BEGIN231 COMMENT compare string table with the elements stored

in 'element dl';235 FOR kl:=0,kl+l WHILE kl<= object string dg[hash il] DO237 BEGIN


239 IF element dl[kl]<> object string dg[kl+hash il] THEN241 BEGIN243 COMMENT the name is not the element so try the next

name ;245 hash il := hash il+4+object string dg[hash il];246 repeat m(search for name 11);247 END;248 END;

250 COMMENT this is the element name so fetch the object table index and return it in 'element ig' whilstsetting 'element type ig' to 'ele operand m';

256 hash il:=hash il+object string dg[hash il]+l;257 element ig:=object string dg[hash il]*64*64 +

object string dg[hash il+l]*64 +object string dg[hash il+2];

259 element type ig := el operand m;261 IF in intro bg <> false m AND

element ig <> rat dot m AND element ig <> rat colon m THEN

262 errorhandler pg(LITERAL(e),"Duplicate%introduction%of%an%object");

264 END ELSE266 BEGIN268 COMMENT this is the case where the name is not known

and hence the object must be declared;273 COMMENT check that the static function nesting

depth is not >0 as declarations are not allowed if this is the case;

277 IF func nest depth ig > 0 THEN278 errorhandler pg(LITERAL(e),

"Names%cannot%be%introduced%in%a%nested%funetion%definition");


281 COMMENT if this is not an introduction (ie USE ...) warnthe man that we are introducing an object;

285 IF in intro bg=false m THEN286 errorhandler pg(LITERAL(w),

"introduction%of%an%object%assumed");298 obj size m[max obj table mark ig];=default obj size m;

(fill in object size)300 obj str mark m[max obj table mark ig] := hash il;

(and the place where the name will be kept as an index into the object string table. Use the next free object table slot)

306 COMMENT now put the name of the object into the string table;309 FOR kl:=0,kl+l WHILE kl<=element dl[0] DO310 object string dl[hash il+kl]:=element dl[kl];312 COMMENT and now link back into the object table - into

3 bytes with the most significant first;316 inc m(hash il,element dl[0]+l);317 object string dg[hash il ]:=byte 2 m(max obj table mark ig);318 object string dg[hash il+l]:=byte 1 m(max obj table mark ig);319 object string dgfhash il+2]:=byte 0 m(max obj table mark ig);321 COMMENT plant code to declare the object ;323 program dg[prog mark ig] ;= rat declare m;324 program dgiprog mark ig+1] :=

byte 2 m(max obj table mark ig);325 program dg[prog mark ig+2] :=

byte 1 m(max obj table mark ig);326 program dg[prog mark ig+3] :=

byte 0 m(max obj table mark ig);327 inc m(prog mark ig,4);329 IF prog mark ig>prog size m THEN errorhandler pg(LITERAL(e),

"No%program%space%left");332 COMMENT now set up the return values - firstly 'element ig'

is set to the object table index of the object and 'element type ig' is set to 'ele operand m';

337 element ig := max obj table mark ig;338 element type ig := ele operand m;340 COMMENT and finally.... tidy up by :

incrementing 'max obj table mark ig' checking for overflow of the object, and object string tables;

344 inc m(max obj table mark ig,2);346 IF max obj table mark ig>obj table size m OR347 hash il+2>obj str size m THEN348 errorhandler pg(LITERAL(e),"Too%many%names%introduced");349 END;

10


350 END;352 return 11:353 END fetch element pg;

11


The high level language, however ill defined, can be used effectively in the transfer of software between machineenvironments provided the language support system used isvery similar on each machine. Less effort will be required if there are less differences between the support systems of the different machines. The problem of portability is then tansferred from the software item to the translation orinterpretation system. This is discussed further in section 2.3.The use of a high level language, rather than not using one, greatly improves the chances of being able to transport thesoftware from one computer to another. The large number of high level languages and the lack of rigour in the definition of some languages detracts from the ability to transport programs. The situation is becoming better with the standardisation of many languages, eg COBOL, Fortran 77, UCSD Pascal and latterly with Ada and the introduction of formal methods for defining languages.In the past only the language syntax was specified rigorously using BNF type constructions. The semantics were defined more loosly either in English, or by example. In addition many languages omitted program segmentation, concurrent process communication and input/output. This leads to a family of languages, each similar but with sufficient differences to make program transportability difficult.The problems associated with a language definition will be explored with reference to the CORAL 66 language which is a Mod standard language (Reference 4).

- Program segmentation is loosly defined by the COMMON, EXTERNAL and ABSOLUTE communicators. Objects which are introduced in a COMMON communicator may be used in the program segment being compiled with, or without, being declared in that segment.EXTERNAL communicators are similar to COMMON communicators except that the items being declared need not be declared in any of the CORAL 66 program segments but may be linked from a subroutine library.ABSOLUTE communicators are intended to allow access to absolutely addressed primitive facilities or machine locations of the "underlying machine" of the program being run.It is this area of a CORAL 66 program which is particularly loosly defined and implemented in a variety of ways. Most implementations of CORAL 66 require that the introduction of a CORAL 66 place specification, ie a procedure, label or switch, in a COMMON communicator be mirrored by a declaration of the object in the outer block of one program segment. The same is not true for CORAL 66 data

12

bUFTWAKE FUKTABlLilTY

objects, ie integers, fixed decimal, arrays and tables, where the language definition is ambiguous. In most implementations it is required that the data objects be declared in the COMMON communicator only and not in any outer program segment.The language definition does not define that the COMMON communicator should be identical in each program segment compiled. In some compilers it is essential that this is the case as space for objects is allocated sequentially, relying upon the relative position within a common area for object addresses. In other compilers only COMMON data object introductions need to be identical in each program segment as place specifications are addressed symbolically, ie by name. In other compilers the position of introductions within a COMMON communicator is not important as all addresses are treated symbolically and indeed it is not necessary for communicated objects which are not used in a program segment to be introduced in a COMMON communicator for that segment.The EXTERNAL communicator is intended to allow the programmer to access operating system routines or procedures which have been written in another language. External communicators suffer from many of the problems described above but in addition the character length of variables is restricted further due to external constraints. In some cases the external communicator is not implemented.The ABSOLUTE communicator is always machine dependent.

- The character string is partially defined in CORAL 66 and an assignment of the form :

s := "A character String";

assigns a locat The location ass mentations. Fo assigns a 2 word word is a pointe the second word 8080 version of string is the length of the characters).

ion to the integer mode (or type) variable, igned is often different in differing imple- r example the ICL George 3 implementation block to each character string. The first r to the starting byte of the string whilst is the length of the string. In the Intel the CORAL 66 compiler the location of the first byte of the string which contains the string (which is thereby restricted to 256

There are no string manipulation, constructs defined in CORAL 66.

eg substringing.

- The CORAL 66 language assumes implicitly word addressing, rather than byte. For example the declaration :

13

BUFTWARE R U R T A B IL IT I

INTEGER i,j,k;declares 3 integers with consecutive addresses such that indirect references [LOCATION(i)+l] references the variable j, and [LOCATION(i)+2] references k. Many implementationsintroduce the concept of BYTE but do not allow indirect references as shown above.

- Bit slicing of integers is permitted. If programs use these constructs, transfer of programs to a machine with a smaller word size can be difficult.

- Code inserts are permitted. The form of the code insert is left to the implementation.

- No input/output is defined and implementations define procedures to perform the functions. Procedures tend to be different for different implementations.

- No process communication or syncronisation facilities are provided for processes operating concurrently. Many programs resort to code inserts to access operating system facilities to provide these functions.

14

B U F T W A K E FUKlABlLilTX

2.2.2 Universal AssemblersThe use of a general assembler language which may be mapped, by suitable means, to any reasonable assembler language of a real machine has been used as a mechanism to achieve tranportability. The general features of this method are discussed in [Reference 3 : Brown (Editor)] whilst in the implementation of STAB-12 [Reference 10 : Colin 1975] the intermediate language (see sections 2.2.3 and 2.3.1) is a low level, assembler like, language. The assembler languages are generally of a low level and can often be interpreted by using a macroprocessor (see section 2.3.2). The low level means that the effort required to provide an interpretation system on a new computer may be significantly less than the effort required to ether rewrite the program for the new machine, or provide a compiler to support a high level language. The disadvantage is that the effort required to produce the program initially may be high. In addition the low level nature of assembler languages and lack of structure may mean that the programs are difficult to understand and modify subsequently.2.2.3 Abstract MachinesAn abstract machine is one defined with an architecture which reflects that of a number of real machines. Abstract machine basic features are discussed in [Reference 3 : Brown (Editor)], and [Reference 5 ; Warren 1976]. The BCPL compiler implementation [Reference 6 ; Richards 1971] utilises a simple stack based abstract machine, as does the Mobile programming system [Reference 7 : Coleman, Pool & Waite 1974]. Most portable compiler systems incorporate an abstract machine architecture within the compilation system. This is discussed further in section 2.3.1.Some abstract machines [Reference 13 : Poole 1971] are multi-level with one level defined upon the level beneath.There are various types of abstract machines defined:

For example -- A simple 2-register machine where the registers are used to store values of operands. Operations are defined on these operands, eg COMPARE, ADD, MULTIPLY,., etc.These machines require storage for data objects and operations to allow flow control both conditionally and unconditionally. In addition operations are required to allow data transfer between registers and storage.- An extension to the 2-register machine is one with an finite or infinite number of virtual registers.The variations on this theme depend upon the overall

15

s u F T W A K E F U K T A B I E I T Y

architecture of the abstract machine, eg all operationscould act upon the contents of the virtual registers,including flow control operations. If this were the case the virtual registers would contain references to both data and program storage.Conversely the virtual registers could be used in exactly the same way as the 2-register machine uses its registers. In this case the operations required would be similar to those of the 2-register machine except that they would need to reference source and sink virtual registers for theoperation.- A tree structured machine where the structure of theprogram is represented by a linked structure. The procedure call

output(channel,time*100+offset) may be represented by the tree :

CALL / \/ \/ PARAMETER

output I \I \I PARAMETER

channel | \I \+ NIL

/ \/ \* offset

/ \/ \ time 100

The tree structure shown here is just one method of portraying the procedure call and has omitted operandidentification nodes, eg a LITERAL node to show that thenumber "100" is a literal, or an OPERAND node to show that "time" is an operand.This kind of abstract machine is interpreted by traversing the tree in an ordered manner.- A simple finite state machine where the current state of the machine and the value of an input determines the next state, and any output.This can be extended to include a stack. In this case the state that the machine takes is dependent upon the currentstate, the value of the item on the stack and the value ofan input.

16

0\JE x v v n x M J j T V / £ \ x r ^ j - 9 x j - i J . X X

Abstract machines can be used as vehicles for transporting programs. They may be modelled as in [Reference 20 : Newey,Poole and Waite 1972] but usually the transportation of programs requires the realisation of the abstract machine in the new environment. This can be by :

- Providing a simulator for the abstract machine in the new environment, a technique used in the first stage transportation of BCPL compilers [Reference 6 : Richards 1971] and in language interpretation systems for LISP [Reference 25 : Taylor 1977] and Pascal [Reference 29 :Ammann 1977].

- Translating the "object code" of the abstract machine into the object code of the new environment. This would allow the program to run directly in the new environment. This is the favoured method for implementing efficiently compilers on new machines as in [Reference 8 : Capon, Wilson, Morris and Rohl 1972] and [Reference 27 : Wilcox 1971].

Abstract machines, as a method of achieving program portability, are often used in conjunction with a compiler and this will be discussed further in section 2.3.1.

17


2.3 ToolsThis section looks at software tools which provide for program transportability.2.3.1 CompilersThe name compiler is given to a program which will translate from a high level language into an object code which can be directly executed on a target machine.So if a program is written in a high level language and a compiler is available for that high level language on all required machines then the program is portable to all of those machines (subject to the constraints described in section 2.2.1).It is desirable, therefore, to make the compilers themselves portable. Techniques for making portable compilers, and using compiler-compilers, or syntax generators, are well documented.The most popular technique is the use of a 2-stage compilation process. Such a method is used in implementing compilers for BCPL [Reference 6 : Richards 1971], C [Reference 9 : Snyder 1975], Pascal [Reference 29 : Ammann 1977] and CORAL 66 [Reference 4]. The first stage is the lexical and syntactic parsing, and syntax/semantic checking to the rules applied by the language definition. The output from this stage is an intermediate language representation which is logically identical to the original program .The intermediate representation is often the object code of an abstract machine which is defined to fit the language being implemented. There have been attempts to make the abstract machine universal, ie applicable to all languages and all real machines. None have been truly successful. This is often termed the Uncol problem as the intermediate language, Uncol, was aimed at being universal. Uncol was defined by Steel in 1961 [Reference 22 : Steel 1961]. The problem to be solved is described in terms of 'n' languages requiring implementation on 'm' target machines. If a 2-stage compilation proceed is used then 'n*m' phases would need to be implemented to provide all languages on all machines. If any code generating phase for any specific target machine can be used with all source languages then only 'n+m' phases would need to be implemented. The major problem of this approach is that the interediate language needs to cater for the requirements of all (or at least a wide range) oflanguages and map onto the real machine architectures of targetmachines. In addition the intermedate language would need to beflexible enough to take advantages of the evolution of future languages and future machine architectures. These problems are described in [References 12 and 24 : Koster 1974].The second stage of the compilation process involves the translation of the intermediate representation into the object

18

B U F T W A K E BUKTAtJ 1 El T Y

code of a real machine, the target machine.To transport a program it is necessary to have a second stagecapable of translating the intermediate representation of the program to the desired target machine.The machine on which the compiler executes is the host machine, to avoid confusion with the target machine which was defined above. It is not necessary for the host and target machines to be the same. If the compiler generates object code for a machinewhich is not the host it is called a cross compiler.A cross compiler which is, itself, written in its source language, ie the language that the compiler translates, can be made to operate on its target machine (and thereby ceasing to be a cross compiler) by exploiting a process known as bootstrapping. Bootstrapping methods, with respect to the SNOBOL 4 language, are discussed in [Reference 21 : Dunn 1973].The sequence of events is :

- the source code of the compiler is input to the operating compiler on the host machine.This generates, firstly, an intermediate representation and then the target object code representation.- the target object code is transferred to the target machine and the code run. The target machine then becomes the host machine for the compiler which will generate object code for the new host machine.

2.3.2 MacroprocessorsThe macroprocessor has been used as a successful tool in program transportability. Macroprocessor basics are discussed in [Reference 3 : Brown (Editor)] and examples of their use appear in [Reference 13 : Poole 1971].A macroprocessor is a general purpose tool which performs text processing and parameter substitution functions. It relies upon 2 stages, namely macro definition and macro expansion.For example a macro definition may be :

MACRO slanguage-constructCASE slanguage-construct IS

call: {LINE proc&l) goto: {LINE goto LINE&l]

END-CASE END-MACRO;

In the above example variables used in the microprocessing stage

19

Bur rwAKE runx/iDJLEX’j. X

are preceded by the character and "&1" is used to denoteactual parameter 1 to the macro expansion. Microprocessor keywords are shown in capital letters.The example is of a fictitious microprocessor input language and is provided for example only. The microprocessor recognises the example as a macro definition. The macro is given the name "&language-construct" which, in this example, can be either "call" or "goto". The action taken, on expansion of the macro, will be dependent upon which of these names is used.The microprocessor will use the above definition in macroexpansions, so :

call input ; goto exit-label;

Will be expanded into :10 procinput 20 goto 750

To translate source code which is in one language into another language it is necessary to define macros for the source language which, when expanded, will generate the target language. This method can be used to transport programs from one machine to another where the same high level language is not available on the host and target machine. The program is translated by the microprocessor, using macro definitions produced specifically to enable the transportation, from the high level language of the host to that of the target.Where the two languages are significantly different it is possible to perform staged translation. This involves generating an intermediate representation which is further processed to generate either a further intermediate version (and again and again if necessary), or the final target code.The macroprocessor is a very flexible portability tool. Its value depends upon the richness of the macro definition language and its speed of execution.

2.3.3 Interpreters and EmulatorsAn interpreter is a program which executes the instructions of an abstract machine, whilst the emulator executes the instructions of either a real machine or an abstract machine. Interpretation is a common method of implementing compilation systems quickly.The interpreter executes the instructiions of the intermediate language. Such techniques are used in implementing portable compilation systems for BCPL [Reference 6 : Richards 1971],Mobile programming system [Reference 7 : Coleman, Poole, Waite 1974], C [Reference 9 : Snyder 1975], STAB-12 [Reference 10 :

20

OKJC ± wnx\ci r\j£\ x n w x jjx x x

Colin 1975], L-Star [Reference 23], Lisp [Reference 25 : Taylor 1977].A program running on a machine relies, for its operation, uponsomething executing the instructions which make up the logic ofthe program. The possibilities are ;

- The program is in the executable code of the host machine and the code is interpreted by the hardware of the hostmachine. It may be that the executable code is generatedas a result of compilation.- The program is in some intermediate form, eg the code of an abstract machine, and this is being interpreted by a program called an interpreter. The language BASIC often operates in this manner as does the PASCAL P-code compiler.

Transportation of the program can be accomplished, respectively, by :

- Implementing on the target machine an emulator which provides, in software, the ability to execute the code of the host machine.- Implement the abstract machine interpreter on the target machine.

In practice the implementation of an abstract machine interpreter is much simpler than implementing the instructions of a real (and sometimes alien) machine and it can be simpler than implementing a compiler for the target machine.Interpretation can be used to aid program transportability either as a primary aid or in conjunction with a compiler and abstract machine interface. Interpreters may be slow in execution.

2.3.4 Total Envi ronmentOne method of ensuring that a program is completely portable is to implement it in an environment which provides all of the facilities that the program needs and bar access to facilities which are provided outside of the environment.To port the program to another identical environment should pose no problems.The problem with this approach is that the environment itself needs to be portable. To overcome this the environment is built from a small kernel of facilities, say f1. f1 facilities are produced using the host machine facilities, eg PASCAL and Operating System calls. This kernel will need rewriting if the environment is moved to another machine.

21

sutTWARE rURlADXEXXX

The environment is enhanced, say to f2 facilities using fl facilities alone.Again the environment is enhanced, to f3 facilities, but this time using fl+f2 facilities, ... and so on.Each level of facility increase relies upon the facility level below.It is clear that the initial kernel must be both small for minimum rewrite on porting but be large enough to provide for f2+ facilities without their recourse to using host operating system facilities.

22

o u r x w x iR iL r u J M r t D .

3 AN INTERMEDIATE LANGUAGEThis section of the report describes an intermediate language designed for a High Level Language Compiler. The intermediate language could be used as the interface between a compiler and :

- a number of code generators which would provide the ability to translate a high level language into the code of a range of computers.- an optimiser which would act upon the intermediate code and transform it such that the code generator would generate more optimal code, minimising either the run time of the program, or the memory utilisation.- an interpreter to permit the execution of the intermediate code. The interpreter would act upon the intermediate code and obey the instructions of the code giving the effect of the program executing.

The intermediate language, which for ease of reference is called Ivor in this document, is the code of an abstract machine. The abstract machine and the Ivor language will be described in this section.The reason for designing Ivor was to assess the difficulty of mapping modern programming structures into some intermediate form and to assess the likely problems of generating code for a range of target machines.The design of Ivor was heavily influenced by the Chill and Ada programming languages. Intermediate languages like 0—code for BCPL, P-code for PASCAL and Janus did not address the problems associated with program segmentation and of programs operating concurrently.All practical compilation systems require programs to be separated into manageable units, compiled separately and linked to form executable program object code. In order to cater for this a compiler needs knowledge about items used within a program segment but which are extenal to it. No intermediate language which was investigated during this research period provided for program segmentation and separate compilation.In addition to this, many compilers implement a particular storage strategy and this is mapped, implicitly, into the intermediate language structure. For example, a Fortran COMMON approach is often adopted for external data. Data is addressed via an offset from some data area and is positionally dependent within the COMMON area. Any modifications to a program's external data would inevitably mean the recompilation of all program segments. Data within procedures are often declared with reference to a stack, or stacks. Both of the storage allocation strategies are inherent in the design of the intermediate language

23

û u r IW A R J d i r U R X A J D X l j X i X

Concurrent processing primitives were a recent innovation at the time of the research study and as a consequence did not feature in any of the intermediate languages considered. Concurrent processing facilities of the high level languages were developing also and, as a result, it was not possible to adopt a single strategy for handling concurrency. Two were chosen, the signal and buffer (as in Chill) but a third type, the Event, would probably be needed in order to cater for Ada.In addition to the primary objectives stated above, secondary design objectives were based upon:

- The lack of optimisation capabilities in intermediate languages. For example A:=A+B can generate intermediate code of the form :

STACK A STACK B ADDSTORE A

A non-intelligent code generator will not appreciate that the variable 'A' appears on both sides of the assignment until too late. A better approach would be to give the code generator the maximum amount of information in a single operation, ie

add B to A result_in AAlso, labels are often generated duri language production. Optimisation of code very difficult as execution can be transfer the label from an unknown program state, using Graph Theory ( as described by Wilson can be used, but the algorithms are compl considerable processing time. A way of avoi is to mark some labels as special, having a places from which execution can be transfer analysis for this case is much simpler.

ng intermediate across labels is red directly to Path analysis, in reference 40) ex and require ding the problem small number of red. The state

- The lack of source related information to allow symbolic debugging at interpretation or final execution stage is apparent in the intermediate languages considered. It was thought desirable to preserve source names and modes in Ivor to facilitate high level debugging. Ivor did not go far enough in this. Source line, and probably source column, references would have been necessary to allow sensible symbolic debugging.

The conclusion reached from performing this design exercise is that the higher the number of basic concepts (or operations) in an intermediate language the more difficult is the task of generating code, though the task of implementing each construct may be simpler if the intermediate language has simple operations

24


defined.The design described here uses :

- Simple linear operations- Stacks and stack operations- Flow control constructions- Process syncronisation constructions

25


3.1 Ivor Abstract Machine

I Ivor I I Definition |I Definition j -------- >| Interpreter jI Stream j + - - - - - - - - - - - - - ++ +

V4---------hI Free |I Space I+ +

V+ - -------- +I Data II Table I-I--------H

+------------ +I Ivor II Constant j -I Stream |H-----------h

- + IV V

4 — ——------+> I Instruction |I Interpreter |<— +------ +

H—I Operand |

— > I Stack I4----------h

4------------hI Ivor II Operation |-I Stream j4------------h

4----------h> I Address |I Stack IH------ H

The Ivor abstract machine has the components shown above. To cater for program segmentation the Ivor program is divided into units. Units are sub-divided into streams. These are the Definition, Constant and Operation streams.The definition stream introduces objects (more on these later) and each object has an identification key. Objects are, for example simple integers, arrays ..etc.The constant stream introduces constant expressions, for example (3+7/16) which need to be evaluated. The constant stream is needed if the Ivor interface is to be used by a code generator which is generating code for, say, a different word length machine than that hosting the compiler. If it is necessary to evaluate the constant expressions in the target machine environment then this can be done.The operation stream is the code of the abstract machine which governs execution, data manipulation and concurrent processing.

26


The abstract machine has 4 separate data areas: Free Space, the Data Table, the Operand Stack and the Address Stack.Free space, and the 2 stacks are used to hold the values of objects whilst the data table holds information about objects.To ensure that the structure of Ivor is free from some storage allocation strategy the structure of free space is leftundefined, except that free space is not directly addressable andmust be addressed through the address stack, in the case of a calculated address, or the data table for an introduced object. The mode of any object held in free space is an integral part of its address.The 2 stacks are used for holding, temporarily, the results of evaluated expressions either in address calculation, in which case the address stack is used, or in other expressions, in whichcase the operand stack is used.The data table is used to hold information about objectsintroduced, including the objects free space address and its structure (more on this later). All objects are identified by akey, the identification key, which is used to index the datatable.The operation of the abstract machine is :

- The instruction interpreter selects the first Ivor unitfor reading and starts with the constant stream.- The constant stream of that unit is read and processed, operation by operation, by the instruction interpreter.The processing causes the evaluation of each constant expression placing the result in the data table.Future reference to the constant expression, ie in thedefinition or instruction stream, is by an identification key which indexes the data table.- The definition interpreter reads and processes theIvor definition stream. In doing this the definitioninterpreter reserves the right amount of free space and puts a free space address in the data table of the object introduced. The data table record for each object is created from information provided in the definition stream.- The operation stream is then read and each operationexecuted. Generally the Ivor instructions are executed sequentially. However some instructions provide for the execution of particular parts of the Ivor program, eg by branching to a procedure call. The valid operations will be described later.

27


The description of Ivor which follows will use the abstract machine to describe the operation of Ivor's functions. The description will cover :

- Program segmentation- The definition stream- The operation stream- The constant stream

Ivor will be described using a modified Backus-Naur form of syntax description method. The semantics are described informally in English.Syntactic categories are referenced by one or more words enclosed between angle brackets (ie <.... >) and is termed a nonterminal symbol. The non-terminal symbol may contain comments, for explanatory purposes, in which case the comment is underlined, eg <procedure operand>. The comments do not form part of the syntax description and in the above example the nonterminal symbol, <operand> is exactly equivalent to <procedure operand>.Grouping of syntactic elements is by the use of braces (ie {....}). The group may be repeated by specifying an upper and a lower bound immediately following the braces, eg {<procedure operand>}l:10 indicates that the non-terminal symbol must appear once, and may be repeated upto 10 times. An indefinite upper limit is shown by an asterix (*) as the upper bound. The special case of a symbol being optional, eg {<procedure operand>}0 :1, may be represented using square brackets, eg [<procedure operand>].Terminal symbols are shown, where appropriate, in capital letters. Although the intermediate language is shown with terminal symbols represented by English words it is expected that the language will be compactly coded and not directly human readable.Other meta language constructs are as the standard Backus-Naur and are described only briefly here.

I Denotes an alternative.: Means "defines".

3.2 Program Segmentation Definitions

<program> : ; =IVOR <system name> { UNIT <unit data>

28


<definition stream> <constant stream><operation stream> ENDUNIT}0;*

<system name> ::=(character string>

(unit data> : : =(module name> {(seized data>}0:*

(module name> ::=(character string>

(seized data> ::=SEIZED (module name> (definitions> ENDSEIZED

(character string> ::=CHARSTRING (character> ENDCHARSTRING

(character> ::=CHARACTER (internal code of character number>

As has been said in the preceding section an Ivor program consists of one or more units, each of which comprises the 3 streams, definition, constant and operation. One of the requirements arising from the need for program segmentation is that each unit needs to be completely separate from others and needs to be self contained so that the Ivor abstract machine can take unambiguaous action for every operation.The unit is part of a system which is specified by a system name. The abstract machine will not permit the concurrent operation of units with dissimilar system names.Each unit is identified by a module name. The abstract machine requires each unit of a system to have a unique module name.In order to satisfy the requirements of separate compilation, where a unit uses objects which are introduced in a different unit, eg a procedure is called in module "A" which is defined in module "B", it is required that the object be introduced as a "seized" object in the module using (but not defining) it. In the module in which the object is introduced it is required that the object be granted wider access, see section 3.3.A seized object is introduced in exactly the same manner as one which is introduced in the definition stream, except that it may not be marked as "granted". To allow a compiler to provide simply the information required seized objects are grouped so that all of the objects seized from a particular unit appear in the same seized data group in the unit. The name of the unit from which the objects are seized is given by the module name of the seized data. For example :

29


- A unit seizes objects "A","B" and "C" from a unit withmodule name "M" and object "X" and "Y" from a unit withmodule name "N".- The unit which seizes "A","B","C","X" and "Y" will contain 2 seized data entries. The first will specify module "M" and introduce the objects "A","B" and "C" whilst the secondwill specify module "N" and introduce object "X" and "Y".

The seized data may contain introductions of objects which are not used in the unit in addition to those which are. It is notrequired that each unit of a system have identical seized dataand introductions may be in any order in each unit. Seized data is not like Fortran "common" data in that ordering is notimportant. The abstract machine will link between units symbolically, using the module name and the object'sidentification key.3.3 Definition streamDefinitions :

(definition stream> ::=DEFINITIONS (definitions> ENDDEFINITIONS

(definitions> ::={ABSTRACTION (abstraction data> (declarations> ENDABSTRACTION}0 : *

(abstraction data> ;;=(visibility> (nesting> (abstraction descriptor> (new key>

(abstraction descriptor> ;:=PROCEDURE (procedure data>I INNERPROCESS | OUTERPROCESS

(procedure data> ::={INLINE I GENERAL | SIMPLE) { RECURSIVE | NONRECURSIVE} {CRITICAL I NONCRITICAL)

(visibility> ::=GRANTED | BUILTIN | VISIBLE

(nesting> ::=(life time defining key> (visibility defining key>

(new key> ::=(character string> (key>

(key> ;:=KEY (number>

The definition stream introduces Ivor identification keys which

30


represent objects used later in Ivor operations. An object does not exist in isolation but exists only when an abstraction is activated. The object is said to be tied to that abtraction.Ivor abstractions are procedures and processes with a special type of process, the outer process, for which an instance is always active when the system is active.Processes can operate concurrently whilst procedures cannot.Many instances of the same process can be active at the same time. The abstractions are invoked, or activated, by Ivor operations in the operation stream. Both procedures and processes may have parameters, or return results as mechanisms for passing arguments between invoking and invoked environments. The parameters and results are defined in the <declarations> immediately following the abstraction introduction.Both Ada and Chill allow operations on procedure mode objects, eg

p ;= proc_name;

p( ) ;Indirect calling of procedures in this way causes inefficiencies in the run-time code, especially if all procedures are candidates for indirect calls, even though some may never be called in thatmanner. In Ivor procedures can be called indirectly only if they areintroduced with appropriate attributes, see below.To allow a compiler to indicate that some procedures can beoptimised (though they need not be if the code generator isnon-intelligent) special attributes are provided. Misuse of these attributes by a compiler is likely to cause incorrect code to be produced.

INLINE - The procedure code will be expanded in-line at the point of call.

GENERAL- The procedure may be used in an assignmentoperation and may be invoked indirectly.

SIMPLE - The procedure may not be used in an assignmentoperation.

RECURSIVE The procedure may invoke itself either directly,through another procedure or indirectly.

NONRECURSIVEThe procedure may not invoke itself in any way.

CRITICAL The procedure may be invoked only when no other

31


procedure contained in a particular bracketed area of the operation stream, termed a critical region, is active.

NONCRITICALA normal, non-critical procedure.

So that many storage allocation strategies are possible, abstractions must not be nested in the Ivor definition stream._ The static nesting characteristics are given by specific nesting attributes.In addition, an object has a lifetime and a visibility. The lifetime of an object is the period during which storage must be allocated to the object. An object starts its life when its tied abstraction is activated. Global objects are tied to the outer process. An object can be living but not visible and visibility is separately definable. This would cater for nested declarations of the form :

BEGINDECLARE X INTEGER;

BEGINDECLARE X BOOLEAN; — Outer x is not visible ... — but it is aliveEND ;

END;For example :The four abstractions pl,p2,p3 and p4 are defined informally as follows :

pi is the outer process.p2 is an inner process which is tied to pi.p3 is a procedure which is tied to pi but is visible only when p2 is active.p4 is a process which is tied to p2 and is visible whenever pi is active.

The Ivor intermediate language caters for these cases by providing for a lifetime defining key and visibility defining key to be specified as the nesting attribute.The key specifies either a tied abstraction, in the case of a lifetime defining key, or a bracket or abstraction name, for a visibility defining key.

32


3.4 Declarations Definitions :

<declarations> ::={<introduction>}0:*

<introduction> ::=(object introduction>I(mode introduction>I(synonym introduction>I(notion introduction>

Ivor declarations are used to introduce objects, modes, synonyms and notions which are described further in the following sections.

ALL identification keys used within the operation or constant streams must be introduced. The only exception to this is the temporary object of section 3.5.2.8.3.4.1 ObjectsDefinitions :

(object introduction> ;:=OBJECT [ (object introduction details> ]{(new object key>}l:* ENDOBJECT

(object introduction details> :;=(visibility> (nesting> (initialisation> (accessibility> (mode key>

(initialisation> ::=LIFEINIT I REACHINIT | NOTINIT

(accessibility> ::=DIRECT[ARGUMENT (abstraction key> (argument type>

(argument type> ::=IN I OUT I INOUT I LOG | RESULT

Ivor objects occupy free space and the definition interpreter reserves an appropriate amount of free space for the object and places a free space address for the object in the data table record which is referenced by the object's identification key.More than one object may occupy the same free space locations provided that their tied abstractions cannot be simultaneously active.

33


Objects may be initialised by operations in the operation stream. They may be initialised statically (ie once only when the outer process is activated) or may be initialised every time that an instance of the tied abstraction is activated. LIFEINIT is the former case whilst REACHINIT is the latter.Parameters to abstractions are introduced immediately following the ABSTRACTION introduction as objects. They are identified as having an accessibility attribute of ARGUMENT.The identification key of the abstraction is included as an attribute. The argument types supported by Ivor are :

IN The value of the actual parameter of theprocedure/process is copied to local storage at the procedure/process invocation. The local storage is used throughout theprocedure/process execution and the original actual parameter value is unchanged at the procedure/process exit.

INOUT Identical to the IN argument except that atprocedure/process exit the value of the parameter is copied to the location represented by the actual parameter.

OUT Identical to the INOUT except that the valueof the actual parameter will not be usedwithin the procedure/process.

LOG The actual parameter location will beaccessed for all read and write references to the parameter within the procedure/process.

RESULT The argument will be used to hold the result(eg in the case of a function call) of a procedure/process.

The structure of an object is given by its mode which specifies attributes such as whether the object is an array, or simple and whether it can be used to hold integers, strings, etc. Theabstract machine uses the mode information to determine how muchfree space is required and to determine the kinds of operations which are allowable on the objects. The mode information is obtained from a data table entry which is referenced by the mode identification key. Modes are described next.

3.4.2 Modes Definitions :

(mode introduction> ::=MODE [ (mode introduction details> ] (new mode key>

34


ENDMODE(mode introduction details> ::=

(visibility> (nesting> (capability> (mode construction>

(capability> ;:=R I W I RW

(mode construction> : ; =(basic mode>I REF (mode key>I BUFFER (mode key>

(buffer length constant>I (array mode>I (structure mode>

(basic mode> ::=BIT I FLAG I CHAR | LABEL | PTR |BIT I FLAG I CHAR | LABEL j PTR j PAIR I CASELABEL | RANGE (range> |PROC I INSTANCE

(range> ; ; =(lower bound constant>(upper bound constant>

(array mode> ;:=ARRAY (mode key> (range>

(structure mode> ::=STRUCTURE { (field> }!:* ENDSTRUCTURE

(field> : : =(mode key> (new field key>

(constant> ::=NUMBER (number>

(number> ::={ 0|1|2|3|4|5|6|7|8|9|A|B|C|D|E|F }4:8

The mode of an object defines the structure of the object and the range of operations which may be performed on the object.In addition it defines whether the object may be read from and/or written to.The capability attribute of the object specifies R for read only access, W for write only and RW for read/write access.The mode of an object is one of : basic, reference, buffer,array or structure.3.4.2.1 Basic Modes

35


Objects which are defined to be a basic mode are simple and canhold a value which is restricted to one valid for the basic mode.Basic modes are :

- BIT is a data item which can take the value TRUE or FALSE.- FLAG is a data item which can take the value FREE or BUSY.- CHAR can take the value of the internal code for anycharacter which can be displayed and printed.- LABEL is a reference to a point in the operation stream of the Ivor program.- PTR is a free space reference to any object.- PAIR is a pair of integers.- CASELABEL is a reference to a point in the operationstream of an Ivor program which can be entered only by a CASE operation.- RANGE is an integer which can take a value which is >= the lower bound specified and <= the upper bound.- PROC is a reference to a point in the operation stream of an Ivor program which represents the start of a GENERAL procedure.- INSTANCE is an identity given to a process when it is executing. A process may be started by one or more processstart operations and each instance of the process canexecute concurrently. Each instance of the process is given a unique process instance value by the Ivor abstract machine and this may be assigned to an object of mode INSTANCE.

3.4.2.2 Reference ModesA reference mode is a free space reference to an object which has the mode specified by the mode identification key.3.4.2.3 Buffer ModesA buffer mode object is used for communicating values between concurrent processes. The buffer has a mode specifed by the mode identification key and has a length specified by the constant.3. 4.2.4 Array ModesAn array mode is an ordered set of elements each of identical mode. The mode of each element is given by the mode identification key, which may, itself, be an array mode. The number of elements is given by the difference between an upper

36


and lower bound ( plus 1). An array element is referenced by an index value which must be >= the lower bound and <= the upper bound.3.4.2.5 Structure ModesA structure mode is a collection of elements, called fields, each of which may be a different mode. The field mode is given by the field mode identification key.

37


3.4.3 NotionsDefinitions :

(notion introduction> ::=NOTION (notion introduction details> (new key>

ENDNOTION(notion introduction details> ::=

(visibility> (nesting> (notion details>

(notion details> : : =LABEL { STRUCTURED | UNSTRUCTURED }I BRACKET (bracket type>I SIGNAL

(bracket type> ::={ STRUCTURED | UNSTRUCTURED }

{ CRITICAL 1 NONCRITICAL }Notion introductions introduce label, bracket and signal type identification keys.Label notions are used to mark points in the Ivor operation stream where flow is transferred to directly, rather than sequentially from the preceding operation. It is useful for a code generator to know which labels ( and brackets) are branched to from a few, rather than many, places. This makes the job of code optimisation simpler as the number of possible states available at the label are fewer. Labels with few branches are termed structured labels. Structured labels are usually generated as a result of some high level language loop, or conditional statement. An unstructured label may be branched to from many places, or may be assigned to a label mode object.A bracket notion is used to delimit a section of Ivor program which is to be entered at its head and where an exit from the bracket will transfer control to the operation following the bracket. Brackets cater also for concurrent operation of critical regions. If data which is shared between concurrently operating processes is to be accessed it is desirable to prevent concurrent (write) access to the data, this can be achieved by specific programming which ensures that data accesses occur only within a "critical region". If the bracket is marked as critical only one process instance may have control dynamically contained within the bracket at any time.Signal notions are used in the syncronisation between concurrently operating processes.3.5 Operation Stream

38


Definitions ;(operation stream> ::=

OPERATIONS { (sequential operation> |(non sequential operation> |(control operation> }0 : * ENDOPERATIONS

(operand> ::={ (identification key> | (stack operand> |(literal operand> } (operand descriptor>

(stack operand> ::={ OPERANDSTACK | ADDRESSSTACK } (mode key>

(literal operand> ::=(literal> (mode key>

(literal> : : =(constant> | (character> | (character string> |NULL I FREE | BUSY | TRUE | FALSE | UNDEF | NONE

(operand descriptor> ::=VALUE I CONSTANT

The operation stream introduces the operations which are to be executed by the Ivor instruction interpreter to provide the logic of the program. Operations are either sequential, non sequential or control operations. Sequential operations are interpeted one following the next. Non sequential operations transfer control to particular Ivor instructions within the operation stream.Operations usually have one or more operands. The operands provide the values and addresses used in the operations.An operand can be one referenced by an identification key, in which case the information about the object is obtained from the abstract machine data table. Alternatively the object may be a stack reference. If a stack reference is specified, either the address or operand stack, its mode is given by the mode key. The mode information is stored in the abstract machine data table record referenced by the identification key. An object may be a literal and can be any of the appropriate literal types.The operand descriptor gives the abstract machine information about how to use the operand, ie :

- If the operand descriptor is VALUE the operand is used as an address and the value of the operand obtained from it by indirection. For example suppose the operand is :

OPERANDSTACK VALUEThe value from the top of the stack is used as the operand, ie the operand OPERANDSTACK is used as the address of the

39


top of the stack and indirection used to obtain a value. Conversely, suppose the operand is :

KEY X VALUE

In this case the value is obtained from a free space address given in the data table record of the identification key x and allocated to x.The VALUE operand descriptor may not be used with literal operands.

- If the operand descriptor is CONSTANT no indirection is applied and the actual value or address is used. If the above examples are repeated with CONSTANT as an operand descriptor the address of the stack top, and free space address of the key x, respectively, will be used as operands.

The operations will be defined with respect to the abstract machine and the following notation is used within the description.

Firstly the syntactic definition is given, in exactly the same manner as described under th definition stream, above.Secondly a list of valid modes and notions are given for each operand. The list describes the combination of modes which are valid. Any other combinations are invalid and the abstract machine will generate an error condition if an invalid combination of modes or notions are provided.The description of modes and notions follow the following format: Firstly a "Modes" heading to indicate that the modesand notions are being described. This is followed by a heading indicating which part of the syntax description is being categorised, for example, suppose the syntax definition was

40


Definitions :(relational operation> ::=

{ GT 1 GE I LT I LE I EQ I NE } (result operand>(first source operand> (second source operand>

A Mode or notion section might be :

Modes :For (relational operation> is GTOrder is (first source operand> (second source operand>

(result operand>BITCHARRANGE

BITCHARRANGE

BITBITBIT

The meaning of this is is :- If the relational operation is the GT operation then the first operand may be a BIT mode in which case the second operand must be a BIT mode which will generate a BIT mode result operand, and so on for CHAR and RANGE mode first operands.- The "Order is .." part of the definition gives the order of the modes with respect to the syntax definition.For (relational operation> is GT | GE | LT | LE | EQ | NE Order is (first source operand> (second source operand>

(result operand>BIT BIT BITCHAR CHAR BITRANGE RANGE BITThe above defines the modes for all of the (relational operation> options and the following shorthand notation may be used when the mode definition applies to all options.

For (relational operation>Order is (first source operand> (second source operand>

(result operand>BIT BIT BITCHAR CHAR BITRANGE RANGE BIT

The actual functions performed by the Ivor operations are described with respect to a smaller number of pseudo operations of the abstract machine, egFunction

For (relational operation> is GT : if value((first source operand>) >

41


value((second source operand>) then (result operand> := TRUE else (result operand> := FALSE endif

The meaning of this is : If the relational operation is GT thenthe abstract machine executes the pseudo operations shown, in this case if .. then ... else .. endif and value pseudo operations. Pseudo operations are explained under a separate heading at their first occurance. In this way the operations of Ivor can be explained with reference to a smaller number of basic constructs.Where necessary, additional explanation will be given in order to relate the Ivor constructs to high level programming language features.3.5.1 Sequential OperationsDefinitions :

(sequential operation> ::=(relational operation> |(arithmetic operation> j (logical operation> |(numerical operation> |(complex mode accessing operation> |(assignment operation> |(result operation> |(syncronisation operation> |

Sequential operations cater for source language expressions, eg arithmetic and logical expressions and array and structure accessing. In addition Ivor operations are provided for the mapping of returned values from procedures and processes.Some bit manipulation operations are provided also.3.5.1.1 Relational operationRelational operations allow two operands to be compared, ie using (,>,(=,>=,/= and = operations, producing a boolean result.

Definitions :(relational operation> ::=

{ GT I GE I LT I LE I EQ I NE } (result operand>(first source operand> (second source operand>

Modes :For (relational operation> :Order is (first source operand> (second source operand>

(result operand>BIT BIT BITCHAR CHAR BIT

42


RANGE RANGE BITFunction ;

For (relational operation> is GTif value((first source operand>) >


For (relational operator> is GEif value((first source operand>) >=


For (relational operator> is LTif value((first source operand>) (

value((second source operand>) then (result operand> ;= TRUE else (result operand> := FALSE endif

For (relational operator> is LEif value((first source operand>) (=

value((second source operand>) then (result operand> := TRUE else (result operand> ;= FALSE endif

For (relational operator> is EQif value((first source operand>) =

value((second source operand>) then (result operand> ;= TRUE else (result operand> := FALSE endif

For (relational operator> is NEif value((first source operand>) /=


Pseudo operations :value The reference level of operands is specified

explicitly in Ivor operands, see start of section3.5. If B is an operand with VALUE specified as an operand descriptor then ( value(B) ) is the value of the operand obtained from the free space address of the operand. If B is an operand with CONSTANT specified then ( value(B) ) is the value

43


of the constant - which may be a free space address.

if The (if .. then ... else .. endif) operation andassociated relational operations have the usual interpretation, ie suppose A and B are operands then (if A>B then C else D endif) will cause C to be executed if (A>B) or D to be executed otherwise.

3.5.1.2 Arithmetic Operations

Arithmetic operations allow the common programming language operations of addition, subtraction, multiplication, division, modulo, absolute and remainder to be represented in Ivor. Also provided for are successor and predecessor functions. These are defined specifically for integer, character and boolean type operands.Definitions :

(arithmetic operation> ::=(monadic arithmetic operation> |(diadic arithmetic operation>

(monadic arithmetic operation> ::={ SUCC I PRED I MINUS | ABSOLUTE } (result operand> (source operand>

(diadic arithmetic operation> ::={ ADD I SUBTRACT | MULTIPLY | DIVIDE | MODULO |REM } (result operand> (first source operand>(second source operand>

Modes :For (monadic operation> is SUCC | PRED :Order is (first source operand> (second source operand>

(result operand>BIT BIT BITCHAR CHAR CHARRANGE RANGE RANGEFor (monadic operation> is MINUS | ABSOLUTE Order is (source operand> (result operand>RANGE RANGEFor (diadic operation>Order is (first source operand> (second source operand>

(result operand>RANGE RANGE RANGE

Function :For (monadic operation> is SUCC (result operand> := successor(

value((source operand>)

44


)

For (monadic operation> is PRED (result operand> := predecessor(

value((source operand>) )

For (monadic operation> is MINUS(result operand> := - value((source operand>)For (monadic operation> is ABSOLUTE if value((source operand>) ( 0 then (result operand> := - value((source operand>) (result operand> := value((source operand>)

else

For (diadic operation> is ADD(result operand> := value((first source operand>) +

value((second source operand>)

For (diadic operation> is SUBTRACT(result operand> := value((first source operand>) -


For (diadic operation> is MULTIPLY(result operand> := value((first source operand>) *


For (diadic operation> is DIVIDE(result operand> ;= (first source operand> /

(second source operand>

For (diadic operation> is MODULO(result operand> := value((first source operand>) //


For (diadic operation> is REM(result operand> ;= remainder (value((first source operand>

value((second source operand>))) /

Pseudo operations :successor If I is an integer then successor(I) is I+l.

If I+l is greater than the permitted range the abstract machine generates an error condition.If C is a character then successor(C) generates the next character in the ordered set of characters. If C is the last character in the set the abstract machine generates an error condition.If B is a bit then successor(B) generates true if B is false, or an error condition

otherwise.

45


predecessor If I is an integer then predecessor(I) is I-1. If l-l is less than the permitted range of I the abstract machine generates an error condition.If C is a character then predecessor(C ) generates the previous character in the

ordered set of characters. If C is the first character in the set the abstract machine generates an error condition. If B is a bit then predecessor(B ) generates false if B is true, or an error condition otherwise.This is arithmetic minus and may be used in modadic or diadic context. In monadic use the effect is identical to the case of diadic zero minus an operand.

+ This is arithmetic addition.* This is arithmetic multiplication./ This is arithmetic division.// This is the modulo operation which is defined

as follows. If I and J are integers then I//J delivers a unique integer value K, where 0<=K<J, such that there is an integer value N for which I=N*J+K is true.

remainder If I and J are integers then remainder(I/J)is the remainder after performing the arithmetic division.

3.5.1.3 Logical OperationsHighly typed languages like Chill and Ada do not permit integers and characters to be treated like bit strings. CORAL 66 does allow this feature. Bit logical operations, eg AND, OR, XOR, are permitted on bits and bit strings only. To cater for this Ivor provides AND, OR, XOR and NOT operations which can be applied to single boolean values or arrays of boolean values, representing bit strings.

Definitions :(logical operation> ::=

(monadic logical operation> |(diadic logical operation>

(monadic logical operation> ::=NOT (result operand> (source operand>

46


(diadic logical operation> ::={ AND I OR I XOR } (result operand>

(first source operand> (second source operand>

Modes :For (monadic logical operation>Order is (source operand> (result operand>BIT BITBIT-ARRAY BIT-ARRAYFor (diadic logical operation>Order is (first source operand> (second source operand>

(result operand>BIT BIT BITBIT-ARRAY BIT-ARRAY BIT-ARRAY Both of the source Operands and

the result operand must be ofexactly the same mode and structure.

Function :For (monadic logical operation> is NOT (result operand> := not(value((source operand>))For (diadic logical operation> is AND(result operand> := value((first source operand>) and


For (diadic logical operation> is OR (result operand> := value((first source operand>) or


For (diadic logical operation> is XOR(result operand> := value((first source operand>) exclusive-or


Pseudo operations :not If B is a bit then not(B) obeys the following

truth table :B not(B)0 11 0

If B is an array of bits the operation is performed on all elements of the array treating each element separately.

and If B and C are bits then (B and C) obeys thefollowing truth table :

B C (B and C)0 0 01 0 0

47


If B and c are arrays of bits the operation is performed on all elements of the array, taking each element in turn, ie

first(B) and first(C) followed by next(B) and next(C) until last(B) and last(C).

B and C must have the same number of elements otherwise the abstract machine will generate an error condition.

or This has identical semantics to the operation except that the truth table is

and

(B or0111

C)

exclusive-or This has identical semantics to the and operation except that the truth table is :

B C0 01 00 11 1

3.5.1.4 Numerical Operations

(B exclusive-or 0 1 1 0

C)

Definitions :(numerical operation> ::=

(monadic numerical operation> |(diadic numerical operation>

(monadic numerical operation> ::={ CARD I MAX I MIN | SIZE } (result operand> (source operand>

(diadic numerical operation> ::=INCLUDE (result operand> (first source operand> (second source operand>

ModesFor (monadic numerical operation> is CARD Order is (source operand> (result operand> BIT-ARRAY RANGEFor (monadic numerical operation> is SIZE Order is (source operand> (result operand> BIT RANGE

MAX MIN

48


RANGE RANGECHAR RANGEFLAG RANGEFor (diadic numerical operation> :Order is (first source operand> (second source operand>

(result operand>BIT-ARRAY BIT-ARRAY BIT Both source operands must have the

same number of elements.Function :

For (monadic numerical operation> is CARD (result operand> := card(

value((source operand>))

For (monadic numerical operation> is MAX (result operand> := maximum(


For (monadic numerical operation> is MIN (result operand> := minimum(


For (monadic numerical operation> is SIZE (result operand> := size (


For (diadic numerical operation> is INCLUDE (result operand> := value((first source operand>)

includes value((second source operand>)

Pseudo operations :card If B is a bit-array then card(B) is an

integer which is the sum of the number of elements of the bit-array which deliver a true value.

maximum If B is a bit-array then maximum(B) is aninteger which is the highest index into the array which delivers a true value.

minimum If B is a bit-array then minimum(B) is aninteger which is the lowest index into the array which delivers a true value.

size If A is an object of valid mode then size(A)is an integer which gives the number of bits used to hold A.

include If B and C are bit-arrays of identical

49


structure then (B includes C) delivers true if, and only if, for each element in C which contains true there is a corresponding true value in the first operand.

3.5.1.5 Complex Mode Accessing OperationsIn some of the early programming languages it was not possible to assign many values to array and structure elements without using some kind of looping construction.It is possible now to use features like :

a := [1..10:0,6,b,14..20:0]Which assigns 0 to elements 1 to 10 of array "a", 6 to element11, the value of "b" to element 12, element 13 is unchanged andelements 14 to 20 are assigned to 0.Ivor provides operations for creating values like those appearing on the right hand side of the assignment.In addition, operations are provided for manipulating arrays, eg by slicing a section from an array, or joining 2 arrays, tocreate a new array. in addition it is possible to createreferences to array elements and structure fields.

Definitions :<complex mode accessing operation> : : =

<monadic complex mode accessing operation> |<diadic complex mode accessing operation>

<monadic complex mode accessing operation> ::={ DEREF I TUPLE } <first operand>

<second operand><diadic complex mode accessing operation> ::=

{ JOIN I SLICE I RANGE | FOR | INDEX | SELECT |ATUPLE } <result operand><first source operand> <second source operand>

Modes :For <monadic complex mode accessing operation> is DEREF Order is <second operand> <first operand>REF-<basic mode> <basic mode>REF-<array mode> <array mode>REF-<structure mode> <structure mode>For <monadic complex mode accessing operation> is TUPLE Order is <second operand> <first operand><basic mode> <basic mode>-ARRAY Length of array depends

upon the number of TUPLE operations.

50


For <diadic complex mode accessing operation> is JOIN | SLICE Order is <first source operand> csecond source operand>

<result operand>BIT-ARRAY BIT-ARRAY BIT-ARRAYCHAR-ARRAY CHAR-ARRAY CHAR-ARRAYRANGE-ARRAY RANGE-ARRAY RANGE-ARRAYFor <diadic complex mode accessing operation> is RANGE | FOR Order is <first source operand> <second source operand>

<result operand>RANGE RANGE PAIRFor <diadic complex mode accessing operation> is INDEX Order is <first source operand> <second source operand>

<result operand>BIT-ARRAY RANGE REF-BITCHAR-ARRAY RANGE REF-CHARRANGE-ARRAY RANGE REF-RANGEFLAG-ARRAY RANGE REF-FLAGLABEL-ARRAY RANGE REF-LABELPTR-ARRAY RANGE REF-PTRPAIR-ARRAY RANGE REF-PAIRPROC-ARRAY RANGE REF-PROC<array mode>-ARRAY RANGE REF-<array mode>For <diadic complex mode accessing operation> is SELECT Order is <first source operand> <second source operand>

<result operand><structure <mode construction> REF-<modemode> construction>For <diadic complex mode accessing operation>Order is <first source operand> <second source

<result operand>BIT RANGE BIT-ARRAYCHAR RANGE CHAR-ARRAYRANGE RANGE RANGE-ARRAYFLAG RANGE FLAG-ARRAYLABEL RANGE LABEL-ARRAYPTR RANGE PTR-ARRAYPAIR RANGE PAIR-ARRAYPROC RANGE PROC-ARRAYBIT-ARRAY PAIR BIT-ARRAYCHAR-ARRAY PAIR CHAR-ARRAYRANGE-ARRAY PAIR RANGE-ARRAYFLAG-ARRAY PAIR FLAG-ARRAYLABEL-ARRAY PAIR LABEL-ARRAYPTR-ARRAY PAIR PTR-ARRAYPAIR-ARRAY PAIR PAIR-ARRAYPROC-ARRAY PAIR PROC-ARRAY

Function :For <monadic complex mode accessing operation> is DEREF <first operand> := value(

51


value(<second operand>))

For <monadic complex mode accessing operation> is TUPLE next (<first operand>) := value(<second operand>)For <diadic complex mode accessing operation> is JOIN <result operand> := value(<first source operand>) join

value(<second source operand>)For <diadic complex mode accessing operation> is SLICE <result operand> := value(<first source operand>) slice

value(<second source operand>)For <diadic complex mode accessing operation> is RANGE <result operand> := value(<first source operand>)

range value(<second source operand>)For <diadic complex mode accessing operation> is FOR <result operand> := value(<first source operand>)

for value(<second source operand>)For <diadic complex mode accessing operation> is INDEX <result operand> := <first source operand> I

value(<second source operand>)For <diadic complex mode accessing operation> is SELECT <result operand> := <first source operand> .

value(<second source operand>)For <diadic complex mode accessing operation> is ATUPLE <result operand> subarray value(<first source operand>) :=

value(<second source operand>)Pseudo operations

next If A is an array then next(A) references the highest array element location at which there is no value stored.

]Oin

slice

If A and B are arrays then (A join B) is annew array whose length is the sum of thelengths of A and B.If A is an array and X is a pair, say (3:4), then (A slice X) will generate an array oflength 2 which will be the elements of A atindices 3 and 4.

range

for

If I and J are integers then generates the pair (l:J).If I and J are integers then generates the pair (I:l+J).

(I range J

(I for J)

52


I If A is and array reference and X is aninteger then (A I X) is a reference to the Xth element of A.If S is a structure and F is a field of thestructure then (S . F) is a reference to thefield of the structure.

subarray If A is an array reference and X is aninteger or pair then (A subarray X)references one or more elements of A.

3.5.1.6 Assignment OperationDefinitions :

<assignment operation> ::={ ASSIGN I INITIALISE } Csink operand><source operand>

Modes :For <assignment operation>Order is <source operand> <sink operand><mode> <mode> Both operands must be of identical

mode.

Function :For <assignment operation> is ASSIGN <sink operand> := value(<source operand>)For <assignment operation> is INITIALISE <sink operand> <- value(<source operand>)

Pseudo operaton ;<- If A is a reference to an object and B is an

object of the same mode as that referenced then (A <- B) causes the value of B to be assigned to the location A once only when the abstract machine first encounters the operation. Thereafter the operation is ignored and causes no action.

3.5.1.7 Result OperationHigh level language functions can return a result which may be used in an expression, eg ;

X := fn()*3+b;It is necessary in Ivor to indicate at the Abstraction introduction (ie abstraction 'fn' in this case) that the abstraction will return a result. A special argument is introduced, the result argument.In the calling environment the result argument operand is used in

53


the expression using the procedure result. In the called environment a RESULT operation effectively assigns the value of the result to the result argument operand immediately prior to returning control to the calling environment.Definitions :

(result operation> :;=RESULT (procedure result operand>(result value operand>

Modes :For (result operation>Order is (result value operand> (procedure result operand> (mode> (mode> Both operands must be of identical

mode.Function :

For (result operation>(procedure result operand> := value((result value operand>)

3.5.1.8 Syncronisation OperationDefinitions :

(syncronisation operation> ::=SEND (buffer or signal operand>(receiving process operand> |RECEIVE (buffer operand>

Modes :For (syncronisation operation> is SENDOrder is (buffer or signal operand> (receiving process operand> BUFFER INSTANCESIGNAL INSTANCE Signal is a notion, not a mode, but

is included here for completeness.For (syncronisation operation> is RECEIVE BUFFER

Function :For (syncronisation operation> is SENDsend (buffer or signal operand> to (receiving processoperand>

For (syncronisation operation> is RECEIVE (buffer operand> := receive

Pseudo operations :send If S is a signal argument and P a process

instance value then (send S to P) causes the value of S to be sent to the process instance P.

If B is a buffer value and P a process

54


instance value then (send B to P) causes the value B to be sent to the process P.Execution continues with the next instruction immediately.

receive A concurrently operating process has an inputmessage queue in free space. The receive operation causes the abstract machine to fetch the message at the head of the queue and delete the message from the queue. The message is then available as a value to the abstract machine and may be assigned to a reference of identical mode.

If the queue is empty, the abstract machine will wait until a message is placed in the queue.

55


3.5.2 Non-Sequential OperationsHigh level programming languages have procedures, blocks, labels and processes to provide for modular or concurrent program construction, or simply to allow control transfer. The simple high level language statement :

proc(p);hides much of the environment creation and parameter passing necessary to implement the feature.Ivor's design aims at keeping the simplicity of the high level language statement by providing explicit environment activation operations.Procedures then become simple bracketed operations and a procedure call simply enters at the bracket head.Definitions :

<non-sequential operations> ::=(entry operation> |(exit operation> |(procedure entry operation> |(procedure exit operation> |(process start operation> |(process stop operation> |(case selection operation>

3.5.2.1 Entry OperationDefinitions :

(entry operation> ::=(conditional entry operation> |(unconditional entry operation>

(conditional entry operation>(boolean conditional entry operation> |(relational conditional entry operation> |(protected entry operation>

(boolean conditional entry operation> ::={ ENTERTRUE | ENTERFALSE } (source operand>(bracket or label identification key operand>

(relational conditional entry operation> :;={ ENTERGT | ENTERGE | ENTERLT | ENTERLE | ENTEREQ | ENTERNE } (first source operand> (second source operand>(bracket or label identification key operand>

(protected entry operation> ::={ ENTERFREE | ENTERBUSY } (source operand>(bracket or label identification key operand>

56


(unconditional entry operation> ::=ENTER (bracket or label identification key operand>

(identification key operand> : : =(identification key> (operand descriptor>

Modes :For (boolean conditional entry operation>Order is (source operand>

(bracket or label identification key operand>BIT LABELBIT BRACKETFor (relational conditional entry operation>Order is (first source operand> (second source operand>

(bracket or label identification key operand>BIT BIT LABELBIT BIT BRACKETCHAR CHAR LABELCHAR CHAR BRACKETRANGE RANGE LABELRANGE RANGE BRACKET

For (protected entry operation>Order is (source operand>

(bracket or label identification key operand>FLAG LABELFLAG BRACKETFor (unconditional entry operation>LABELBRACKET

Function :For (boolean conditional entry operation> is ENTERTRUE if value((source operand>) = TRUE then execute (bracket or label identification key operand>For (boolean conditional entry operation> is ENTERFALSE if value((source operand>) = FALSE then execute (bracket or label identification key operand>For (relational conditional entry operation> is ENTERGT if value((first source operand>) >

value((second source operand>) then execute (bracket or label identification key operand>For (relational conditional entry operation> is ENTERGE if value((first source operand>) >=

value((second source operand>) then execute (bracket or label identification key operand>For (relational conditional entry operation> is ENTERLT if value((first source operand>) (

57


value((second source operand>) then execute (bracket or label identification key operand>For (relational conditional entry operation> is ENTERLE if value((first source operand>) (=

value((second source operand>) then execute (bracket or label identification key operand>For (relational conditional entry operation> is ENTEREQ if value((first source operand>) =

valuei(second source operand>) then execute (bracket or label identification key operand>For (relational conditional entry operation> is ENTERNE if value((first source operand>) /=

value((second source operand>) then execute (bracket or label identification key operand>For (protected entry operation> is ENTERFREE if value((source operand>) = FREE then execute (bracket or label identification key operand>For (protected entry operation> is ENTERBUSY if value((source operand>) = BUSY then execute (bracket or label identification key operand>

Pseudo operations ;execute If X is a reference to a location within the

Ivor operation stream then (execute X) causes the Ivor instruction interpreter to execute the operation at location X and continue execution from there.

3.5.2.2 Exit OperationDefinitions :

(exit operation> ::=(conditional exit operation> |(unconditional exit operation>

(conditional exit operation> : : =(boolean conditional exit operation> |(relational conditional exit operation> |

(boolean conditional exit operation> ; : ={ EXITTRUE I EXITFALSE } (source operand>(bracket identification key operand>

(relational conditional exit operation> ::={ EXITGT I EXITGE | EXITLT | EXITLE | EXITEQ | EXITNE } (first source operand> (second source operand>(bracket identification key operand>

(unconditional exit operation> ;:=

58


EXIT (bracket identification key operand>

Modes :For (boolean conditional exit operation>Order is (source operand>

(bracket identification key operand>BIT BRACKETFor (relational conditional exit operation>Order is (first source operand> (second source operand>

(bracket identification key operand>BIT BIT BRACKETCHAR CHAR BRACKETRANGE RANGE BRACKETFor (unconditional exit operation>BRACKET

Function :For (boolean conditional exit operation> is EXITTRUE if value((source operand>) = TRUE then exit (bracket identification key operand>For (boolean conditional exit operation> is EXITFALSE if value((source operand>) = FALSE then exit (bracket identification key operand>For (relational conditional exit operation> is EXITGT if value((first source operand>) >

value((second source operand>) then exit (bracket identification key operand>For (relational conditional exit operation> if value((first source operand>) >=

value((second source operand>) then exit (bracket identification key operand>For (relational conditional exit operation> if value((first source operand>) (

is EXITGE

is EXITLT

exvalue((second source operand>) then it (bracket identification key operaand>

For (relational conditional exit operation> is EXITLE if value((first source operand>) (=

value((second source operand>) then exit (bracket identification key operand>For (relational conditional exit operation> is EXITEQ if value((first source operand>) =

value((second source operand>) then exit (bracket identification key operand>For (relational conditional exit operation> is EXITNE

59


if value((first source operand>) /= value((second source operand>) then

exit (bracket identification key operand>For (protected exit operation> is EXITFREE if value((source operand>) = FREE then exit (bracket identification key operand>For (protected exit operation> is EXITBUSY if value((source operand>) = BUSY then exit (bracket identification key operand>

Pseudo operations :exit If a section of Ivor operations is bracketed

by the bracket X (which has a start of bracket and an end of bracket) then exit causes the instruction interpreter to execute the operations following the closing bracket.

3.5.2.3 Procedure Entry OperationDefinitions :

(procedure entry operation> ::=ENTERPROC (procedure operand>

Modes :For (procedure entry operation>PROC

Function :For (procedure entry operation> execute value((procedure operand>) r :

Pseudo Operations: See section 3.5.3.2 - labelling

3.5.2.4 Procedure Exit OperationDefinitions :

(procedure exit operation> : : =EXITPROC (procedure identification key operand>

Modes :For (procedure exit operation>PROC

Functions :For (procedure exit operation>deactivate (procedure identification key operand> return (procedure identification key operand>

Pseudo operations :deactivate The deactivate operation does the reverse of

the activate operation in that it releases

60


the free space allocated to the procedure or process.

return The return operation causes the instructioninterpreter to execute the operation (in the operation stream) referenced by the return address planted at the preceding activate instruction.

3.5.2.5 Process Start Operation

Definitions :(process start operation> ::=

STARTPROCESS (process identification key operand> (instance identification key operand>

Modes :For (process start operation>Order is (process identification key operand>

(instance identification key operand>PROCESS INSTANCE

Functions :For (process start operation>(instance identification key operand> :=

start (process identification key operand>

Pseudo operations :start If P is a process and I is an instance object

then (I ;= start P) causes the instruction interpreter to execute P concurrently with the activating process. The activating process continues execution with the operation following the start operation.In addition a value is returned which is the identity of the instance of the process being executed. This can be assigned to an instance mode object.

3.5.2.6 Process Stop OperationDefinitions :

(process stop operation> ::=STOPPROCESS

Modes :None

Functions :For (process stop operation> stop

61


Pseudo operations :stop Causes the instruction interpreter to cease

execution of the process containing the stop operation. All free space allocated by the activate operation is released and execution ceases. Only the particular process instance is affected by the stop.

3.5.2.7 Case Selection OperationIvor caters for source languages having multi-dimensional case statements. Three types of case statements use the same Ivor accessing operations. The type depends upon the mode of the accessing operand.

The first type considers the case to be a 1 to n dimensional array of case labels (with holes, possibly). Control is transferred to the caselabel delivered by indexing the array with the case operands. The case label array is conceptual only as implementation in this manner would not prove feasible.The remaining types of case statements allow a message to be obtained from one or more message queues, depending upon the queue that contains the message, eg

CASE sl,s2,s3 ENDCASE;If only queue "s2" contains a message then the message will be received from "s2". If other queues contain messages then one message will be received though the abstract machine does not define the search order.Definitions :

(case selection operation> ::=CASE (case bracket identification key operand>(case label array identification key operand> (selection> ENDCASE

(selection> ::={ RANGE I BUFFER | SIGNAL }{ (case selector operand> }1:*

Modes :For (case selection operation> is CASE (case label

identification key operand> (case label array identification key operand> RANGE { (case selector operand> }1:*

Order is (case bracket identification key operand>(case label array identification key operand>(selection^

CASELABEL CASELABEL-ARRAY RANGEFor (case selection operation> is CASE (case label

identification key operand> (case label array

62


identification key operand> BUFFER { (case selector operand> }1:*

Order is (case bracket identification key operand>(case label array identification key operand>(selections

CASELABEL CASELABEL-ARRAY BUFFERFor (case selection operation> is CASE (case label

identification key operand> (case label array identification key operand> SIGNAL { (case selector operand> }!:*

Order is (case bracket identification key operand>(case label array identification key operand>(selections

CASELABEL CASELABEL-ARRAY SIGNAL

Functions ;For (case selection operation> is CASE (case label

identification key operand> (case label array identification key operand> RANGE (case selector operand>

execute value((case label array identification key operand> I value((case selector operand>)

For (case selection operation> is CASE (case label identification key operand> (case label array identification key operand> RANGE (case selector 1 operand> (case selector 2 operand>

execute value( ((case label array identification key operand> I value((case selector 1 operand>) ) I

value(case selector 2 operand>) )

.... and so on.For (case selection operation> is CASE (case label

identification key operand> (case label array identification key operand> BUFFER (case selector operand>

ostack := receive (case selector operand>For (case selection operation> is CASE (case label

identification key operand> (case label array identification key operand> BUFFER (case selector 1 operand> (case selector 2 operand>

if message (case selector 1 operand> thenostack := receive (case selector 1 operand>

orif message (case selector 2 operand> thenostack := receive (case selector 2 operand>

.... and so onFor (case selection operation> is CASE (case label

identification key operand> (case label array identification key operand> SIGNAL (case

63


selector operand> ostack := receive (case selector operand>For (case selection operation> is CASE (case label

identification key operand> (case label array identification key operand> SIGNAL (case selector 1 operand> (case selector 2 operand>

if message (case selector 1 operand> thenostack := receive (case selector 1 operand>

orif message (case selector 2 operand> thenostack := receive (case selector 2 operand>

Pseudo operations :orif B and Q are boolean and X is an integer.

(if B then X:=2 orif Q then X:=3) causes the value of B and the value of Q to be obtained concurrently. This will generate a deterministic result only if B and Q do not change their values during the time taken to evaluate the operation.The orif condition will be evaluatedconcurrently with the if condition inaddition to any other orif conditionals.

message If S is a signal or a buffer then (message S)is TRUE if a message is available for receipt

by the process from the signal or buffer.

3.5.3 Control OperationsDefinitions :

(control operations>(bracketing operation> |(labelling operation> |(environment set up operation> |(parameter handling operation> j (case association operation> |(procedure bracket> |(process bracket> |(temporary varaible allocation>

3.5.3.1 Bracketing OperationDefinitions :

(bracketing operation> ::=(open bracket> (operation list> (close bracket>

(open bracket> :;=BRACKET (bracket identification key operand>

(operation list> ::=

64


{ (sequential operation> |(non-sequential operation> |(control operation> }

(close bracket> ::=ENDBRACKET (bracket identification key operand>

Modes :For (open bracket>BRACKETFor (close bracket>BRACKET

Functions :For (bracketing operation>(bracket identification key operand>:

bracket{ (operation list> }

Pseudo operations :: The : identifies a point in the operation

stream to which control may be transferred.If L is a location within the operation stream then L: identifies the location.

bracket{ The braces {....} identify sections of theoperation stream which are bracketed. The identifier preceding the bracket defines the type of the bracket, in this case a simple bracket. Control may be transfered to the start of the bracket by an execute operation and control may be transfered to the end of the bracket by an exit operation. The execute operation may be executed from any point in the program but an exit operation may be executed only from within the bracket which is to be exited.

3.5.3.2 Labelling OperationDefinitions :

(labelling operation> ::=LABEL (label identification key operand>

Modes :For (labelling operation>LABEL

Functions :For (labelling operation>(label identification key operand> :

3.5.3.3 Environment Set Up Operation

65


Definitions :(environment set up operation> ::=

ACTIVATE (activation operation>

Modes :PROCPROCESS

Functions :For (environment set up operation> activate (activation operand>

Pseudo operations activate During the definition interpreter stage the

abstract machine assesses the free space requirements for an invocation of _ a procedure or process. The activate operation allocates the free space and, in the case of a procedure activation, stores within it the address that the instruction interpreter is to execute from (the return address) when it meets a return operation.

3.5.3.4 Parameter Handling Operation

Definitions :(parameter handling operation>

{ ARGUMENT | OUTARGUMENT } (actual parameter operand>

(formal parameter operand>

ModesFor (parameter handling operation> with (argument type> of

(formal parameter operand>=IN Order is (formal parameter operand>

(actual parameter operand>(basic mode> (basic mode>

REF-(basic mode> (array mode> (structure mode>

REF-(basic mode> (array mode> (structure mode>

All modes must be identical.All modes must be identical.All modes must be identical.All modes must be identical.

For (parameter handling operation> with (argument type> of (formal parameter operand>=INOUT

Order is (formal parameter operand>(actual parameter operand>

(structure mode> (basic mode>(structure mode> REF-(basic mode>(strucure mode> (array mode>(structure mode> (structure mode>

Note If the (actual parameter operand> is of a mode

66


represented by the identification key parameter operand> will be of mode

'm" then the (formal

STRUCTURE KEY m KEY fpl "fpl"KEY rm KEYfp2 "fp2"

ENDSTRUCTURE Where :fpl is the identification key of the first part of the formal parameter and represents its value.fp2 is the identification key of the second part of the formal parameter which represents the location of the actual parameter.rm is the mode of fp2 which is REF m.

For (parameter handling operation> with (argument type> of (formal parameter operand>=OUT or (formal parameter operand>=LOC or (formal parameter operand>=RESULT

Order is (formal parameter operand>(actual parameter operand>

REF-(basic mode> REF-REF-(basic mode> REF-(array mode> REF-(structure mode>

(basic mode> REF-(basic mode> (array mode> (structure mode>

Both (basic mode>sare identical.Both (basic mode>sare identical.Both (basic mode>sare identical.Both (basic mode>sare identical.

Functions ;For (parameter handling operation> with (argument type> of

(formal parameter operand>=IN (formal parameter operand> := value((actual parameter

operand>)For (parameter handling operation> is ARGUMENT

with (argument type> of (formal parameter operand>=INOUT (formal parameter operand> . fpl :=

value((actual parameter operand>)(formal parameter operand> . :=

(- (actual parameter operand>For (parameter handling operation> is OUTARGUMENT

with (argument type> of (formal parameter operand>=INOUT value((formal parameter operand> . fp2) :=

value((actual parameter operand>)For (parameter handling operation> is OUTARGUMENT

with (argument type> of (formal parameter operand>=OUT or

67


(formal parameter operand>=LOC or (formal parameter operand>=RESULT

value((formal parameter operand>) :=value((actual parameter operand>)

3.5.3.5 Case Association OperationIn section 3.5.2.7 the case statement was described as a one to "n" dimensional array of caselabels. The case association operation associates a particular caselabel with an element of the n-dimensional array. This could, conceivably, be performed using the assignment statement. In order to permit an efficient implementation, as the n-dimensional array is likely to have many elements without caselabels (ie holes), a special CASE BIND operation is provided.Definitions :

(case association operation> ::=BIND (case label identification key operand>(case array identification key operand>{ (case range pair> }1:* ENDBIND

(case range pair> :;=(lower bound operand> (upper bound operand>

ModesFor (case association operation>Order is (case label identification key operand>

(case array identification key operand> CASELABEL CASELABEL-ARRAYFor (case range pair>Order is (lower bound operand> (upper bound operand> RANGE RANGE

Functions :For (case association operation> isBIND (case label identification key operand>

(case array identification key operand>(case range pair> ENDBIND

(case array identification key operand> 1 (lower bound operand> to (upper bound operand> :=

(case label identification key operand>For (case association operation> is

BIND (case label identification key operand>(case array identification key operand>(case range 1 pair> (case range 2 pair> ENDBIND

(case array identification key operand> I(lower bound 1 operand> I(lower bound 2 operand> to (upper bound 2 operand> :=

(case label identification key operand>(case array identification key operand> I (lower bound 1 operand> +1 I

68


(lower bound 2 operand> to (upper bound 2 operand> :=(case label identification key operand>

.... and so on until the first index= (upper bound 1 operand>

... and this is repeated for 3,4,.... n (case range pair> operands.

Pseudo operations :to If A is an array then (A ! 1 to 3) represents

the 1st, 2nd and 3rd elements of A. The assignment (A! 1 to 3 :=5) assigns the value 5 to the first 3 elements of A.

3.5.2.6 Procedure BracketDefinitions :

(procedure bracket> : : =BEGINPROC (procedure identification key operand> (operation list>

ENDPROC (procedure identification key operand>

Functions :For (procedure bracket>(procedure identification key operand>:

procedure{ (operation list> }Pseudo operations :

procedure{ The braces {....} identify sections of theoperation stream which are bracketed. The "procedure" identifier preceding the bracket defines this type of bracket as a procedure bracket. Control may be transfered to the start of the bracket by an execute operation and control may be transfered to the end of the bracket by an exit operation. The execute operation may be executed from any point in the program but an exit operation may be executed only from within the bracket which is to be exited.

3.5.2.7 Process BracketDefinitions :

(process bracket> :;=BEGINPROCESS (process identification key operand> (operation list>ENDPROCESS (process identification key operand>

Functions ;For (process bracket>(process identification key operand> : process{ (operation list> }

69


Pseudo operations :process{ The braces identify sections of the

operation stream which are bracketed. The "process" identifier preceding the bracket defines this type of bracket as a process bracket. Control may be transfered to the start of the bracket by a start operation and control may be transfered to the end of the bracket by an exit operation.

3.5.2.8 Temporary Variable AllocationDefinitions ;

(temporary variable allocation> ::=ALLOCATE (temporary key> (mode key> |FREE (temporary key>

Functions :For (temporary variable allocation> is ALLOCATE allocate (temporary key> of (mode key>For (temporary variable allocation> is FREE free (temporary key>

Pseudo operations :allocate .. of If T is a temporary variable and M i s a mode

then (allocate T of M) will cause free space to be allocated within the current process or procedure. The free space address allocated will be attributed to T and placed in thedata table record of T. Free space allocatedin this way is not automatically freed at a deallocate or stop operation and the abstract machine will generate an error condition if temporary storage is not freed before exiting a procedure or process.

free If T is a temporary variable then (free T)causes the free space allocated to T to bereleased. The free operation in notpermitted on non-temporary variables.

70


3.6 Constant StreamDefinitions :

(constant stream> ::=CONSTANTS (constant operations> ENDCONSTANTS

(constant operations. ::={ (constant sequential operation> }0:*

The constant stream may contain any sequential operation provided:

- The operands are constants in that they can be fully evaluated by the instruction interpreter without it having to access any free space location. An assignment operation will retain the value of the evaluated constant in the data table record of the object being assigned - and not in the object's free space location.

71


3.7 Conclusions

No other intermediate language considered during this research period had incorporated concurrent processing features, nor did they relate the intermediate code back to the original source from which it was generated. Ivor addressed both of these areas and in addition did not tie the code generator to a particular storage allocation strategy.The conclusions are :3.7.1 The concurrent processing facilities would probably require an 'event' type operation where processing is suspended until an event occurs.

3.7.2 More source related information will be required in order to do effective high level debugging at the interpretation stage. Identification of source line and column numbers would be required.

3.7.3 Isolation of storage allocation parameters until code generation stage is viable and sucessfully accomplished in Ivor. The price for this is a more complex code generation phase.This could be replaced by two phases: storage allocation, followed by code generation.3.8 Example of Use

To illustrate the use of Ivor as an intermediate language the example of figure 2.2.1-1 (reproduced here as figure 3.8-1) will be translated into Ivor.

To simplify the description the following terminology has been adopted :

- Identification key numbers are shown as lower case names.- Character literals and character strings are shown as their character representation and are enclosed in double quotes, eg "A character string".

- Operand descriptors are omitted and CONSTANT is assumed. Where a VALUE descriptor is appropriate the operand is enclosed in square brackets, eg [KEY kl].- Operations start on a new line with the operator name occupying the first tabulation position. Operands occupy subsequent tabulation positions and continuation is shown by the first tabulation position being empty.- Comments start with the characters "— ".

In addition declaration of notions, ie labels and brackets have been omitted.

72


FIGURE 3.8-1

002 PROCEDURE fetch element pg;098 BEGIN099 INTEGER ARRAY element dl[0:char lit length m];100 INTEGER char il,kl,hash il,string delimiter il;

103 COMMENT read the element;105 char il := read a rel char pg;106 element dl[l] := char il;107 kl := 2;109 IF alphabetic m(char il) OR numeric m(char il) THEN112 BEGIN114 COMMENT the case of an element being an alpha-numeric

name or a literal value;118 FOR char il := read a rel char pg

WHILE alphabetic m(char il) or numeric m(char il) DO 121 BEGIN123 IF irrelevant skipped bg=true m THEN GOTO outl 11;125 element dl[kl] := char il;126 inc m(kl,1);127 END;129 outl 11:130 END ELSE132 BEGIN134 COMMENT case of the element being an operator type (ie

non alpha-numeric) name or character string;139 COMMENT check first for character string;141 string delimiter il := char il;143 IF string delimiter il = char lit 1 delimiter m OR144 string delimiter il = char lit 2 delimiter m THEN146 BEGIN148 COMMENT this is a character string literal;151 COMMENT fetch the string and return it ;153 kl := 1;155 FOR char il := ich m

WHILE char il <> string delimiter il DO157 BEGIN158 element dl[kl] := char il;159 inc m(kl,1);161 IF kl>char lit length m THEN162 errorhandler(LITERAL(e),

"Character%string%literal%is%too%long");

164 IF char il=new line m THENinc m(current line ig,l);

166 END;167 element dl[0]:=kl-l; (Character string length)168 element type ig := ele char lit m;169 element ig := LOCATION(element dl[0]);

73


170 return m;171 END;

173 FOR char il := read a rel char pgWHILE non alpha numeric m(char il) DO

175 BEGIN177 IF irrelevant skipped bg=true m THEN GOTO out211;179 element dl[kl];=char il;180 inc m(kl,1);181 END;183 out211:184 END;185 back step m;186 char buff mark ig := char buff mark ig-1;187 element dl[0] := kl-1;

188 COMMENT at this stage the array 'element dl' is set up suchthat element-0 is the character length of the element andelement-1 to element-n contain the characters of the element;

195 IF numeric m(element dl[l]) THEN 197 BEGIN199 COMMENT case of a numeric constant being returned ;201 kl := element dl[0]+l;202 element ig := 0;204 FOR kl;=kl-l WHILE kl>0 DO206 BEGIN207 element ig := element ig+power of 10 dg[

element dl[0]-kl]^element dl[kl];208 END;

209 element type ig := ele literal m;210 return m;211 END ELSE213 BEGIN215 COMMENT this is the complex part of the procedure where a

'name' is to be returned. Firstly it is necessary to searchthe object table to see if the name has been introducedalready;

221 hash il := 0;225 search for name 11:

227 IF object string dg[hash il]<> empty m THEN229 BEGIN231 COMMENT compare string table with the elements stored

in 'element dl';235 FOR kl:=0,kl+l WHILE kl<= object string dg[hash il] DO237 BEGIN

74


239 IF element dl[kl]<> object string dg[kl+hash 11] THEN241 BEGIN243 COMMENT the name is not the element so try the next

name ;245 hash il := hash il+4+object string dg[hash il];246 repeat m(search for name 11);247 END;248 END;250 COMMENT this is the element name so fetch the object

table index and return it in 'element ig' whilstsetting 'element type ig' to 'ele operand m';

256 hash il:=hash il+object string dg[hash il]+l;257 element ig:=object string dg[hash il]*64*64 +

object string dg[hash il+l]*64 +object string dg[hash il+2];

259 element type ig := el operand m;261 IF in intro bg <> false m AND

element ig <> rat dot m AND element ig <> rat colon m THEN

262 errorhandler pg(LITERAL(e),"Duplicate%introduction%of%an%object");

264 END ELSE266 BEGIN268 COMMENT this is the case where the name is not known

and hence the object must be declared;273 COMMENT check that the static function nesting

depth is not >0 as declarations are not allowed if this is the case;

277 IF func nest depth ig > 0 THEN278 errorhandler pg(LITERAL(e),

"Names%cannot%be%introduced%in%a%nested%funetion%definition" ) ;

75


281

285286

298300

306309310312316317318319321323324325326327 329

332

337338340

344346347348

COMMENT if this is not an introduction (ie USE ...) warn the man that we are introducing an object;IF in intro bg=false m THEN errorhandler pg(LITERAL(w),"introduction%of%an%object%assumed");obj size m[max obj table mark ig]:=default obj size m;

(fill in object size) obj str mark m[max obj table mark ig] := hash il;

(and the place where the name will be kept as an index into the object string table. Use the next free object table slot)

COMMENT now put the name of the object into the string table;FOR kl:=0,kl+l WHILE kl<=element dl[0] DO object string dl[hash il+kl]:=element dl[kl];COMMENT and now link back into the object table - into 3 bytes with the most significant first; inc m(hash il,element object string dg[hash object string dg[hash object string dgfhash

dl[0]+l); il ]:=byte il+1]:=byte il+2]:=byte

m(maxm(maxm(max

objobjobj

tabletabletable

mark ig); mark ig); mark ig);

COMMENT plant code to declare the object; program dg[prog mark ig] := rat declare m; program dgiprog mark ig+1] := byte 2 m(max obj table mark ig);

program dg[prog mark ig+2] ;= byte 1 m(max obj table mark ig);

program dg[prog mark ig+3] := byte 0 m(max obj table mark ig); inc m(prog mark ig,4);IF prog mark ig>prog size m "No%program%space%left");

THEN errorhandler pg(LITERAL(e),

COMMENT now set up the return values - firstly 'element ig' is set to the object table index of the object and 'element type ig' is set to 'ele operand m'; element ig := max obj table mark ig; element type ig := ele operand m;COMMENT and finally.... tidy up by :incrementing 'max obj table mark ig' checking for overflow of the object, and object string tables; inc m(max obj table mark ig,2);IF max obj table mark ig>obj table size m OR

hash il+2>obj str size m THEN errorhandler pg(LITERAL(e),"Too%many%names%introduced");

76


FIGURE 3.8-2IVOR "mule"UNIT "fetch element pg"SEIZED "globals"

ABSTRACTION SEIZED KEY outer KEY outer OUTERPROCESS KEY "outer" outer

— Define the "built in" modes of boolean, byte, integer, character— and string

MODE SEIZED KEY outer KEY outer RW BIT KEY boolean "boolean" ENDMODE

MODE SEIZED KEY outer KEY outer RW RANGE 0 255 KEY byte "byte" ENDMODE

MODE SEIZED KEY outer KEY outer RW RANGE -32768 +32767 KEY integer "integer" ENDMODE

MODE SEIZED KEY outer KEY outer RW CHAR KEY char "character" ENDMODE

MODE SEIZED KEY outer KEY outer RW ARRAY KEY char 0 255 KEY String "string" ENDMODE

— Now define the global variables used within the procedure— firstly "irrelevant skipped bg"

OBJECT SEIZED KEY outer KEY outer NOTINIT DIRECT KEY boolean KEY irrelevantskippedbg "irrelevant skipped bg" ENDOBJECT

— now "current line ig"OBJECT SEIZED KEY outer KEY outer LIFEINIT DIRECT KEY integer

KEY currentlineig "current line ig" ENDOBJECT— "element ig"

OBJECT SEIZED KEY outer KEY outer NOTINIT DIRECT KEY integer KEY elementig "element ig" ENDOBJECT

— "char buff mark ig"OBJECT SEIZED KEY outer KEY outer LIFEINIT DIRECT KEY integer

KEY charbuffmarkig "char buff mark ig" ENDOBJECT

78


"power of 10 dg" - requires both a mode and object introduction MODE SEIZED KEY outer KEY outer RO ARRAY KEY integer 0 10

KEY mode_poweroflOdg "mode_power of 10 dg" ENDMODE OBJECT SEIZED KEY outer KEY outer LIFEINIT DIRECT

KEY mode_poweroflOdg KEY charbuffmarkig "char buff mark ig" ENDOBJECT

"object string dg" - requires both a mode and object introductionMODE SEIZED KEY outer KEY outer RW ARRAY KEY char 0 1000

KEY mode_objectstringdg "mode_object string dg" ENDMODE OBJECT SEIZED KEY outer KEY outer NOTINIT DIRECT

KEY mode_objectstringdg KEY objectstringdg "object string dg" ENDOBJECT

"in intro bg"OBJECT SEIZED KEY outer KEY outer LIFEINIT DIRECT

KEY boolean KEY inintrobg "in intro bg" ENDOBJECT"obj size m" which is an array of restricted range (to 12 bits).This is not fundamental to the design of the module and was chosento save space. Consequently to simplify the descriptionthe object has been declared with mode integer.

MODE SEIZED KEY outer KEY outer RW ARRAY KEY integer 0 1000KEY mode_objsizem "mode obj size m" ENDMODE

OBJECT SEIZED KEY outer KEY outer NOTINIT DIRECTKEY mode_objsizem KEY objsizem "obj size m" ENDOBJECT

"obj str mark m"MODE SEIZED KEY outer KEY outer RW ARRAY KEY integer 0 1000

KEY mode_objstrmarkm "mode_obj str mark m" ENDMODE OBJECT SEIZED KEY outer KEY outer NOTINIT DIRECT

KEY mode_objstrmarkm KEY objstrmarkm "obj str mark m" ENDOBJECT

"max obj table mark ig"OBJECT SEIZED KEY outer KEY outer LIFEINIT DIRECT

KEY integer KEY maxobjtablemarkig "max obj table mark ig" ENDOBJECT

79


"program dg"MODE SEIZED KEY outer KEY outer RW ARRAY KEY byte 0 1000

KEY mode_programdg "mode_program dg" ENDMODE OBJECT SEIZED KEY outer KEY outer NOTINIT DIRECT

KEY mode_programdg KEY programdg "program dg" ENDOBJECT"prog mark ig"

OBJECT SEIZED KEY outer KEY outer LIFEINIT DIRECTKEY integer KEY progmarkig "prog mark ig" ENDOBJECT

ENDABSTRACTION

80


— And now define the seized global procedures, and procedure— arguments used by the module.— Firstly "read a rel char pg" which has one argument,— its returned result.

ABSTRACTION SEIZED KEY outer KEY outer PROCEDURE SIMPLENONRECURSIVE NONCRITICAL readarelcharpg "read a rel char pg"

— And now the procedure arguments, only one the procedure result.OBJECT SEIZED KEY readarelcharpg KEY readarelcharpg NOTINIT

ARGUMENT KEY readarelcharpg RESULT KEY integer KEY result_readarelcharpg "result_read a rel char pg" ENDOBJECT

— And now the local variables of the procedure, it has one only— "char il".

OBJECT SEIZED KEY readarelcharpg KEY readarelcharpg NOTINIT DIRECT KEY integer KEY charil "char il"ENDOBJECT

ENDABSTRACTION— and finally the procedure "error handler pg"

ABSTRACTION SEIZED KEY outer KEY outer PROCEDURE SIMPLENONRECURSIVE NONCRITICAL errorhandlerpg "error handler pg"

— And now the procedure arguments, the first and second parameterOBJECT SEIZED KEY readarelcharpg KEY readarelcharpg

NOTINIT ARGUMENT KEY readarelcharpg IN KEY char KEY severityq "severity q" ENDOBJECT

OBJECT SEIZED KEY readarelcharpg KEY readarelcharpgNOTINIT ARGUMENT KEY readarelcharpg IN KEY string KEY errorstringq "error string q" ENDOBJECT

— And now the local variables of the procedure, it has one only— "kl".

OBJECT SEIZED KEY readarelcharpg KEY readarelcharpg NOTINIT DIRECT KEY integer KEY kl "kl" ENDOBJECT

ENDABSTRACTIONENDDEFINITIONSENDSEIZED

81


— Now the definitions of the Ivor unit are introduced in the— definition stream.DEFINITIONS

ABSTRACTION VISIBLE KEY outer KEY outer PROCEDURE SIMPLE NONRECURSIVE NONCRITICAL KEY fetchelementpg "fetch element pg"

— The procedure does not have arguments so introduce ..— the objects and modes which are local to the procedure— "fetch element pg"— Firstly "element dl"

MODE VISIBLE KEY fetchelementpg KEY fetchelementpg RWARRAY KEY integer 0 12 KEY mode elementdl "mode_element dl" ENDMODE

OBJECT VISIBLE KEY fetchelement KEY fetchelement NOTINIT DIRECT KEY mode_elementdl KEY elementdl "element dl" ENDOBJECT

— And finally the integers "char il", "kl", "hash il",— "string delimiter il"

OBJECT VISIBLE KEY fetchelement KEY fetchelement NOTINIT DIRECT KEY integer

KEY charil "char il"KEY kl "kl"KEY hashil "hash il"KEY stringdelimiteril "string delimiter il"

ENDOBJECTENDABSTRACTION

ENDDEFINITIONSCONSTANTS— The constant stream does not contain any operations ENDCONSTANTSOPERATIONS— The operation stream gives the logic of the program.— Line 002 : PROCEDURE fetch element pg;

BRACKET KEY fetchelementpg— Line 105 : char il := read a rel char pg;— The procedure is activated and the result bound to the— variable charil by the ARGUMENT operation. No assignment— is necessary at the procedure return.

ACTIVATE KEY readarelcharpgARGUMENT KEY result_readarelcharpg KEY charilENTERPROC KEY readarelcharpg

— Line 106 : element dl[l] := char il;— First evaluate the address of the element onto the address stack

82


INDEXNow assign ASSIGN

ADDRESSSTACK KEY refinteger KEY elementdl 1 KEY integer

to the address the [ADDRESSSTACK KEY

value of "char il" refinteger] [KEY charil]

Line 107 : kl := 2; ASSIGN KEY kl 2 KEY integerLine 109 : IF alphabetic m(char il) OR numeric m(char il ) THEN Note - "alphabetic(X)" is a macro which expands to "x>=LITERAL(A) and x<=LITERAL(z)"ENTERLT [KEY charil] "A"

KEY intermediatel09 ENTERLE [KEY charil] "Z"

KEY truel09 LABEL KEY intermediatel09Note - numeric(x) is a macro which expands to X<=LITERAL(9)"ENTERLT [KEY charil] "0"

KEY falsel09 ENTERGT [KEY charil] "9"

KEY falsel09 LABEL KEY truel09

KEY char KEY char

"x>=LITERAL(0) and KEY char KEY char

FOR char il := read a rel char pgLine 118Line 119 : WHILE alphabetic m(char ilBRACKET KEY forll8ACTIVATE KEY readarelcharpgARGUMENT KEY result_readarelcharpgENTERPROC KEY readarelcharpgENTERLT [KEY charil]

KEY intermediatell8 ENTERLE [KEY charil]

KEY truell8 LABEL KEY intermediatell8EXITLT [KEY charil]

KEY forll8 EXITGT [KEY charil]

KEY forll8 LABEL KEY truell8

or numeric m(char il) DO

KEY charil"A" KEY charII rt IIZ" KEY char

"0" KEY char "9" KEY char

Line 123 : IF irrelevant skipped bg = true m then goto out 1 11; ENTERTRUE [KEY irrelevantskippedbg] KEY outlllLine 125 INDEX

ASSIGN

element dl[kl] := char il;ADDRESSSTACK KEY refinteger [KEY kl][ADDRESSSTACK KEY refinteger] [KEY charil]

KEY elementdl

Line 126 : inc m(kl,l);Note - "inc m(x,y)" is a macro which expands to "x:=x+y" ad d key kl [key kl]

1 KEY integer

83


Line 127 : the end of the FOR loop of line 118 ENTER KEY forll8ENDBRACKET KEY forll8Line 129 LABEL

out 1 11; KEY outlll

Line 130 : end of the "true" partthen.... else" statement of line 109 ENTER KEY fil09LABEL KEY falsel09

of the "if.

Line 141 ASSIGN

string delimiter il := char il;KEY stringdelimiteril [KEY charil]

il = il =

charchar

litlit

Line 143 : IF string delimiter Line 144 : string delimiterNote - char lit 1 delimiter m is LITERAL( char lit 2 delimiter m is LITERAL(")

delimiterdelimiter

m OR m THEN

) andENTEREQ [KEY stringdelimiteril]

KEY truel43 ENTERNE [KEY stringdelimiter]

KEY falsel43 LABEL KEY truel43

"'" KEY char KEY char

Line 153 : kl := 1; ASSIGN KEY kl 1 KEY integer

— Line 155BRACKETACTIVATEARGUMENTENTERPROCEXITEQ

FOR char il := ich m WHILE char il <> string delimiter il DO KEY forl55 KEY ichmKEY result_ichm KEY charilKEY ichm[KEY charil] [KEY

stringdelimiteril]KEY forl55

Line 158 INDEXASSIGNLine 159 ADD

element dl[kl] := char il ADDRESSSTACK KEY refinteger KEY elementdl [KEY kl][ADDRESSSTACK KEY refinteger] [KEY charil]

inc m(kl,1); KEY kl1 KEY integer

[KEY kl]

Line 161 : IF kl>char lit length m THEN error handler pg(LITERAL(E),"Character%string%literal

%is%too%long");Note - "char lit length m" is a macro representing the integer 63ENTERGT [KEY kl] 63 KEY integer

KEY fil61

84


ACTIVATEARGUMENTARGUMENT

ENTERPROCLABEL

KEY errorhandlerpg KEY severity KEY errorstring

KEY errorhandler fil61

"E" KEY char "Character%string% literal%is%too%long" KEY string

Line 164 ; IF char il=new line m THEN inc m(current line ig,l) Note - "new line m" is a macro for the value "-1"ENTERNEADD

Line 166 : ENTERENDBRACKETLine 167 : SUBTRACTINDEXASSIGN

[KEY charil] fil64KEY currentlineig 1 KEY integer

-1 KEY integer [KEY currentlineig]

end of the FOR loop started at line 155 KEY forl66 KEY forl66

element dl[0] := kl-1;OPERANDSTACK KEY integer [KEY kl]1 KEY integerADDRESSSTACK KEY refinteger KEY elementdl 0 KEY integer[ADDRESSSTACK KEY refinteger] [OPERANDSTACK

KEY integer]

Line 168 : element type ig := ele char lit m;Note - "ele char lit m" is a macro for the value "2" ASSIGN KEY elementtypeig 2 KEY integer

85


Line 169 : element ig := LOCATION(element INDEX ADDRESSSTACK KEY refinteger

0 KEY integer ASSIGN KEY elementig

dl[0]);KEY elementdlADDRESSSTACK KEY refinteger

Line 170 : return m;Note - CORAL 66 does not have a procedure return statement. The macro "return m" has been used consistently to mean return from the procedure and will be interpreted as meaning this.EXITPROC KEY fetchelementpgLine 171 ; end of the IF statement of line 143 LABEL fil43

— Line 17 3 ;— Note — The— "X<LITERAL(A)

FOR char il := read a rel char pg WHILE non alpha numeric m(char il) DOmacro "non alpha numeric m (x )" is translated into

OR x>LITERAL(Z) AND x<LITERAL(0) OR x>LITERAL(9)"BRACKET KEY forl73ACTIVATE KEY readarelcharpgARGUMENT KEY result_readarelcharpg KEY charilENTERPROC KEY readarelcharpgENTERLT [KEY charil]

KEY intermediatel73"A" KEY char

EXITLE [KEY charil] KEY forl73

"Z" KEY char

LABEL KEY intermediatel73ENTERLT [KEY charil]

KEY truel73"0" KEY char

EXITGT [KEY charil] KEY forl73

"9" KEY char

LABEL KEY truel73

Line 177 : IF irrelevant skipped bg=true GOTO out 2 11;

m THEN

ENTERTRUE [KEY irrelevantskippedbg] KEY OUt211

Line 179 : element dl [kl] := char il;INDEX ADDRESSSTACK KEY refinteger

[KEY kl]KEY elementdl

ASSIGN [ADDRESSSTACK KEY refinteger] [KEY charil]

Line 180 ; inc m(kl,1);ADD KEY kl

1 KEY integer[KEY kl]

86


Line 181 : ENTERENDBRACKETLine 183 : LABELLine 184 : LABELLine 185 ;ACTIVATEENTERPROCLine 186 : SUBTRACT

Line 187 SUBTRACTINDEXASSIGN

Line 195 INDEXALLOCATEDEREFENTERGEENTERGTLABELLine 201 INDEXDEREFADD

Line 202 ASSIGNLine 204BRACKETSUBTRACT

end of FOR loop of line 173 KEY forl73 KEY forl73

out 2 11:KEY out211

end of false part of the IF statement of line 109 KEY fil09

back space m;KEY backspacem KEY backspacemchar buff mark ig := char buff mark ig -1;KEY charbuffmarkig [KEY charbuffmarkig]1 KEY integer


element dl[0] := kl-1;OPERANDSTACK KEY integer 1 KEY integerADDRESSSTACK KEY refinteger0 KEY integer[ADDRESSSTACK KEY refinteger] [OPERANDSTACK

KEY integer]

IF numeric m(element dl[l]) THEN ADDRESSSTACK KEY refinteger KEY elementdl1 KEY integerKEY temporaryl95 KEY char KEY temporaryl95KEY temporaryl95 KEY truel95 KEY temporaryl95 KEY falsel95 KEY truel95

kl := element dl[0]+l; ADDRESSSTACK KEY refinteger0 KEY integer OPERANDSTACK KEY integerKEY kl1 KEY integer

element ig := 0;KEY elementigFOR kl := kl-1 WHILE kl>0 DO KEY for204 KEY kl1 KEY integer

[ADDRESSSTACK KEY refinteger] "0" KEY char"9" KEY char

KEY elementdl[ADDRESSSTACK KEY refinteger] [OPERANDSTACK KEY integer]

0 KEY integer

[KEY kl]

87


EXITLE

Line 207INDEXDEREF

[KEY kl] KEY for204

0 KEY integer

element ig := element ig+power of 10 dg [element dl[0]-kl]^element dl[kl]ADDRESSSTACK KEY refinteger KEY elementdl 0 KEY integerOPERANDSTACK KEY integer [ADDRESSSTACK

KEY refinteger]SUBTRACT OPERANDSTACK KEY integer

[KEY kl][OPERANDSTACK KEY integer]

INDEX ADDRESSSTACK KEY refinteger [KEY kl]

KEY elementdlDEREF OPERANDSTACK KEY integer [ADDRESSSTACK

KEY refinteger]MULTIPLY OPERANDSTACK KEY integer

[OPERANDSTACK KEY integer][OPERANDSTACK KEY integer]

ADD KEY elementig [OPERANDSTACK KEY integer]

[KEY elementig]

— Line 208 : end of FOR loop of line 204ENTER for204ENDBRACKET for204

— Line 211 : end of true part of IF statement of line 195ENTER fil95LABEL falsel95

— Line 221 : hash il := 0;ASSIGN KEY hashil 0 KEY integer

— Line 225 : seach for name 11:LABEL KEY searchfornamell

— Line 227 : IF object string dg[hash il]<> empty m THEN— Note - "empty m" is a macro representing

INDEX ADDRESSSTACK KEY refinteger [KEY hashil]

KEY objectstriniDEREF OPERANDSTACK KEY integer [ADDRESSSTACK

KEY refinteger]ENTEREQ [OPERANDSTACK KEY integer]

KEY fi227-1 KEY integer

— Line 235BRACKETASSIGNENTERLABELADDINDEX

FOR kl := 0,kl+l WHILE kl <= object string dg[hash il] DO for235 KEY klKEY forstart235 KEY forelement2_235 KEY kl1 KEY integerADDRESSSTACK KEY refinteger

0 KEY integer

[KEY kl]KEY objectstringdg

88


DEREFEXITGT

LABELLine 239INDEXDEREFADDINDEXDEREFENTEREQ

Line 245 ADDINDEXDEREFADD

[KEY hashil]OPERANDSTACK KEY integer

[KEY kl]KEY for235 KEY forstart235

[ADDRESSSTACK KEY refinteger] [OPERANDSTACK KEY integer]

IF element dl[kl]<>object string dg[kl+hash il] THENADDRESSSTACK KEY refinteger [KEY kl]OPERANDSTACK KEY integer

KEY elementdl

OPERANDSTACK KEY integer [KEY hashil]ADDRESSSTACK KEY refinteger [OPERANDSTACK KEY integer] OPERANDSTACK KEY integer[OPERANDSTACK KEY integer]

fi239

[ADDRESSSTACK KEY refinteger] [KEY kl]KEY objectstringdg[ADDRESSSTACK KEY refinteger] [OPERANDSTACK KEY integer]

hash il := hash il+4+object string dg[hash il]; OPERANDSTACK KEY integer 4 KEY integerADDRESSSTACK KEY refinteger [KEY hashil]OPERANDSTACK KEY integer

[KEY hashil]KEY objectstringdg

KEY hashil[OPERANDSTACK KEY integer]


Line 246 ; repeat m(search for name 11);Note - "repeat m(x)" is a macro which expands to "GOTO m" ENTER KEY searchfornamellLine 247 : end of IF statement of line 239 LABEL KEY fi239Line 248 : end of FOR statement of line 235 ENTER KEY forelement2_235ENDBRACKET KEY for235Line 256 INDEXDEREFADD

hash il := hash il + object string dg[hash il]+l; ADDRESSSTACK KEY refinteger KEY objectstringdg [KEY hashil]OPERANDSTACK KEY integerOPERANDSTACK KEY integer 1 KEY integer


89


ADD KEY hashil[OPERANDSTACK KEY integer]

— Line 257 : element ig :=

INDEXDEREFMULTIPLY

ADDINDEXDEREFMULTIPLY

ADD

ADDINDEXDEREFADD

— Line 259 :— Note - "el

ASSIGN— Line 261 :

ADDRESSSTACK [KEY hashil] OPERANDSTACK

object object object KEY

stringstringstring

refinteger KEY integer

OPERANDSTACK KEY integer4096 KEY integer OPERANDSTACK KEY integer1 KEY integerADDRESSSTACK KEY refinteger [OPERANDSTACK KEY integer] OPERANDSTACK KEY integerOPERANDSTACK KEY integer64 KEY integer OPERANDSTACK KEY integer[OPERANDSTACK KEY integer] OPERANDSTACK KEY integer2 KEY integerADDRESSSTACK KEY refinteger [OPERANDSTACK KEY integer] OPERANDSTACK KEY integerKEY elementig[OPERANDSTACK KEY integer]

element type ig := ele operand e operand m" is a macro for the

KEY elementtypeigIF

[KEY hashil]

dg[hash il]*64*64+ dgihash il+l]*64 + dgihash il+2];

KEY objectstringdg[ADDRESSSTACK KEY refinteger][OPERANDSTACK KEY integer][KEY hashil]KEY objectstringdg[ADDRESSSTACK KEY refinteger] [OPERANDSTACK KEY integer][OPERANDSTACK KEY integer][KEY hashil]KEY objectstringdg[ADDRESSSTACK KEY refinteger][OPERANDSTACK KEY integer]m;value 1 KEY

I I 2 I I

integer

— Note "rat "rat

ENTERTRUE ENTEREQENTEREQ

— Line 262

ACTIVATEARGUMENT

in intro bg <> false m AND element ig <> rat dot m AND element ig <> rat colon m THEN

dot m" is a macro for the value "2", and colon m" is a macro for the value "0"[KEY inintrobg] KEY fi261[KEY elementig] 2 KEY integerKEY fi261[KEY elementig] 0 KEY integerKEY fi261

errorhandler pg(LITERAL(E),"Duplicate% introduction%of%an%object");

... and the end of the IF statement of line 261 KEY errorhandlerpgKEY severity "E" KEY char

90


ARGUMENT

ENTERPROCLABEL

— Line 264 ENTER LABEL

— L i ne 277

ENTERLEACTIVATEARGUMENTARGUMENT

ENTERPROCLABEL

KEY errorstring

KEY errorhandler KEY fi261

"Duplicate%intréduction %of%an%object"KEY string

end of the true part of the IF statement of line 227 KEY fi227 KEY false227IF func nest depth ig > 0 THEN

errorhandler pg(LITERAL(E),"Names%cannot%be% introduced%in%a%nested%function%definition");

[KEY funcnestdepthig] 0 KEY integerKEY fi277KEY errorhandlerpgKEY severity "E" KEY charKEY errorstring "Names%cannot%be%introduced%in%a%nested%funetion%definition"

KEY stringKEY errorhandler KEY fi277

91


Line 285 : IF in intro bg=false m THENerrorhandler pg(LITERAL(W),"Introduction%of%an% object%assumed");

ENTERFALSE [KEY inintrobg] KEY fi285ACTIVATE KEY errorhandlerpgARGUMENT KEY severityARGUMENT KEY errorstring

"E" KEY char "Introduction%of%an% object%assumed"KEY string

ENTERPROCLABEL


Line 298 : obj size m[max obj table mark ig] := default obj size m;Note - "default obj size m" is a macro for the value "4"INDEXASSIGN

— Line 300 : INDEXASSIGN

— Line 309 :BRACKETASSIGNENTERLABELADDINDEXDEREFEXITGT

LABELINDEXINDEXDEREFASSIGNENTERENDBRACKET

— Line 316 ; INDEX

ADDRESSSTACK KEY refinteger KEY objsizem [KEY maxobjtablemarkig][ADDRESSSTACK KEY refinteger] 4 KEY integer

obj str mark m[max obj table mark i] := hash il; ADDRESSSTACK KEY refinteger KEY objstrmarkm [KEY maxobjtablemarkig][ADDRESSSTACK KEY refinteger] KEY hashil

FOR kl:=0,kl+l WHILE kl<=element dl[0] DO object string dl[hash il] := element dl[kl];KEY for309 KEY klKEY forstart309 KEY forelement2_309 KEY kl1 KEY integerADDRESSSTACK KEY refinteger 0 KEY integer OPERANDSTACK KEY integer[KEY kl]

0 KEY integer


KEY for309 KEY forstart309 ADDRESSSTACK KEY refinteger [KEY hashil]ADDRESSSTACK KEY refinteger [KEY kl]OPERANDSTACK KEY integer [ADDRESSSTACK KEY refinteger]


KEY forelement2 KEY for309

309

KEY objectstringdlKEY elementdl[ADDRESSSTACK KEY refinteger] [OPERANDSTACK KEY integer]

inc m(hash il,element dl[0]+l);ADDRESSSTACK KEY refinteger KEY elementdl 0 KEY integer

92


DEREFADD

ADD

— Line 317

OPERANDSTACK KEY integerOPERANDSTACK KEY integer1 KEY integer KEY hashil[OPERANDSTACK KEY integer]

[ADDRESSSTACK KEY refinteger] [OPERANDSTACK KEY integer][KEY hashil]

object string dg[hash il] := byte 2 m(max obj table mark ig);

e 2 m (X )" is a macro which delivers as an integer bitsNote "byt 12 to 17 (if the LSB is bit 0) of INDEX

X

RANGECONVERTSLICE

CONVERTASSIGN

— Line 318 :— Note "byte— 6 to 11 (i:

ADDINDEXRANGECONVERTSLICE

CONVERTASSIGN

— Line 319 :

KEY objectstringdg 12 KEY integer

ADDRESSSTACK KEY refinteger [KEY hashil]OPERANDSTACK KEY pair 17 KEY integer OPERANDSTACK KEY intbitstring KEY maxobjstringdg OPERANDSTACK KEY intbitstring [OPERANDSTACK

KEY intbitstring][OPERANDSTACK KEY pair]OPERANDSTACK KEY integer[ADDRESSTACK KEY refinteger]

[OPERANDSTACK KEY intbitstring] [OPERANDSTACK KEY integer]

object string dg[hash il+1] := byte 1 m(max obj table mark ig);1 m (X )" is a macro which delivers as an integer bits : the LSB is bit 0) of "x"OPERANDSTACK KEY integerI KEY integerADDRESSSTACK KEY refinteger [OPERANDSTACK KEY integer]OPERANDSTACK KEY pairII KEY integerOPERANDSTACK KEY intbitstring KEY maxobjstringdg OPERANDSTACK KEY intbitstring [OPERANDSTACK

KEY intbitstring][OPERANDSTACK KEY pair]OPERANDSTACK KEY integer

[KEY hashil]KEY objectstringdg 6 KEY integer

[ADDRESSTACK KEY refinteger][OPERANDSTACK KEY intbitstring] [OPERANDSTACK KEY integer]

object string dg[hash il+2] := byte 0 m(max obj table mark ig);

Note "byte 0 m(x)" is a macro which delivers as an integer bits 0 to 5 (if the LSB is bit 0) of "x"ADD OPERANDSTACK KEY integer

2 KEY integer INDEX ADDRESSSTACK KEY refinteger

[OPERANDSTACK KEY integer]RANGE OPERANDSTACK KEY pair

5 KEY integer

[KEY hashil]KEY objectstringdg 0 KEY integer

93


CONVERTSLICE

CONVERTASSIGN

Line 323 Note - " INDEXASSIGNLine 324ADDINDEXRANGECONVERTSLICE

CONVERTASSIGN

Line 325ADDINDEXRANGECONVERTSLICE

CONVERTASSIGN

Line 326ADDINDEX

OPERANDSTACK KEY intbitstring KEY maxobjstringdg OPERANDSTACK KEY intbitstring [OPERANDSTACK

KEY intbitstring][OPERANDSTACK KEY pair]OPERANDSTACK KEY integer[ADDRESSTACK KEY refinteger]

[OPERANDSTACK KEY intbitstring] [OPERANDSTACK KEY integer]

: program dg[prog mark ig] := rat declare m; rat declare m" is a macro for the value "5"

ADDRESSSTACK KEY refinteger KEY programdg [KEY progmarkig][ADDRESSSTACK KEY refinteger] 5 KEY integer

program dg[progmark ig +1] := byte 2 m(max obj table mark ig OPERANDSTACK KEY integer 1 KEY integerADDRESSSTACK KEY refinteger [OPERANDSTACK KEY integer] OPERANDSTACK KEY pair 17 KEY integerOPERANDSTACK KEY intbitstring OPERANDSTACK KEY intbitstring[OPERANDSTACK KEY pair] OPERANDSTACK KEY integer[ADDRESSTACK KEY refinteger]

program dg[progmark ig +2] := byte 1 m(max obj table mark ig OPERANDSTACK KEY integer 2 KEY integerADDRESSSTACK KEY refinteger [OPERANDSTACK KEY integer] OPERANDSTACK KEY pair 11 KEY integerOPERANDSTACK KEY intbitstring OPERANDSTACK KEY intbitstring[OPERANDSTACK KEY pair] OPERANDSTACK KEY integer[ADDRESSTACK KEY refinteger]

) ;[KEY progmarkig]KEY programdg12 KEY integerKEY maxobjstringdg [OPERANDSTACK KEY intbitstring][OPERANDSTACK KEY intbitstring][OPERANDSTACK KEY integer]

) ;[KEY progmarkig]KEY programdg6 KEY integerKEY maxobjstringdg [OPERANDSTACK KEY intbitstring][OPERANDSTACK KEY intbitstring] [OPERANDSTACK KEY integer]

program dg[progmark ig +3] := byte 0 m(max obj table mark ig);OPERANDSTACK KEY integer [KEY progmarkig]3 KEY integerADDRESSSTACK KEY refinteger KEY programdg

94


[OPERANDSTACK KEY integer] RANGE OPERANDSTACK KEY pair

5 KEY integer CONVERT OPERANDSTACK KEY intbitstringSLICE OPERANDSTACK KEY intbitstring

[OPERANDSTACK KEY pair] CONVERT OPERANDSTACK KEY integerASSIGN [ADDRESSTACK KEY refinteger]

0 KEY integerKEY maxobjstringdg [OPERANDSTACK KEY intbitstring][OPERANDSTACK KEY intbitstring] [OPERANDSTACK KEY integer]

Line 329 : IF prog mark ig > prog size m THENerrorhandler pg(LITERAL(E),"No%program%space%left");

Note "prog size m" is a macro for the value "10000"ENTERLEACTIVATEARGUMENTARGUMENT

ENTERPROCLABELLine 337 ASSIGN

Line 338 ASSIGN

[KEY progmarkig] KEY fi329KEY errorhandlerpg KEY severity KEY errorstring


10000 KEY integer

"E" KEY char "No%program% space%left" KEY string

element ig := max obj table mark ig;KEY elementig [KEY

maxobjtablemarkig]element type ig := ele operand m;KEY elementtypeig 1 KEY integer

95


— Line 344 : inc m(max obj table mark ig,2) /ADD KEY maxobjtablemarkig [KEY

maxobjtablemarkig]2 KEY integer

— Line 346 ; IF max obj table mark ig > obj table size m OR— hash il +2 > obj str size m THEN

— errorhandler pg(LITERAL(E),"Too%many%names%introduced");— Note - "obj table size m" is a macro for the value "1000" and

"obj str size m" is a macro for the value "10000"ENTERGT [KEY maxobjtablemarkig] 1000 KEY integer

KEY true346ADD OPERANDSTACK KEY integer [KEY hashil]

2 KEY integerENTERLE [OPERANDSTACK KEY integer] 10000 KEY integer

KEY fi346LABEL true346ACTIVATE KEY errorhandlerpgARGUMENT KEY severity "E" KEY charARGUMENT KEY errorstring "Too%many%names%

introduced"KEY string

ENTERPROC KEY errorhandlerLABEL KEY fi346

— Line 349 : end of false part of IF statement of line 227LABEL KEY fi227

— Line 350 : end of false part of IF statement of line 195LABEL KEY fil95

— Line 353 : end of procedure, and end of moduleEXITPROC KEY fetchelementpgENDBRACKET KEY fetchelementpg

ENDOPERATIONSENDUNIT

96


4 MULE

This section of the Thesis describes a function based programming language called Mule. Mule was designed and implemented as part of the research for this degree. The aims were :

- To provide a programming environment rather than alanguage.

- To design the environment to be portable.- To provide an environment which can evolve.

- To implement a pilot Mule environment in order to test outthe idea.

In many of the program portability methods researched portability was achieved by reprocessing the program being ported using either a compiler, macroprocessor, interpreter, etc in the new environment. This gave the user of the program a new environment to work in in addition to the program operating in the new environment. For example, if a spread-sheet program is transported from an IBM machine environment to an ICL machine environment then only the use of the spread-sheet (assuming a successful port) remains the same. The user needs to learn (possibly) new logging on sequences, new ways of invoking programs, and possibly new ways of invoking simple utilities like editing.

A way of removing this problem is to provide a user with an environment in which he works. The environment would provide all of the facilities that he requires and he would never need to venture outside of the environment, nor need to access any of the native facilities of the underlying host machine.So, if the user wishes to use his facility set on new machine it would be necessary to move the whole environment to that new machine.

This section of the research was aimed at investigating the needs of such an environment and looking at ways of making it easy to port.

In order to meet the aims it was decided to define a kernel of facilities to form the foundation of the mule environment. The kernel will provide Ist-level facilities. In order to provide a greater number of facilities, say 2nd-level facilities. Mule could be enhanced using Ist-level facilities alone. So the facilities available to a user would be both 1st and 2nd-level facilities. In order to provide a greater range of facilities still the Mule environment could be enhanced to provide, say 3rd- level facilities, using the facilities of the Ist-level and 2nd- level ... and so on.

97


The success, or otherwise, of this approach depends upon the design of the kernel which should provide sufficient facilities to allow the upper levels (ie 2nd, 3rd ... level facilities) to be implemented but should be sufficiently small so that it can be transported with relative ease.The real success of such an environment, however, is in the ability to produce applications on top of the basic environment. The Mule language designed is probably rich enough for this but this was not tested to any depth, except for the production of language additions.A Mule environment was designed and implemented and this is described in the following sections, as follows :

- The Mule language- The Pilot Implementation- Test programs- Conclusions

The major conclusions are :- That it is easy to add new functions to Mule and thatthese functions are identical to built-in or kernelfunctions, as viewed by the Mule progammer.- The concept of mode or type would be a useful addition and could be added using kernel facilities alone.- The kernel is small, but sufficient.- The lexical analyser should be produced in Mule to obtainmaximum transportability.

98


4.1 The Mule LanguageThe idea was to develop a function based language which had very few basic concepts and a very simple underlying abstract machine.The function was to be the way that facilities were provided.Some base level functions were to form the Mule kernel and were to be used in order to create higher level functions which could, in the end provide applications, eg editing, data handling., etc.Little consideration was to be given to the syntax of the language as it was the idea of a hierarchy of functions that was to be addressed, rather than a syntactically elegant language.What follows is a description of the design work performed in order to meet these aims, and details about the Mule pilot implementation.

The mule language assumes a very simple underlying machine with 4 data areas : data memory, program memory, a stack and an objecttable.Data memory is the main memory for holding the values of introduced objects. Program memory holds the Mule function definitions. Data and Program memory are totally separate ensuring that data can never be treated as program and inadvertantly executed.Data memory comprises cells, each of identical (but unspecified) bit size and with addresses starting at cell 0 and increasing by 1 .

Program memory comprises cells, again with each having identical (but unspecified) bit size and with addresses starting at cell 0 and increasing by 1.The stack is used for holding values during expression evaluation.The stack is a first-in last-off organised data structure which can be used to hold values. The Mule kernel provides the programmer with facilities for adding objects to the stack and for removing them.The object table holds information about objects which are introduced, or used within a Mule program. Objects will be described later but for now consider them to be the names of variables and subroutines. Access to the object table is obtained by using the object's name as a key. The information held in the object table is the start address of the object (ie memory cell address) and the size of the object, in memory cells.The Mule language will be described using the modified BNF of

99


section 2. To simplify the syntax description space-characterand new line separators are not shown in the syntax description. Both spaces and new lines are significant and multiple spaces, or new lines, are exactly equivalent. In general spaces and new lines are required wherever it would be ambiguous not to so do.For example: USE A B. requires the space between the USE and the

name A and between the name A and name B. USEA B. is ambiguous, and ...USE AB. intoduces a single name, ie AB.

<mule language> ::={<object introduction> |<stacking operation> |<function call operation> |<function stacking operation> |<infix stacking operation> |<destacking operation> }0:*

The operations will be described in more detail in subsequentsection. They allow :

- Objects to be introduced and then used subsequently inother operations.- The results of, for example arithmetic or logicaloperations, to be evaluated and placed on the stack.- A value to be placed on the stack.- A function to be defined and placed upon the stack.- A function, which has been placed upon the stack, to beexecuted.- A value to be removed from the stack and placed in datamemory.

Objects may be introduced, though they need not be. They are given names in a similar manner to other programming languages, eg a vaid name might be:

CASHFLOW or PRINCIPALA number of data memory cells are allocated to the object and a pointer to the first memory cell is placed in the data table record for the introduced object.The number of data memory cells is dependent upon the manner in which the object is introduced. For example if an object is introduced by :

USE cashflow:25.

100


Then 25 data memory cells will be allocated to the object. The introduction is executed every time it is met so that memory is allocated and released as the program executes. So, an introduction of the form :

USE principal : scale.Will allocate a variable number of data memory cells, depending upon the value of the object 'scale'. There are defaults too. If an object is introduced without the size being specified (or if the object is not formally introduced at all) a default size of four data memory cells is used.Object names are not restricted to the more common kind of names, like those shown above. Special names can be introduced too, eg:

USE + + , $ $ .

These names can be used in exactly the same manner as "normal" names but they are provided in order to allow the Mule environment to be enhanced by the addition of new operators, by using the introduced names in order to invoke Mule functions. Similarly, special names may have a size attribute specified.Fundamental to the operation of Mule is the stack. Functions do not have parameters (as such) and (strictly) there are no expressions. Mule operations take items from the stack and return items to the stack. An item may be an object's value, an object's address or a constant value. The size of an object is an integral part of its identity and when an object is placed on the stack the top stack item assumes the size attribute of the item being placed on the stack. Again, there are defaults. For example an integer constant has a size of four memory cells, as does an object address.Functions can be defined in Mule by the use of the FUNCTION and END brackets. The effect of the definition is to, effectively, place the function definition on the stack. For example,

FUNCTION 123.72 END

is a function definition which, WHEN EXECUTED, will place 123.72 on the stack. A more useful example is :

FUNCTIONUSE localstring:stringsize -> ^localstring ^localstring; outchar()

ENDThis function, when executed, takes a value from the stack and assigns it to the data memory locations of the object "localstring". It then prints the string via the built in function "outchar"

101


The function defined has no name. It is merely placed on the stack. Functions can be executed from the stack by using the function call operation, eg

FUNCTION 1234.72 END ()will cause a function to be placed on the stack which will be immediately executed to cause the constant value, 1234.72, to be placed on the stack.It is more normal to assign a function to an introduced object. The object must have a size attribute of the default, ie 4 memory cells. In the previous case a new function, "outstring", can be created by assigning the function, as follows :

USE outstring.FUNCTION

USE localstring:stringsize -> @localstring ^localstring; outchar()

END -> @outstringIn fact any value can be assigned to an object. The right hand side of the "destacking" operation must be an address, hence the

notation. For example :"A character string

containing line control <CR> characters" —> @string 1234->@constantvalue

4.1.1 Object Introduction

Syntax :<object introduction> ::=

USE { <intro> { <intro>}0:* }1:* .

<intro> : : =<name> { : <size> }

<size> : : =<name> | <numeric constant>

<name> ::=<alpha-numeric name> |<special name>

<alpha-numeric name> ::=<letter> { <letter>|<digit>}0 :11

<letter> ::=A|B|C|D|E|F|G|H|I|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

102


<digit> : ; =0|1|2|3|4|5|6|7|8|9

<special name> ::={ <special character> }1:12

<special character> ::=I|"|E|$|%|&|'|(|)|*|:|[|{|}|]|"|?|/|>|<|.|+|-|=I@

Mule objects may be introduced in an object introduction. They are introduced with the keyword USE and are given a name. The name must be unique to the whole Mule environment. The name may be either a more normal alpha-numeric name, ie a string of characters commencing with an alphabetic character, or a special name. Special names are composed entirely of what areconventionally "operator" type characters and are intended to allow the provision of enhanced operations, should this be required.The effect of the object introduction is to create an objecttable record and reserve data memory cells for it.In addition to being given a name the object may be given a size attribute which specifies the number of data memory cells theobject will occupy. If the size attribute is omitted 4 memory cells will be reserved for the object.An object may be used without being introduced in which case the object is treated as if it had been introduced at the point of use and is given the default size attribute of 4.Restrictions:An object introduction may not appear within a function stacking operation which is itself nested within a function stacking operation.An object name must be unique to the whole Mule environment.An object cannot be introduced with a size attribute of zero.Only 12 characters are significant in an object name. Any characters above the 12th are ignored.

Examples of use:Valid object introductions are :

USE element character:1 buffer:132.USE char2:elel.Introduces

element which occupies 4 (default) memory cells, character which occupies 1 memory cell, buffer which occupies 132 memory cells.

103


buffer2 which occupies a variable number of memory cells which is dependent upon the value of elel. If the value of elel is 12 when the USE is executed then 12 cells will be reserved.

USE : : < > ( ) : 12.Note the need for syntactic separation between () and :.

Introduces: : which occupies 4 (default) memory cells.<> which occupies 4 (default) memory cells.() which occupies 12 memory cells.

Invalid object introductions are :USE la <abc> abcdefzO &&&.Because

la commences with a digit<abc> mixes special characters and alphabetic

characters.abcdefzO allocates a size attribute of zero.&&&. is a valid special name but the to signify the

end of the introduction would be missing. There must be a space between the last special character and the terminator.

4.1.2 Stacking OperationSyntax :

<stacking operation> ;:=<name> |@ <name> |<constant> |<function call operation> |<function stacking operation>

<constant> ::=<numeric constant> |<character string constant>

<numeric constant> ::=<integer constant> |<decimal constant> |<floating constant>

<integer constant> ::={ <digit> }0:* |H : { <hex digit> }!:* |0: { <octal digit> }1:* |B : { <binary digit> }1:*

104


<hex digit> ::=<digit> |A|B|C|D|E|F

<octal digit> : : =0|1|2|3|4|5|6|7

<binary digit> ::=0|1

<decimal constant> ::={<digit>}!:* . {<digit>}0:*

<floating constant> ::={<digit>}!:* E {<digit>}0:2

<character string constant> ::=" {<letter>I<digit>I<special character>|<line formatting characters>}0 : * "

Semantics :The appearance of a name, a constant or a function stackingoperation will cause a value to be placed upon the stack. Thevalue placed on the stack will depend upon the type of stacking operation and the size attribute of any object being stacked.Objects which are being stacked consecutively maybe separated by commas or line formatting characters. Line formatting characters are spaces, tabulation characters and new line characters.Taking each in turn :

name - the appearance of a name will cause the contents of the memory cells reserved for the object to be copied to the stack. Each cell will be copied in turn and the stack topwill assume the size attribute of the original object. Thecontents of the memory cells allocated to the named object will be unchanged by the stacking operation.@ name - the @ symbol indicates that the address of the first data memory cell of the named object is to be placed on the stack. The stack assumes a default size attribute (ie 4 ) .numeric constant - the numeric constant is placed on the stack and the stack assumes a defult size attribute. Theprecision used for decimal and floating constants is notdefined here.character string constant - the character string is placed on the stack. One memory cell is assigned to each character and the stack assumes a size attribute which is equal to thelength of the character string. The character setrepresentation is ASCII.

105

b U f l W H K H i r U K T A D l L i J . X X

function stacking operation - see section 4.1.4.

Examples of use :element, 123, "Character

String which includesNew line and space characters", H:FFEB3,

<> , :: , ::= , @element, @ <>4.1.3 Function Call Operation

Syntax :<function call operation> ::=

( )

Semantics: , .The function call operation will expect to find a function for it to execute on the top of the stack. The effect of the operation is to execute the function and, once done, continue execution at the next Mule operation following the function call operation.The function will be placed upon the stack by a function stacking operation, or a stacking operation. Functions and the function stacking operations are described in section 4.1.4.

Examples of Use :FUNCTION element, "Element Handler" END ()... causes a function to be placed on the stack (ie all between the FUNCTION and END) and that function to be executed. The execution causes the value of element and the character string "Element Handler" (in turn) to be placed on the stack.

4.1.4 Function Stacking Operation

Syntax :<function stacking operation> ::=

FUNCTION <limited Mule language> END

<limited Mule language> ::={ <object introduction> j <limited stacking operation> |<function call operation> |<limited function stacking operation> |<limited infix stacking operation> |<destacking operation> }0:*

<limited stacking operation> ::=<name> |@ <name> |<constant> |<limited function stacking operation>

<limited infix stacking operation> ::=

106

bUFTWAKE KUKTAblLlTÏ

( <limited expression> <operation><limited expression> )

<limited expression> ::=<limited stacking operation>{<function call operation>}0 : * |<limited infix stacking operation>

<limited function stacking operation> ::=FUNCTION {<limited stacking operation> |<function call operation> |<limited function stacking operation> |<limited infix stacking operation> |<destacking operation>} END

Semantics :A function is a collection of Mule operations bracketed by the keywords FUNCTION and END. The effect of the function stacking operation is to place the address of the start of the function (in program memory) on the stack. The stack then assumes a size attribute of 4 memory cells.The function is called by the application of a function call operation [ie () ]. The result of this is to cause execution of the first operation within the function bracket and to continue from there. When execution meets the function return, execution continues from the operation following the function call which caused the function to be executed.A function (or strictly a function reference) may be assigned to a mule object by a destacking operation, see section 4.1.6.Restrictions :A function may contain within it a nested function stacking operation however, the nested function stacking operation may not contain object introductions. This restriction applies to explicit (ie USE type) and implicit (ie the appearance of an object name) introductions.Examples of use :

FUNCTIONchar

ENDExecution of this function will cause the value of char

to be placed on the stack.FUNCTION FUNCTION char END END... Execution of this function will cause a function reference to be placed on the stack. If this function is then executed then the value of char will be placed on the stack.

107

j. vvra£\i:i f v ^ x \ x x -^j^ j . x j ju

4.1.5 Infix Stacking Operation

Syntax :<infix stacking operation> ::=

( <expression> {<operator> <expression>}0 :1 )

<expression> ::=<name> {<function call operation>}0 : * |@ <name> |<constant> |<function stacking operation>

{<function call operation>}0: * |<infix stacking operation>

<operator> ::=<name>

Semantics:The infix stacking operation is short hand for a function call which takes its parameters from the stack and delivers its result to the stack. For example :

( a + b ) is exactly equivalent to a , b , + ( )

The operator is any name which has been introduced either explicitly or implicitly and which has had a function reference assigned to it.Restrictions :The operator value must be a function reference.

Examples of use :( a+b )(f() AND (a OR b) )( FUNCTION a,b END() TRIADICOPERATION c)( x O )

4.1.6 Destacking Operation

Syntax :<destacking operation> ::=

-> <destacking expression><destacking expression> ::=

<name> |@ <name> |<constant> |<infix stacking operation>

Semantics :The destacking operation causes the value which is currently on the stack to be transfered to the data memory address which is provided as the right hand operand to the destacking operation.

108

bUFTWAKE FUKTAElEiTÏ

The address may be one of :@<name> - in which case the value is assigned to the cells reserved for the object.

memory

<name> - in which case an address is obtained from the value of the object named. The object must be 4 memory cells in size. The first 3 memory cells (cells 0 to 3) provide the address in data memory whilst memory cell 4 provides the size attribute of the object being referenced. An assignment of the form :

@a @bwill create a suitable reference such that cells 0 to 3 of the object "b" will contain the cell address of "a", whilst cell 4 of "b" will contain the value 4 which is the size attribute of "a".<constant> values, except for charac default size attribute of 4 memory ce used as a data memory address must cells 0 to 3 and the size attribute i size is not specified as part of the of numeric constants in this way wi portable. Character strings may be maintained as each character occupie character set is specified.

ter strings, assume the 11s. The constant, if provide the address in n cell 4. As cell bit Mule language the use 11 make programs nonused and portability s a memory cell and the

An <infix stacking operation> which must deliver a value which is an address reference which includes the sizeattribute, as described above.

Restrictions :Except for constant values placed on the stack the size attribute of the stack value must be identical to that of the destack operand.If the stack value is a constant then :

- If the constant has a larger size attribute than thedestack operand then the constant is truncated to the same size as the operand and the higher order memory cells are discarded.- If the constant has a smaller size attribute than thedestack operand then the constant is copied to the lower order memory cells of the operand and the higher order memory cells are left unchanged.

Examples of use :3 -> @a

The value 3 is assigned to the lower 4 memory cells the object "a".

of

109


"The rain in Spain" -> @str... The character string "The rain in Spain" is assigned to the object "str" provided the object has a size attribute of 17 cells.(a+ (b*c) ) -> ( index ARRAY @arrayname )... Assigns the result of (a+ (b*c) ) to an addressevaluated by the expression ( index ARRAY @arrayname )

4.1.7 Built-in FunctionsMule provides a number of built-in functions which are part of the kernel Mule environment. Although they are built-in they are invoked in exactly the same manner as normal Mule functions, by the function call operation [ie ()].

le

The built-in functions expect their arguments to be on the stack and the arguments must be valid for the uses specified. Arguments are removed from the stack by the operation of the function. Results are delivered to the stack.

4.1.7.1 select

inchar

outchar

outint

Input/Output FunctionsHas one argument which is a value which represents an input/output channel. Channels are represented by a number between 0 and 100.The function selects the designated channel and any subsequent input or output is directed to that channel.Has a single argument which is a data memory address. The function reads "n" characters from the currently selected input/output channel and transfers them to data memory at the address specified in its argument. The value of "n" is given by the size attribute of the data memory address of the argument.Has a single argument which is a data memory address. The function copies "n" characters from data memory, at the address specified in its argument, to the currently selected input/output channel. The value "n" is given by the size attribute of the data memory address of the argument.Has a single argument which is the result of an expression involving numeric values. The function expects a value with a size attribute of 4. The function will interpret the lower order 4 cells as strict binary with cell 0 providing the least significant bits and cell 3 providing the most significant. The argument is transferred to the currently selected input/output channel as a decimal representation of the binary value.

110


4.1.7.2 Arithmetic FunctionsArithmetic functions have two arguments which represent numeric values. The functions expect values with size attributes of 4 and either an integer, decimal or floating format. In the case of integer arguments the function will interpret the lower order 4 cells as strict binary with cell 0 providing the least significant bits and cell 3 providing the most significant.In the descriptions which follow the top of the stack is the second argument and the next stack item is the first argument. The function removes both arguments from the stack.

+ The first argument is added to the second argument andthe result is placed on the stack.

- The second argument is subtracted from the firstargument and the result is left on the stack.

* The first argument is multiplied by the second argumentand the result is left on the stack.

/ The first argument is divided by the second argumentand the result left on the stack. In the case of integer division the remainder is discarded and the result truncated to the integer result.The first argument is raised to the power of the second argument and the result left on the stack.

4.7.1.3 Relational FunctionsRelational functions have two arguments. Each argument may be multi-celled and may have dissimilar size attributes. The relational operator compares each memory cell in turn, treating the memory cell as strict binary with cell 0 representing the lower order cell. Where one argument has a greater size attribute the higher order memory cells of the lower size argument are padded with cells of value binary zero until both arguments are of identical size.In the descriptions which follow the top of the stack is the second argument and the next stack item is the first argument. The function removes both arguments from the stack.In the relational functions the first arument is compared with the second. The result is a constant value which is placed on the stack. The constant is either 1 (for a true relationship) or 0 (for a false relationship).The functions are :

111


< Less than> Greater than<= Less than or equal to>= Greater than or equal to

= Equal/= Not equal4.1.7.3 Logical FunctionsLogical functions have two arguments. Each argument may be multi-celled and may have dissimilar size attributes. The logical operation acts upon each memory cell in turn, treating the memory cell as strict binary with cell 0 representing the lower order cell. Where one argument has a greater size attribute the higher order memory cells of the lower size argument are padded with cells of value binary zero until both arguments are of identical size.In the descriptions which follow the top of the stack is the second argument and the next stack item is the first argument.The function removes both arguments from the stack.an d The AND function acts upon each bit of its arguments in

turn such that bit 0 of the first argument is ANDedwith bit 0 of the second argument, and then bit 1, andso on.

OR The OR function acts upon each bit of its arguments inturn such that bit 0 of the first argument is OR'd with bit 0 of the second argument, and then bit 1, and so on.

4.1.7.4 Miscellaneous FunctionsIF The IF function has two arguments which are on the

stack. The second argument is the top stack item which is a function reference. The first argument is the second stack item which is a single celled value which is either 0 or 1. This is typically produced by theaction of a relational or logical function or acombination of the two in an infix operation.The action of the IF function is to call its second argument as a function if the first argument is the value 1. If the value is not 1 no action is taken.In either case the function removes its arguments from the stack.

112


POP The POP function has no arguments. The action of the function is to remove a return address from the function return list. The effect of this is such that at the next function return, execution will return, not to the point of call of the currently executing function, but to the point of call of the function which called the currently executing function.

STACKNAME

COMPILE

SUBSTR

The STACKNAME function has a single argument which is on the top of the stack. The argument is a reference to an introduced object. The result of the function is to place on the stack a character string constant which exactly matches the name of the object, eg

@convoy STACKNAME() will put the character string "convoy" on the stack.The function COMPILE has one a character string constant and i stack. The action of the COMPILE reading from the terminal and tak file which is given by the functi file name format is host machine returns to the user's terminal if the file being read, or the end of

rgument which is a s on the top of the function is to stop

e its input from a on's argument. The dependent. Reading an error is found in file is reached.

The SUBSTR function has 3 arguments as follows :- The 3rd argument is on the top of the stack and is a numeric value which gives the length of a substring.- The 2nd argument is next on the stack and is a numeric value which represents the start position of a substring. The first cell is cell zero.- The first argument is next on reference to an object.

the stack and is a

The action of the function is to obtain a reference to a portion of free space which is between cell 0 and cell-n of the object referenced by the first argument, where n is the size attribute (minus 1) of the object.For example :

USE buffer:20.Gbuffer 3,7 SUBSTR()

will place on the stack a reference to the free space location (^buffer + 3) with a size attribute of 7.

113


VALUE The VALUE function has a single argument which is onthe top of the stack. The argument represents a data memory reference. The function causes the contents of the memory cells referenced to be copied to the stack top.For example :

USE buffer:20."ABC123DEF456GHI789JK" -> ^buffer Gbuffer 3,7 SUBSTR() VALUE()

will result in the character string value "123DEF4" being placed on the stack.

114


4.2 The Pilot ImplementationThe Mule language was implemented in CORAL 66 on an ICL 2966running the George 3 Operating System under DME. Theimplementation was a pilot to test out the basic ideas and had the following restrictions :

- Only upper case characters were permitted (a George 3 restriction).- Memory cells were 6-bits (again a George 3 restriction, 8 bits would have been better).- The size attribute in an object introduction wasrestricted to being a constant value.- Only integer numeric values were implemented.- Only decimal notation integer constants were implemented.- In relational and logical functions the arguments wereassumed to be no greater than 4 memory cells and higher order cells were discarded.- The built in function "SELECT" was not implemented and all input output was directed to channel-0.- The separators "," and ";" were considered to be identical to space and line separator characters and were completely interchangeable. In addition comments were permitted at any place where a separator was permitted. Comments were enclosed in square brackets (ie[...]) and could not contain either open or close square bracket characters.

The pilot implementation will be described in the following sections in terms of : An overview. Lexical phase and theinterpretation phase.4.2.1 OverviewThe Mule Pilot Implementation (Mule-P) relies upon 2 stages, namely the lexical analysis (and syntax checking) phase and the interpretation phase.

Normally control passes to and fro between the phases as Mule-P source code is read. For example suppose a user entered :

( 5 * 3 ) OUTINT()The lexical analysis phase would be called to decide that this was an infix stacking operation and to provide the value 5. The interpretation phase would then be called to cause the value 5 to be placed upon the stack. The lexical analysis phase would then read on and provide the value 3. The interpreter would be called

115


again to cause 3 to be stacked. The lexical analyser would then provide the multiplication function call which the interpreter would execute, and so on.This to and fro operation is the normal mode of the Mule-P and allows fully interactive use with the user, for example, printing the values of objects for debugging should execution cease for any reason.When the lexical analyser meets a function stacking operation it does not allow the interpeter to execute the function immediately but instead stores the body of the function in program memory and only calls the interpreter to stack the function reference.In order for this mechanism to operate the lexical analyser and interpreter must share some common data structures.The first is the linked object table and object string table which provides information about introducd objects.The object table consists of records of the following structure referenced by an object table mark. Each record is identical.

- The size of the object, restricted to a range of 0 to 255. This is represented by the name "OBJ SIZE M".- An index into the object string table, restricted to a range of 0 to 32767. This is represented by the name "OBJ STRING MARK M".- The data memory address of the object. This is represented by the name "OBJ ADDRESS M"

The object string table is a character array represented by the name "OBJECT STRING DG", each element being 6 bits. The object string table is indexed by "OBJ STR MARK M" of the object table.Starting at the index "OBJ STR MARK M" the characters have thefollowing meaning :Character-0 The length of the objects name in characters, eg

the name "CONVOY" has a length of 6.

Character-1 to Character-nThe characters of the objects name.

Character-(n+1) to (n+3)An index into the object table to provide therecord for the object. The least significant bitsare in character-(n+1).

The next data structure is data memory which is an array of 6-bit cells represented by the name "MEMORY DG". The data structure is indexed by "MEM MARK IG".

116


Program memory is represented by the data structure "PROGRAM DG" which is an array of 6-bit cells. Program memory is indexed by the variable "PROG MARK IG". Program memory consists of operator cells and operand cells. Operator cells are executed by the Mule-P interpreter, the value of the operator dictating the operation which is to be performed. Operator cells are structured as follows :

- Bits 4 to 5 represent the operation field which takes on the following values.

0 - denotes that operand cells follow the operator.1 - denotes that no operand cells follow the operator.

- Bits 0 to 3 represent an operation modifier field which is used in conjunction with the operation field to denote the operation which is to be performed, ie :

Operation Operation OperationField Modifier to be performed

Field0 1 Stack a value.0 2 Stack an address.0 3 Stack a literal (non

character stringconstant).

0 4 Stack a characterstring literal(constant).

0 5 Declare an object.1 1 Function call.1 2 A direct branch cau

sing the interpreter to index the program memory at a particular index.

1 3 A Function Return.1 4 A destack.

Operand cells appear immediately following, in program memory, operator cells with operation modifier fields of the value "1". The value provided as an operand will depend upon the preceding operator as follows :

Operator OperandStack a value 3 memory cells interpreted as

strict binary with cell-0 providing the lower order bits and cell-2 providing the higher order bits.

117


Stack an address Stack a literal

Stack a character string literal

The value provided is the index into the Object Table for the object value to be stacked.

ditto.As the only literal value which is implemented is the integer the value of the integer is represented in 3 program memory cells with cell-0 providing the lower order bits and cell-2 providing the higher order bits.

Declare an object

The number of memory ce operand is dependent number of characters character string, ie length. If n is the lestring then n+1 progcells form the operand, memory cell provides the the character string, with 6-bit memory character string is res 64 characters.As stack a value.

11s of the upon the

in the the string ngth of the ram memory The first length of Note that, cells, a tricted to

The last data structure is the interpreter's run-time stack. The interpreter interacts with the stack during stack, destack and operations which take their arguments from the stack, ie the function call and direct branch. The stack is represented by 2 arrays, both indexed by the variable "STACK MARK IG" which, unless in the process of being updated, always references the top stack item. The arrays are "STACK DG" which holds the stackoperand and "STACK TYPE DG". Each element of "STACK DG" is 24-bits, ie 4 memory cells and is interpreted as a binary valueusing 2s complement notation. The meaning of the value of "STACKDG" is dependent upon the value of "STACK TYPE DG", as follows :

STACK TYPE DG0

Meaning

Stack a value

Stack an address

STACK DG

The index into the object table for the object to be stacked. When the object is required its value will be obtained from the data memory address referenced.The index into the object

118


table for the object address to be stacked. When the object is required its data memory address will be obtained from the

data table.Constant The number of elements of

STACK DG used will depend upon the size attribute of the constant. STACKDG[STACK MARK IG] provides the size attribute of the constant. Thecells which make up the constant are stored 4 to each element of STACK DG. Any unused space within an element of STACK DG is discarded.

Address Constant Is stored as a 4-cellconstant.

The Mule-P implementation is modular with CORAL 66 procedures forming the unit of modularity. Each procedure is compiled separately and communicates with other procedures through the data structures described above, through parameters and returned results and through global variables. Global variables are defined in a separate modules as are macros which were used to make changes to the code simpler.In addition variable naming follows a convention with each variable having a 2 letter suffix. The first letter denotes usage and can be one of :

B Boolean having the value "TRUE M" or "FALSEM"

I IntegerK Loop Counterp ProcedureD Data structure (eg array or table)Q Procedure parameterL LabelM Macro

The second letter denotes scope and can be either :L Local to the procedure or block.G Global to the whole program.C Common (declared in a CORAL 66 Common

119


communicator).Execution starts with the call of procedure "LEXIS PG", the lexical analyser.4.2.2 Lexical AnalyserLexical Analysis (and syntax analysis) starts with the procedure "LEXIS PG".4.2.2.1 LEXIS PGLEXIS PG is called repetitively to read Mule-P source code. By calling other procedures it translates the source code into operations and operands which it places sequentially in program memory, PROGRAM DG. The sequence of events is :If there are operations to interpret in PROGRAM DG, ie LEXIS PG is operating in interactive dialogue mode, the procedure INTERPRET PG is called to execute them. The program memory marker PROG MARK IG is reset to its initial value after execution.The procedure FETCH ELEMENT PG is called to fetch an "element" of Mule-P. It returns the element in 2 global variables ELEMENT IG and ELEMENT TYPE IG. The meanings of the various options are as follows :

Value of ELEMENT TYPE IGELE OPERAND M

Value of ELEMENT IG

Index into the data table of the object

ELE LITERAL M

ELE CHAR LIT M

The value of the literal (integers only are allowed)A pointer to the start of the character string which includes the string length as its first character.

Meaning

The element was an object name, eg CONVOY, +, - > and has an entry in the object table.The element was a constant value, eg 32, 123.The element was a character string, eg "A char acter string".

No other element type is permitted and an error message is produced, via the procedure ERRORHANDLER PG, if the element is not one of the above.The error message is :

SYNTAX ERROR - UNKNOWN ELEMENT

120


If the element is an operand the action is dependent upon thevalue of ELEMENT IG, ie the index into the object table. Mule-Psymbols are introduced via LEXIS PG as normal objects duringsystem initialisation. As a result they are given specificobject table indices as follows :

Data Table Index

Mule Symbol

0246810121416182022

USE(FUNCTION- >( )END)

Note that object table indices increase by 2 - this is a function of the way that the object size, object string mark and object address is mapped onto the data table array.If the value of ELEMENT IG is < 19 (and ELEMENT TYPE IG is ELE OPERAND M) the action taken by LEXIS PG is dependent upon the value of ELEMENT IG, as follows :ELEMENT IG=0, ie :

This is a development feature and can be used to signify the end of an element to FETCH ELEMENT PG.

ELEMENT IG=2, ie .The . denotes the end of introductions which is handled by the procedure INTRODUCTION PG. LEXIS PG takes no action and passes control to the exit point - see later.

ELEMENT IG=4, ie USEThe procedure INTRODUCTION PG is called to handle object introductions. Control is then passed to the exit point - see later.

ELEMENT IG=6, ie (The procedure INFIX PG is called to handle the infix operation. Control is then passed to the exit point - see later.

ELEMENT IG=8, ie FUNCTIONThe variable REMAIN IN LEXIS KL is incremented to indicate to the exit point that control is to remain within LEXIS PG until the matching function-end is received. The procedure FUNCTION DEF PG is called to deal with the function

121


definition. Control is then passed to the exit point - see later.

ELEMENT IG=10, ie ->The procedure DESTACK PG is called to handle the destack operation. Control is then passed to the exit point - see later.

ELEMENT IG=12, ie ()The procedure FUNCTION CALL PG is called to handle the function call operation. Control is then passed to the exit point - see later.

ELEMENT IG=14, ie @FETCH ELEMENT IG is called to fetch the next Mule-P element which should be an operand for the @ operator to act upon. The procedure STACK PG is then called to plant the stack address operation in program memory. Control is then passed to the exit point - see later.

ELEMENT IG=16, ie ENDThe variable REMAIN IN LEXIS KL is decremented to counter the increment at the corresponding FUNCTION. The procedure END FUNCTION DEF PG is called to handle the operation. Control is then passed to the exit point - see later.

ELEMENT IG=18, ie )LEXIS PG should never receive a closed bracket as this is handled by INFIX PG. There is a small design error in this part of the procedure as LEXIS PG ignores any closed bracket received, passing control to the exit point. An error message should have been produced.

Any other value of ELEMENT IG, with ELEMENT TYPE IG having the value ELE OPERAND M, represents a user introduced object which is handled by the procedure STACK PG.Similarly elements with ELEMENT TYPE IG of ELE LITERAL M or ELECHARLIT M are handled by the procedure STACK PG.STACK PG causes the appropriate stacking operations, andoperands, to be planted in the program memory for interpretationby INTERPRET PG. Control is then passed to the exit point.The exit point of LEXIS PG performs a check on the value of the variable REMAIN IN LEXIS PG. LEXIS PG will exit only if the value of this variable is 0. LEXIS PG is called recursively from INFIX PG and DESTACK PG and when called for Mule-P operations like :

(FUNCTION (A+ FUNCTION X Y Z() END() ) END() + B) ->( FUNCTION (A<B) FUNCTION @A END FUNCTION @B END IFELSE() )

It is required that LEXIS PG handle the Mule-P between the

122


FUNCTION and END at the same recursion level.

4. 2. 2.2 INTRODUCTION PGThis procedure is called whenever an explicit introduction is met in the Mule-P source, eg USE A:10.The procedure sets the flag IN INTRO BG to TRUE M. This is usedby the procedure FETCH ELEMENT PG to indicate that it has beencalled from within INTRODUCTION PG.Control remains in INTRODUCTION PG until the character isread to indicate the end of an introduction when the procedure returns control to LEXIS PG after first resetting the flag IN INTRO BG to FALSE M.The following sequence is repeated for each object being introduced.An element is obtained from the Mule-P source by calling FETCH ELEMENT PG. If the element obtained is not an operand, ieELEMENT TYPE IG is not equal to ELE OPERAND M, the error handlerprocdure, ERRORHANDLER PG, is called. The error message generated is :

SYNTAX ERROR - UNKNOWN ELEMENTThe operand must be a new name being introduced. The introduction of the object, planting of the declare operation in program memory and creation of the object table record is all performed by the procedure FETCH ELEMENT PG as is necessary when the object is implicitly introduced (ie by using a name). It is FETCH ELEMENT PG which checks for duplicate introductions of the same object name. Allocation of data memory is done dynamically during interpretation.FETCH ELEMENT PG returns the object table index allocated to the introduced object in ELEMENT IG. This is saved in a local variable.FETCH ELEMENT PG is called again to check for a in the caseof :

USE A:12.If the next element is not a control returns to the head ofthe repeated sequence but without reading an element as this has been obtained already.In the case of a being read FETCH ELEMENT PG is called againto read the numeric constant which follows. If a numeric constant is not read ERRORHANDLER PG is called to print the error message :

SYNTAX ERROR - A NUMERIC CONSTANT MUST BE SPECIFIED AS AN ATTRIBUTE OF THE OBJECT INTRODUCTION.

123


When FETCH ELEMENT PG introduced the object it was given a default size attribute of 4 memory cells. This is now updated to the value specified in the actual introduction by updating the field OBJ SIZE M of the object table record.4.2.2.3 INFIX PG

INFIX PG is called at the opening bracket of an infix stacking operation and control remains within INFIX PG until the matching close bracket is received. INFIX PG is called recursively to handle nested infix stacking operations.INFIX PG causes the infix stacking operation to be translated into two stacking operations and a function call, ie (A AND B) is translated into A B AND(). The only complication is that the operands A and B can be very complex involving infix stacking operations, function calls and function stacking operations.INFIX PG operates as follows :The procedure LEXIS PG is called (recursively) to handle thefirst operand. This will cause operations to be planted in theprogram memory which will allow the interpreter to, ultimately, provide the first operand from the stack. Calling LEXIS PG in this way will cater for all possible types of operands and, in the case of an infix stacking operation as the first operand, INFIX PG will be called again, and recursively, from INFIX PG.Having obtained the operand FETCH ELEMENT PG is called to obtain the infix operator (which is a Mule-P object name!). However it is possible that what is obtained is either (or a combination) :

- A function call symbol { () } in the case of ( FUNCTION A B END() TRIADIC B END ), or multiple function call symbols, eg in the case of (FUNCTION A B + END() () AND C).If this is the case the procedure FUNCTION CALL PG is calledto plant the function call operation in the program memoryfor each occurance of the function call symbol. FETCHELEMENT PG is then called to obtain the actual infix operator.- A closed bracket in the case of a single operand, eg (X),or (FN() ). In this case a return from INFIX PG to itscalling procedure is performed.

INFIX PG checks that the operation name is valid, ie that ELEMENT IG = ELE OPERAND M and that the name is not the symbol asthis is invalid.Once the actual infix operator name is obtained it is saved in a local variable.LEXIS PG is called again to obtain the right hand operand. The

124


next element is fetched, by FETCH ELEMENT PG, and identical action taken to that above, in the case of the element being either a function call or closed bracket.Finally STACK PG is called to plant operations in the program memory to allow the interpreter to stack the infix operator name. Then the procedure FUNCTION CALL PG is called to handle theplanting of the function call operator.A closed bracket, ie ), is expected but it is possible that a further infix operation name and associated operand(s) may be obtained, eg (A + B * C - D). In this case INFIX PG repeats the infix operator name and right hand operand handling for each operator/operand.

4. 2. 2.4 FUNCTION DEF PGFUNCTION DEF PG is called whenever the start of a functionstacking operation is encountered in the Mule-P source (ieFUNCTION). The procedure END FUNCTION DEF PG is called to service the corresponding end.The Mule-P implementation restricts the nesting level of function stacking operations to the value of FUNC STC SIZE M. If this is exceeded ERRORHANDLER PG is called to deliver the error message :

NESTED FUNCTION DEPTH EXCEEDEDBoth FUNCTION DEF PG and END FUNCTION DEF PG communicateinformation through an integer array FUNCTION START DG. This is indexed by FUNC NEST DEPTH IG, the current nesting depth, which is incremented by FUNCTION DEF PG and decremented by END FUNCTION DEF PG. FUNCTION START DG is used to hold an index into program memory.FUNCTION DEF PG plants the following in the program memory at the index which is put into FUNCTION START DG.

- Firstly a stack literal "0" operation. This will be changed by END FUNCTION DEF PG to a constant which is the index into program memory of the end of the function.- Secondly a direct jump operation.

The effect of these operations will be to cause the interpreter to branch over the operations of the function until they are called by a function call operation.

4.2.2.5 FUNCTION CALL PGThis procedure is called when a function call operation, ie (), appears in the Mule-P source. It plants a function call operation into program memory and returns.4.2. 2. 6 END FUNCTION DEF PG

125


END FUNCTION DEF PG is called when a function stacking operation end, ie END, is obtained.It is possible that a function end has been entered without a corresponding FUNCTION symbol. If this is the case ERRORHANDLER PG is called to display the error message :

FUNCTION END ENCOUNTERED WITHOUT A FUNCTION BEGINBefore returning END FUNCTION DEF PG does the following ;Plants a function return operation in program memory.Changes the value of the stack literal operation at the function begin to the current program memory index (ie PROG MARK IG) from its initial value of zero.Calls the procedure STACK PG to plant operations in program memory to cause the interpreter to stack the index into program memory of the start of the function.Decrements the value of FUNC NEST DEPTH IG.

126


4.2.3 InterpreterThe lexical analyser, LEXIS PG, calls the interpreter, ie theprocedure INTERPRET PG, whenever there are any operations in theprogram memory for it to interpret. Control remains in the interpreter until it meets a halt-operation within program memory when the interpreter returns control to LEXIS PG. Before returning, INTERPRET PG plants halt instructions in program memory for that portion of the program memory which represents interactive dialogue between the user and Mule-P. This is to prevent the operations from being re-executed by LEXIS PG onreturn.INTERPRET PG controls its execution firstly by using the value of the operation field and then by using the value of the operation modifier. This double switch enables INTERPRET PG to obtain the operation's operand via a central handler rather than obtaining the operand for each operation.In this way control is passed to particular parts of INTERPRET PG dependent upon the operation which is to be performed and inparticular the following sub-routines are provided :

- HaIt.- Stack a value.- Stack an address.- Stack a literal.- Stack a character string literal.- Declare an object.- Function call.- Direct branch.- Function return.- Destack.

Built-in functions (see section 4.1.7) are part of the Mule-P interpreter but are called in the Mule-P source like any otherfunction and the programmer is unaware that the function isbuilt-in. The interpreter recognises a built-in function by its address field (ie OBJ ADDRESS M) of the data table record of thebuilt-in function object being negative. The absolute value ofthis address is the built-in function number which is used by the interpreter. Built-in function numbers are assigned tointroduced objects by a built-in function MAKEBUILTIN which has a preset function number of 1. Suppose we wished to create a built

127


in function name ADD with a function number of 4 (ie the same the "+" function). The function call :

as

ADD,4 MAKEBUILTIN()

Will Srecordbuilt-inumberprocedubuilt-iroutineControlnumber

et the address field (OBJ ADDRESS M) of the data table of the object ADD to -4 signifying that the function is

n (ie the address is negative) and that the function is 4. The function number is used as a parameter to the

res BUILT IN PG which is called by INTERPRET PG whenever a n function is to be called. BUILT IN PG has CORAL 66 s for each of the built-in functions of section 4.1.7.of execution within BUILT IN PG is by using the function

passed as a parameter to the procedure.

Function numbers are as followsFunction FunctionNumber Name

1 MAKEBUILTIN2 INCHAR3 OUTCHAR4 +5 -6 *7 /8 " (exponentiation)9 <10 >11 <=12 > =13 =

14 <>15 AND16 OR17 (unallocated - reserved for exclusive OR)18 IF19 GOTO20 POP21 STACKNAME22 OUTINT23 COMPILE24 SUBSTR25 VALUE

128

bUFTWAKE PUKTABILITY

4.3 Test ProgramsAt the outset of the design of the Mule-P implementation 3 tests were devised ;

- Test A to test the basic operation of introductions and to be operating prior to implementation of any other operation.- Test B to test the infix stacking operation (and relying upon Test A operating successfully).- ACCEPTANCE which tests all of the features of the Mule-P language and introduces 2 mule functions, via the COMPILE built-in function, IFELSE which provides theIF... THEN...ELSE capability and WHILE which provides the WHILE...DO....ENDDO facility.

Mule-P passed all of these tests.4.4 ConclusionsThe Mule-P implementation is compact and operates in approximately 18k words (around 64k bytes) which includes trace code used during debugging. The whole environment was written in CORAL 66 with the interpreter, which is the only part which needs to be resident at all times, being approximately 1000 lines of code (inclusive of comments). The IFELSE and WHILE functions were very easy to produce and showed that the Mule-P environment can be enhanced very easily. A programmer would be unable to tell that the IFELSE and WHILE functions were not part of the Mule-P kernel. Other facilities, eg an editor, could be added in the same manner.For better structure to programs it would be useful to add the concept of mode or type to Mule-P. This could be by, say, the addition of a function TYPE to the built-in repertoire to assign type to an introduced object and CHECK to check for correct use of the type. For example :

USE integerobject, referenceobject.[ Introduces two objects which may be of any type]

integerobject, integer TYPE() referenceobject, reference TYPE()

[ Restricts "integerobject" to be of type "integer" and "referenceobject" to be of type "reference" ]

FUNCTIONUSE pl,p2.integer CHECK() -> @pl integer CHECK() -> @p2 (pi + p2)

END —> @ ++[Introduces a function called "++" which adds two

129

t > u r x w i^ K E j r u n x ^ D X L j x j. X

operands which it finds on the stack but checks that they are "integer" type operands before allowing the operation]

(integerobject ++ 3) -> ^integerobject[is legal as "integerobject" is an integer]

(referenceobject ++ 3) -> ^referenceobject[is illegal as "referenceobject" is a reference]

In order for this type of mechanism to operate successfully it is necessary to bar access to the non-typed versions of the functions, ie + in the above example. This could be achieved by adding access control to Mule. For example if two functions CLOSE and OPEN were added the following would be possible:

+ ++ OPEN()[Open access to the "+" function from the ++function, ie allow the "++" function to call the "+" functon]

+ CLOSE()[Close all other accesses to the "+" function. Nowonly the "++" function can call the "+" function so that to open access again the "++" function would need to contain the OPEN function call]

OPEN CLOSE()[Is lethal and closes all access to the OPEN function]

It is thought that only the above additions are necessary to theMule kernel to make it a truely useful environment fortransporting programs. The syntax of the language would require improving but it was not considered that the syntax was important in proving the concept of the Mule-P implementation.A final improvement would be the implementation of the lexical analyser procedures in Mule and translating them to the Muleoperations in program memory. If this was achieved it would benecessary to transport the interpreter (some 1000 lines) onlywhen moving the Mule environment.

4.5 Mule-P Source CodeThe Appendix contains the Coral 66 source code of the Mule-P implementation, the George 3 command language instructions forcompiling and operating the Mule-P and the Mule-P source code for building the environment and for testing.The following are the files included and their uses :

File Name PurposePCOR(/MACR) The CORAL 66 compilation macro used to invoke

the compiler. It uses another George 3 macro(PINCLUDE) to include CORAL 66 source files

130

bUFTWAKti F U K T A Ü I L j I T Ï

in sequence for the compiler. Compilation ceases if errors are found in a particular source file. This is because the compiler's error handling is very poor.

PINCLUDE(/MACR)

PCON(/MACR)

A George 3 macro used with PCOR to present each CORAL 66 source file in a sequence to the compiler.The linking, or "consolidation" George 3 maco which brings together the compiled Mule source and the standard input/output libraries.

PMULE(/MACR) The George 3 macro which executes the Mule-P.

The following are the Mule-P source files.

HEADERCOMMON

MIDDLE

MACROSVARIABLES

Compiler introduction statements.Declaration of common objects and those which will be used from the standard subroutine library.CORAL 66 required statements between the Common comunicator and the start of the procedure declarations.Macros definitions.Global variable declarations

The following are Mule-P procedures.

TRACEPCERRORHANDLERREADARELCHARFETCHELEMENT

STACKPGFUNCTIONCALLINFIXPGENDFUNCTIONDFUNCTIONDEFPINTRODUCTION

Used for debugging. ERRORHANDLER PG READ A REL CHAR PG FETCH ELEMENT PG

STACK PGFUNCTION CALL PG INFIX PGEND FUNCTION DEF PG FUNCTION DEF PG INTRODUCTION PG

131

POPVALUEPGPOPADDRESSPGPOPINTEGERPGBUILTINPGINTERPRETPGMAPPG

LEXISPGEND


POP VALUE PG POP ADDRESS PG POP INTEGER PG BUILT IN PG INTERPRET PGMAP LIST PG - used for providing a map of memory addresses for each global variable. Used for debugging.

LEXIS PGThe start of executable code and compilation end statements.

The following are Mule-P source files.

LANGSYMB(/MULE)

BUILTINS(/MULE)

TESTA(/MULE) TESTB(/MULE) IFELSE(/MULE) WHILE(/MULE)

Contains a list of the Mule-P symbols and built in routines which area read into the Mule-P at system initialisation.

Contains the calls of MAKEBUILTIN which allocates built in function numbers to the built in functions introduced above. This file is executed immediately following system initialisation.

Mule TEST-A.Mule TEST-B.The if..then...else function.The while function.

ACCEPTANCE(/MULE)The Mule-P acceptance test.

132


5 REFERENCES1 Backus J 1978

Can programming be liberated from the Von Neuman Style. A functional style and its algebra of programs.CACM V21 N8.

2 Lucas P 1970Lauer P Sfigleitner HMethod and notation for the formal definition of programming languages.

3 Brown P J (Ed)Software Portability - An advanced course Publisher - Cambridge University Press

4 HMSOThe Official Definition of Coral 66

5 Warren J C 1976Software Portability - a survey of approaches and problems. 10th IEEE Computer Society International Meeting on Technology to Reach the People.

6 Richards M 1971The portability of the BCPL complier.Software Practice and Experience VI ppl35-146

7 Coleman S S 1974Poole P CWaite W MThe MOBILE programming system JANUS.Software Practice and Experience V4 pp5.

8 Capon P C 1972Wilson I RMorris D Rohl J CThe MUS compiler target language and autocode.Computer Journal Vl5

9 Snyder A et al 1975A portable language for the language C MIT MAC-TR-149

10 Colin A J T et al 1975The translation and interpretation of STAB-12.Software Practice and Experience V5 N2 pp 123-138.

11 Johnston S CA portable compiler - theory and practice.Bell Laboratories, New Jersey.

133


12 Foster C H A 1974Portable compilers and the Uncol problem.Machine Oriented High Level Languages.North Holland Publishing Co, Amsterdam.

13 Poole P C 1971Hierarchical abstract machines.Proceedings of the Culham Symposium on Software Engineering HMSO

14 Poole P C 1970Waite W MBuilding Mobile Software.Computer Journal Vl3 N28

15 Orgas R J 1969Waite W MA base for a mobile programming system.CACM VI2 Nil

16 Brown P J 1972Levels of language for Portable Software.CACM 15.

17 Abrhams P S 1971An APL machine - PhD ThesisReport NB SLAC 114 Stamford California

18 McCracken D D 1973Revolution in Programming Datamation December 1973.

19 Dijkstra E W 1972The Humble ProgrammerCACM VI5 NlO 1972 pp 859-866

20 Newey M C 1972Poole P CWaite W MAbstract machine modelling to produce portable software. Software Practice and Experience V2 pp 107-136.

21 Dunn R C 1973SNOBOL 4 as a language for bootstrapping a compiler.Sigplan Notices V8 pp28-32

22 Steel T B 1961The first version of Uncol.Procs IFIPS WJCC V19.

23 L Star - An interactive, symbolic implementation system. CMU Pittsburgh.NTIS AD-A050 119/7GA

134


24 Foster C H A 1974Portable Compilers & the Uncol Problem.Machine Oriented Higher Level Languages.North Holland Publishing Company, Amsterdam.

25 Taylor J R 1977A compiler interpreter for a LISP dialect.Research Establishment RISO Report; Denmark.

26 Brown P J 1976Throw away compiling.Software Practice and Experience.

27 Wilcox T R 1971Generating Machine Code for High Level Programming Languages .

28 Bauer F L 1975"(Editor)Lecture notes in Computer Science 30 : Software Engineeringand Advanced Course.

29 Ammann U 1977On Code Generation in a Pascal compiler.Software Practice and Experience V7 N3 pp391-423

30 Lecharm 0 et al 1974A (Truely) Usable & Portable Compiler Writing System.Information Processing 74, pp218-221North Holland Publishing Company, Amsterdam.

31 Miller P L 1971Automatic Creation of a Code Generator from a Machine Description.Project MAC TR-85 (May 1971)

32 Lauer P E 1977Abstract Tree Processors with netwoeks of state machines as control - their use in programming language definition. Colloquium on Trees in Algebra and in Programming, 5-7 Feb1976, pp96-128 (Lille - France).

33 1978Computer Software - Transferability & Portability; Bibliography with Abstracts.NTIS PS-78 00552 6GA

34 The Structure of Directly Executed Languages - A New Theory of Interpretive System Design.Stamford University California - Digital Systems Lab.NTIS AD-A051 835 7GA

35 Lecrame 0 1973An Experience in Structured Programming and Transferability.

135


ACM Sigplan Notices V8 N9 Sep 73 pp956.36 Cheriton Et al 1978

Thoth, A Portable Real Time Operating System.

37 Allen JThe anatomy of Lisp.Publisher - McGraw Hill.

38 Chevance R J 1977Design of High Level Language Oriented Processors.Sigplan Notices Vl2 Nil, pp40-51

39 Chung L L 1977Elements of Discrete Mathematics.

40 Wilson R J 1972Introduction to Graph Theory.Publisher - New York Academic Press.

41 McCarthy Et Al 1965Lisp 1.5 Programmers Manual MIT Press

42 Akin D C 1978Allen B CSimulation of the Direct Execution of Higher Order Languages NTIS AD-A055 235 6GA

136


APPENDIXThe Appendix contains the Coral 66 source code of the Mule-P implementation, the George 3 command language instructions for compiling and operating the Mule-P and the Mule-P source code for building the environment and for testing.The following are the files included and their uses :

File Name PCOR(/MACR)

PurposeThe CORAL 66 compilation macro used to invoke the compiler. It uses another George 3 macro (PINCLUDE) to include CORAL 66 source files in sequence for the compiler. Compilation ceases if errors are found in a particular source file. This is because the compiler's error handling is very poor.

PINCLUDE(/MACR)

PCON(/MACR)

A George 3 macro used with PCOR to present each CORAL 66 source file in a sequence to the compiler.The linking, or "consolidation" George 3 maco which brings together the compiled Mule source and the standard input/output libraries.

PMULE(/MACR) The George 3 macro which executes the Mule-P. The following are the Mule-P source files.HEADERCOMMON

MIDDLE

Compiler introduction statements.Declaration of common objects and those which will be used from the standard subroutine library.CORAL 66 required statements between the Common comunicator and the start of the procedure declarations.

MACROS Macros definitions.VARIABLES Global variable declarationsThe following are Mule-P procedures.TRACEPC Used for debugging.ERRORHANDLER ERRORHANDLER PG

137

READARELCHARFETCHELEMENTSTACKPGFUNCTIONCALL

INFIXPGENDFUNCTIONDFUNCTIONDEFPINTRODUCTIONPOPVALUEPGPOPADDRESSPGPOPINTEGERPGBUILTINPGINTERPRETPGMAPPG

LEXISPGEND


READ A REL CHAR PG FETCH ELEMENT PG STACK PGFUNCTION CALL PG INFIX PGEND FUNCTION DEF PG FUNCTION DEF PG INTRODUCTION PG POP VALUE PG POP ADDRESS PG POP INTEGER PG BUILT IN PG INTERPRET PGMAP LIST PG - used for providing a map of memory addresses for each global variable. Used for debugging.LEXIS PGThe start of executable code and compilation end statements.

The following are Mule-P source files. LANGSYMB(/MULE)

Contains a list of the Mule-P symbols and built in routines which area read into the Mule-P at system initialisation.

BUILTINS(/MULE)

TESTA(/MULE) TESTB(/MULE)

Contains the calls of MAKEBUILTIN which allocates built in function numbers to the built in functions introduced above. This file is executed immediately following system initialisation.Mule TEST-A.Mule TEST-B.

IFELSE(/MULE) The if..then...else function.

138


WHILE(/MULE) The while function.

ACCEPTANCE(/MULE)The Mule-P acceptance test.

139

>!»*»m

■ n X T a3 Z CTC o o X -4 X

o c o m % XX m r* M -J i~ t*>c * n X t-i\ I— t~i r~o r*i 7 m3C X w.

I- C r

X z EX X >o l-c C O

e % C C rr. X m rr.

x x x x x x x x x x x x x x x x x x x x * »Z Z Z Z Z Z 2 Z Z Z Z Z Z Z Z Z Z Z Z Z r > < T r > o o r > r > r » r > o o r > r > f T O o r > o r > o »r-f-i-i-i-i-r-r-f-ri-r-i-i-i-i-i-i-ri-i-c c c c c c c c c c c c c c c c c c c c xO C C O C O C C C O C O t O O O C ï C O O C - m m r r m m m f n m f T ' . r r f n r r n i m r n f T i m i T i m f T i

- n m î> c X X % X3 X % % O X I - » > Ci X % *»

M CDr c X X X c c c c m*-i »- < - Iz c ï» »• - i o f - o mxc^ o m m X r r « n X oX tf> c > % X X % Xc. c. X ï>» % 3»X X > >

z c r z -r z cr -n X r> X c - I c X c 1-4 Z Xc o r» Cin z — I % — I c M X►4 rr c > c -n z z X cC i » -*»% X X X > o

c -< z s» r> n -4«-4 Xe Ci z > n X

X rr, - i < s z om X X > » X c> X > X o c 30 C - r > *-i X c s> X rii X o 1“ OX z X ( E c/i m zm X r > f“ X % »f - z % m X X Xr i o X e n > > »1 r X %X m X

I X X XI X XC i C i \ ; X X

' X X

X X X X mr- M «n (A z z» (T » *f r- r- O X c X Xc c c N m % »z X 3rr X c X c rX t

X " 4

Xc X

l*t tso O r~ »ri C 9c - 4 O I • H3 X - « 0 4m C »

X O f r o - 4 cc- 4 « n —4

r - r s 1-4 z C D 0 4o »X o œc z r i 3 1— - 4

O X 0 4• • « - - 4 3 X O iC M m C - 4 X- 4 a r r X X XM * X X Xf X 4-1 T O . | - »1-4 X ^ m TV) m fsl ff- 4 o f i X Œ le -4•<0 3 3 «e O .• X C ri »X X I - 3 Xo 3 rr -4o r i Z O .X C) \ —( - 4 »X o r i X X| - X r r f - r i - 4O X C i X c 04o o X »1 3 c 1 X0 4 C 0 4 - 4TV) r - c O .o i m *

X 3 X» X X - 4

O i r i 0 43 X »XX - 4

r X X 0 4o X »o XO

O I Z c 0 4»m r r Xc o oo X 0 4X c o »

C i m00 - 4TVI 0 4

»X X- 4 r r - 4

o 0 400 »O XO I X 0 4* - - 4 »

X* - - 4< 1 <o 0 4

»c 0 4 XO ) $- - 4

0 4z O I »C i TV) X

Of0 4 »00 X- 4

»m- 404»O- 4O f»

M»09- 40 4»O- 40 4»OD

»»»»s»*. >f

—) ru m Co. <3 a O- o.i\i-*C'CX*>J0'O<*'0irvj-» -4 X» -4 c. —4X en en X enen w o J» r*> X en X Oi-i "O X 3 X X O C z enf- > X r* X c »Oi M 3 4- X» Z X < X c » ¥* X m » <4 > Z X » > r~ -4X C c t f~ N N X c r X Oi-4 —1 X r *--\i -4 X en »O. X- c m o c % fV c K Z -4 le X

X o 1 » en X *» Ci N -4O T~ m en K- 1 en—1r V N Oi

1 •< *4 r\jX X c r- *Oi r K X m le X» m. c 4Tr K rvi m NX c X C X 4-4 le Oi

en Vf X ru o- z le »04 -4 ■V ■ ISi le X» X c 3 le -4X r X X C Z O.-4 m X m N *O. m X r" X X» » z «r -4X -4 «3 C o x> OiX X »04 O 1 r- X

w»s- 4Oi»mL n»œw » X — i O i »

»X - i

• O i ' » X • H O i » X -4 O i »

»- 4 r u mW •C X ■ei » 04 PC ■ o X ■ M o * ' O i 4VI»X m t n e r m y » » » » » C l- 4 r~ X X cn c If » r 1 - ZO i V »» 3 X r u X » c n «1 » X X m 3X C 3 N » r* c X O X-4 X C X r m XOi |- c o 3 w to o» r~ C Vi -4 2X c i~ V: cn rr.- 4 m m «n V X UlOi X tr c c r c* c K X X r- X 3X X X 3 » X 2 »

-4 ♦ > X X O04 X c 3» c > XX X » X X-4 X » n CiOi X r* c 3» 3 m X mX r X (—o Gi

4*» »r »

Xcn -4-4 04

»X

O -4Oi

c »X-404»X

40 -4N O.re »4*4 X40 -44*4 044**i »1*4 X4*4

04»X Xo -4o Oiz »

XO! -4

Of3 »

XCi -4X 04

»X-4

X 04X »o Xo -4c 04r» »m Xc -4

04o »z X-404

X »> XX -4

04X »

X

J* 04-< »

X-4

O i 04»o X-404»

X X

»CD-*Ot»to- iw»w- *w»CD-4M»mw»mw»w

L L

»»

X XX oX o

tf> o-4XX m m X en M m enX — I

>1»S- 4 0 4 0 4 0 4 r o T\4 IVJ r o r u r o IN4 r o r o l o »o > P O C C a - e o- v r f 0 4 r o c ■ o » - 0 O' O I $• 0 4 r o X» Xœ v > 3 X X - * X m X -o r r X m m X r - rr 0 4

- 4 X v> X z 3 M X X z X z z X X o c X c »O i o f - - 4 z m C D» X o rr » - k r o » z - 4 » X X * » * X Z r - - 4X X m r- X c X X œ C O X X r n X O - 4 œ X 0 4

X X X X 3 X 4 0 »0 4 r j - 4 o c o c X X C l e X» 3 3 1“ C X _ 3 » * K 3 r - 4X - 4 1 1 X X X K » -4 X t - - 4 X X X rr. O i- 4 C z ► 4 *» X f - l e »O i s X o ■ X c - o m t e œ» Si c X X X X X c » < c l e - 4X r r < n X C > c > C 3 l e 0 4- 4 r i r X r r » z X X X X > »0 4 o « T o > f ~ 3 X » 3 r > C» r - 4 c X • < M c o c X O C X l e - 4X z r o c c T - o r - Z O i- 4 X 4 - X c o * r r r r - 4 »0 4 m m 3 c % - 4 c r - œ r X X» - X X C X X S > c » m 3 - 4X c X | - X o z X X C O -o > r * f n 3 * r * X X 3» X r - »0 4 m > C 1“ - 4 X c 1 r r 0 3• » 1 c r * X 3 - 4X m X m z z z C N 0 4

v> y 4 X X r - »0 4 c X m 3 X» ; X r - X - 4X ' t r -4 X X 0 4- 4 • O m 3 X »0 4 > X S» 3 X » - 4X » X m X r * X X 0 4- 4 X > o o X »m X X 4 0 C 0 3> O O t ? - 4X 90 3 r Z C 0 4m o X »0 4 X - 4 - » 0 3

w»00HW»w

M»X04»m

04 tv z

* m r r X X» > Z X cX c r- »>X - l-i 3

r » - 4 3 - 3 C Cf - r~

04»mO i»m

r fr** P S > 1O f - *c m- 4 X - 4X - 4 0 4C- t C

OOC 0 4

o »Œ

r* — <O »

X »- 4 l e X

l e o >r l e »m l e X

l et e 0 4z l e »l e XZ L s

- 4 »4“ X X

mO i

n »1 m m

X — 4c 0 4*X XX - 4X 043 »

X- 4 - 4Z X 0 4

X »c ŒC D - 4Z C 0 4

CiX

O> 0 4c o »o z 0 0o cr o 0 4

o s »» > œ- 4 X - 4

X 0 4o c *

O X- 4

04 > 0 4-sJ -4 »X-4O» 0 4 0 4»C O XX - 4

0 4z »e> O* X

O i0 4 »OB X

»o-404»W-404»O C

>1»

**üiPu-»c.'Oa-eooif'oifoX X X M X X X z c O c -4

C C C X mmrpfnrriipmrrrr —

X X X X X XX X X Xc c o o c on o o o o or r fT*. rr. m m rr.o X c o c cC C C = C C

— Xz X jH C

X c

X X «T X X o c o 30 0 3m rr O c c z c c -X X

en en X z rr rr X tr I - r - «-» z rr rr z r- o o ■e x -r -r o z X c. X rr z c X %.

X —

< « ?> > C

- - ZX X Xz z rr X X o

en X t c X X X o ». X X rn o z X es rr X rr c en X X X- <• X - ■c. » X» 1“ X Xr- C - m z rr c »- X z XX z m » z X - Xrr JT X rr< tr zm X X

C s o >es Te z enX Xrr » - o

X mC3 —

r rO rs M,o o I- »o c mc X en X3 X X 04rr z *z X z ZX oX 04X o »OI- Xo 04o en le »3 X N Œ3 X XC le uZ N »rr N cN Xen N Oi2 te *X . ccle o.X »|- aC3 Oi3 »1 O O)z XC 04»en ZX X043 »SXX 1*4X »o œO es XZ z 04o »m œo* 04c o *o z 00oe Xru ru 04c *œX > Xz 04OB *c ru CDXvn > 04N X »mru X•e 04

»*- (Sen o 04z »en Wl O0404 »OB 00X04»œ04»m04»CDX04»CD

>i o rs rs »» o o r - »» c X» c X cn Xo 3 X X 04X m c »o. rv) -» c X X» C l9 X 04X X X X c »04 z m X» X o c r XCE o Z 04X Cl z X c/iO. rr, - c X l e X» X 3 c N9 r~ l e 04X r r r - l e »04 Te 3 rn N X» r r C l eS r r r~ re o .X X m z l e »04 l e X» NIœ c Z o.

X »04 X i~ 3 X»03 r~ > 04

r r Te »04 t r~ X» XX en C. 04X Z ro »04 m X c* r r X Xœ X cr> 04X 3 »04 X»X X X 04

X »O i o m» CX Z c 04X 4»O I X» » Xos J» 0 4o *04 O z m» otX rvj 04X o c »04 X» X XŒ X 040 0 »04 o X»X Wl » ' 04O c X »04 X» XX ao 0 4 0 4X »0 4 c c X» M Wl XX *-t 0 4

Z r o »04 Cl e l œ» Xœ 0 4X 0 4 »04 a X» X

OF * Z Z Z Z Z Z Z Z Z Z Z Y4. M A C R0S ( 52/) P R O D U C E D O N 30J U L 82 AT 15. 50.23 Y L 15T F 1L E IN • | T L F A K - 1U . R P S K I T H ' ON 16A U G 82 AT 10,59.35 U S I N G 1381

macR0S(S2/)

define» ELE LITERAL M"0" : define* ELE OPERAND M"1" S DEFINE* TA PnOC F"0" ;DEFINE* EXIT M"«GOTO* EXIT LI" i DEFINE* ICHAK M"READCHAP" :DEFINE* NEW LINE M"-1" ;DEFINE* FALSE M"U" ;DEFINE* RELAVANT M(Q)"UOl6 'AND* «0-1 "AND* 0<>28 'AND* Q011 'AND* 0<>• LITERAL*(t)" S DEFINE* TRUE M"1" ;DEFINE* REPEAT M(U)"*GOTO* 0" !DEFINE* BACK STEP «"BACKSPACE" i DEFINE* NAME length M"62" :DEFINE* ALPHABETIC M(Q)"û>»*LlTERAL*<A) «AND* 0<»* LITERAL'(Z)" :DEFINE* NUMERIC H(0)"«>»*LI TERAL*(0) 'AND* a<** LITERAL*(9>" }DEFINE* INC M(@1,Q2)"01:#Q1+02" }DEFINE * NON ALPHANUMERIC H(C)"Q>«10 'AND* 0<«32" Î DEFINE* RETURN M"*GOTO* RETURN LI" :DEFINE* EMPTY M"63" : -i •DEFINE* DEFAULT OBJ SIZE M"A" i DEFINE* BYTE 2 M(9)"*BITS*C6,12JO" Î DEFINE* BYTE 1 M(W)"*B1TS*C6/6J0" ;DEFINE* BYTE (J M (0 ) " * BITS * C6# ÜJO" ;DEFINE* OBJ TABLE SIZE «"1000" !DEFINE* OBJ STR SIZE M"10000" S DEFINE* PROG SIZE M"10000" ;DEFINE* RAT DECLARE M"5" tDEFINE* OBJ SIZE M"ibITS*C8,16J0BJ TAB DG" :DEFINE* OBJ STR MARK M"*PITS*C16/0J0BJ TAB DG" S DEFINE* OSEL M(0)"SELECT OUT(Q)" ;DEFINE* OKaPF M"1" ;DEFINE* PTRACE M(91,Q2) "TRACE PC(01,B2)";DEFINE* ONL H "NEWLINE" ;DEFINE* OSP M(fi) "SPACES(O)" ;DEFINE* OTEXT M(0) "WRITETEXT(0)" : define* OINT M((l) "PRINT(Q)";'DEFINE* ICh M "READ CHAR";DEFINE* OCH M(Q) "PRINTCH(Q)"I 'DEFINE* RAT COLON M "0";'DEFINE* RAT DOT M "2";'DEFINE* ISEL M(Q) "SELECT IN(Q>";'DEFINE* IINITF H "1";'DEFINE* STOP CHAR M "*LITERAL'(Î>";'DEFINE* RAT END 'DEFINE* RAT BRANCH M"18";'DEFINE* RAT ST VAL «"1"; . ! ;'DEFINE* RAT ST ADD M"2"; " ''DEFINE* RAT ST LIT M"3";'DEFINE* RAT AT K"14"; |•DEFINE* RAT CRD M"18"; ;'DEFINE* RAT ORD CRD M "12";'DEFINE* RAT FN CALL M"17";'DEFINE* VAL HELD M"0";'DEFINE * ADDR HELD M"1";'define* lit HELD M"2";'DEFINE* MEM SIZE M "10U0U";'DEFINE* FUwC STC SIZE M "25";'DEFINE * STACK SIZE M "200";* COMMENT * I It * * U K * * * * * * * * * * * * * * * * * * * * *THIS MACRO HAD TO BE COMMENTED OUT N MADE INTO A PROCEDURE BECAUSE OF THE INABILITY OF THE COMPILER TO HANDLE IT - SEE PROCEDURE TRACE PC 'DEFINE* UPSTACK M "STACK MARK IG :■ STACK MARK IG+1;

*IF * STACK MARK 1G>STACK SIZE M 'THEN*'begin*ERROR HANDLER PG<6,""RUNXTIMFIERROR"") ;•END*";

END OF COMMENTED OUT SECTIONA*******************************************#*****************#*********);'DEFINE* RAT DESTACK M"20";'DEFINE* RAT FN RET M "19";'DEFINE* ELE CHAR LIT M "2";'DEFINE* CHAR LIT 1 DELIMITER M "18";'DEFINE* CHAR LIT 2 DELIMITER M "23";•define* Char lit LENGTH M "63";•define* rat ST CHAR LIT M "4";'DEFINE * ISEL N(û) "SELECTIN(O)";•define* if tty M "U";•define* if COMPILE M "1";•define* MULE MESSAGE M (01,92) "DISPLAY(92);'CODE"BEGIN* SUSWT('LIT'(91))•END'";HT3*BT3*HT3*BT3»iPT3*BT3*BT3*BT3*PT3*eT3*BT3*BT3*BT3*BT3ABT3*BT3*BT3*BT3*BT3*BT3*BT3*BT3*BT3*BT3*BT3*BT3*BT3*l

W » U l » » »-» 2 O X -e

o o X r» c c z o .-r m X 3 X X m 3

i l m o s m z

t- »3> vn '

C c 3 Z 3 O X X

c c z z o o

» w w X L wO C X X ■ >!/> O - «

> «- ZX M z e n 3 » t nn z 3 » 3 <n

X X X » V. Mr> 2 en X m X » 3 > X O r > » X X o X

I X X, m c X

X J) X . Œ 3

O X • • O

» c X o X > ^ c - X

z z X V » o z c X

o z N i

m 3 C z e n M

X e n 3 X X

X X eu no X o -C X

< n -3 X 1 » 3 U Z (—1 X Zc z »— e n X 3Z 3O e n o l~!

1

t \ j e U ' U f U r U ! U l U < U x x x x x x x x x x- e O ' X f ' X i u x - o x ~ o > x . N x y ) x c c X - e 3 x f -

« X «-> r »Z O Om 3 3

X o NI 3

X e n o X

3X e n

X v> Ni X

mI 3 X 3

3 e nX X% z ,

O NI3 m 3m 3 z XX »

z v i x o z x x x z - n : ' z r “ H i — oe z x z x x c - i X O O e n z i » » * » ' ^ , —3 NI » 3 Z » » Z Z % 3 X X X Z31TIXZ o r j z O c . m z bX z 3 X X X - en z c X m

o x z > n x z o z x o ® ï » z f ” - r z e z z x z z z m c i * o x z x »

o x x c i » m m e n 3 z z v*o - n X Z x z x z z x z r - xx o î X 3 X m z m o z » » xX C l 3 e n » x o z x o x z z z zm % %» % z x x o r n x o m z j — x m m r t z - x f i i o o z - ^ o x m î»x - x o % % X = x x o

r> o X - 3 I 0 - Z X 3 0 0 * »X C X 3 0 - O » r " o m O » % % 0 3 0 3 % O C X X C O % z% 3 % m z 3 X o 3 3 X X

m Z - 3 3 % » 3 0 - - C i- z « x o 3 f n x - r m % r » x r » o

e - » x m « o m z o f i Z o e r o 3 c - o 3 z X % o < 1 X « 3 % 3 3 3 3 X 3 X - 3 3 - e n 3 3 m3 X 3 Z m - - 3 0 o m m zx f - r r m z x o m z z s z - Z xZ » Z X X I 0 Z X 0 3 X O X -x o x s - o m s x m x m - O -

- o z 3 - Z Z Z 3 X vt 3 X Z m X X X 3 % : z

z m x o z x f - z x I m « x m x m X X z X m X » X z z m z mN I m X 3 « n - m o x x z r m X z m m e n x z Z - m x

- H 0 3 C x e n m z m c z o z » z e n X z X x 3 z c m- r » » z x o m » o O f ” Œ z m

z z x x » x > » m m zz » m x o e m z x z z ( m z z » C m x r > z 3 x x x r > m z x m z 3 ■ n z x % « m » o x o O m lm X m 3 Z O Z C O Z X Z mz z z T i » x z m r ’ z z m o zm o o z » e n r ’ » o x zZ O Z Z ^ X 3 X X 3 « n Z » Xr * o c f * m z X m » z X z m r » x x z m 3 Z X 3 0 o m 0 _o x z x % « m o o m c m x ; X m c X 3 3 z c X z0 3 » z z o r “ » o m 3 Z z mz z X z m < z m x« - 3 e n m X < O x r » e n o x mm e n z X ^m m z m zX z Xc fi» zz z o o

3 m

z 3 ( - o z »m z o < n X 9 ^ z o » m z X z z e n X C C O O z Z z c r » z

X X z Z O Xs» z cX o e nX z X

Z z z X z XX o

(- * m r-r - fi» 3 m m m » o o e n X 0 0 9

X c _ mo o r » zX 3 X fi» Z XX X » m X

z Œ » z

1*1 r s > 1O O f“ »

c X 3c X 3 X3 z X 0 4i Z *

i N n o - » O X zX fi»

3 e xz f- J- X o *

Xm 3 3 z r *

< (j4» z z fi» e n »< X X m z X Xo X X - e xX X e n X f“ *z % I - 3

mX e n e xz *z fi» f ) l U 3z % o » Xm 3 O.o 3 X »

- m 1 - X3 r » Zfi» o X z e x% 3 - »3 1 3

s X- Z Z r* ex

m *z en 3

3 f” z X3 X m rw I Xm X 3 3 3 »z m m TX z X X- X X z ( X

X »» z o X

m z OZ Z ex1-0 3 »

» z C o Xfi» r* » X

m m c I Xc r- c f» »fi» m s

X 3 3 Xl U I Xz z o »

X » z XX X

e n z I Xm f - *

e n > o 3 3X W l Z I X

M 3 »X f W 3o W l

• O » I XX X »z c Sc to Xm • U I Xz »

fi) o s» X

I X» w *z 3 ( U 3

XI X

z »z 3mr- I Xm

w»9XW»zXw»e s

esw»3XW»*>

LT vn V ï LT

ro

Vf

rC c

c % c

ro c Wl cO' c

c c ru c c % c rw % o » œ %c

»»Xtx»9XIX»9

I L L L L'

3*flT3»BT3*BT3*BT3*HT3*BT3*BT3*bT3*BT3*BT3*8T3*BT3*BT3*BT3*0T3ABT3*BT3*BT3*BT3*BT3*BT3*BT3*BT3*BT3*BT3*8T3*BT OF ZZZZZZZZZZZZN.VARIABLES(28/) PRODUCED ON 4MAR82 AT 17,04,12

GY LISTFILE IN ';TLFAK-10.RPSMITH' ON 16AUG82 AT 10,53,59 USING 1381 VARIa8L6S(28/)

'INTEGER'ELEMENT IG, 'COMMENT' AN ELEMENT OF MULE fELEMENT TYPE IG, 'COMMENT' THE TYPE OF ELEMENT READ iIHRELAVAWT SKIPPED BG/ 'COMMENT' A FLAG WHICH IS SET TO TRUE IF AN IRRELEVANT CHARACTER WAS READ DURING THE LAST READ;CURRENT LINE IG, 'COMMENT* THE LINE NUMBER IN THE FILE BEING READ;OBJ TAP Mark IG, 'COMMENT* WHERE WE ARE UP TO IN THE OBJECT TABLE SMAX OBJ TABLE MARK IG, 'COMMENT* WHERE WE ARE UPTO (MAXIMUM) IN THE OBJECT TABLE;TA PPOC PRINT IG, 'COMMENT* THE NUMBER OF TRACE MESSAGES OUTPUT ;LATEST PROCEDURE IG, 'COMMENT* THE LAST PROCEDURE CALLED ;PROG MARK IG, 'COMMENT* POINTER INTO PROGRAM MEMORY;KG, 'COMMENT* GLOBAL COUNTER - USE CAREFULLY TO AVOID CONCURRENT USE:FUNC NEST DEPTH IG,'COMMENT* THE STATIC NESTING LEVEL OF FUNCTION DEFINITIONS)RUN TIME PROG M A R K IG, 'COMMENT* THE PROGRAM MEMORY MARKER DURING INTERPRETATION)START H E R E IG,'COMMENT* TmE PLACE TO START THE INTERPRETATION)STACK NARK IG, 'COMMENT* RUN TI' E STACK MARKER)FUNC STC MARK IG, 'COMMENT* THE RUN TIME FUNCTION STACK MARKER)MEM MARK IG,'COMMENT* THE MQMORY MARKER)CHAR BUFF mark IG, 'COMMENT* THE CHARACTER BUFFER MARKER )IN INTRO BG, 'COMMENT* FLAG SET IF AN INTRODUCTION IS BEING PROCESSED)SIZE OF OBJECT IG, 'COMMENT* SIZE OF REFERENCED OBJECT RETURNED FROM "POPADDRESS PG" )DUMMY

'COMMENT* PRESET )' CO MMENT*•INTEGER*:»; ;•BYTE* ' AR RA Y* ,OBJECT STRING OGCO:OBJ STR SIZE M], = ‘ ;PROGRAM DGC0:PR0G SIZE M], 'COMMENT* PROGRAM MEMORY )STACK TYPE DGCUrSTACK SIZE M],MEMORY dGCO:MEMSIZE M],CHARACTER BUFFER OGCO;12UJ, 'COMMENT' THE CHARACTERS INPUT BUFFER FOR THE CURRENT LINE)0UMMYAC0:1J

ARRAY* 'COMMENT* THE OBJECT TABLE )'INTEGER * 'ARRAY*OBJ TAB DGtUlOBJ TABLE SIZE MSTACK DGLUrSTACK SIZE M3,FUNC MEMORY OGCO; FUNC STC SIZFUNC STACK DGCO;FUNC STC SIZEFUNC NAME OGCOrFUNC STC SIZEFUNCTION START DGCO:FUNC STCDUMMYIA[U;1]

•c o m m e n t * p r e s e t ;' I NT EG ER * 'ARRAY*POWER OF 10 DGC0:6J ,POWER OF 2 DGCOtlSJ,DUflMYPIACOrU!*1,10,100,1000,1oüOü,inüOüo,ionoüOo,1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,0; ......

rBT3*8T3*BT3*HT3*RT3*8r3*BI3*BT3*BT3*BT3*BT3*BT3ABT3*BT3*BT3*BT3*BT3*BT3ABT3*BT3*BT3*BT3*BT3*BT3*BT3*BT3*BT3<

ING OF :ZZZZZZZZZZZN.TRACEPC(18/) PRODUCED ON 29JUL82 AT 17.04.26 UT BY LISTFILE IH ':TLFAK-10.RPSMITH• ON 16AU682 AT 10.58.51 USING 1381 lENT TRACEPC<18/)

Ü 'PROCEDURE' DUMMY PCI 'BEGIN' 'END' DUMMY:123 'PROCEDURE' TRACE PC ('VALUE' 'INTEGER' TRACE CODE Q, TRACE STRING Q ):4 'BEGIN*56 'COMMENT' TRACE PROCEDURE SWITCHED BY 'ON' OPERATIONS,IE7 ON 23 PROCEDURE TRACE8 ON 22 VALUE PRINT TRACE9 ON 21 STRING PRINT TRACE10 'IF' TRACE CODE Q=TA PROC M 'THEN' LATEST PROCEDURE IG :■ TRACE STRING Q!

11 1213 'IF' CURRENT LINE IG<C29J14 'THEN' RETURN m;1516 'IF' ([30] 'MASK' POWER OF 2 DGCTRACE CODE Q]) 'DIFFER' POWER OF 2 D6CTRACE C0DEQ]"017 'THEN'18 'BEGIN'19 'SWITCH* SELECT TRACE SL ;*PROC LL,20 VAL PRINT LL/21 STRING LIST LL:22 'GOTO' SELECT TRACE SLCTRACE CODE Q+1];2324 PROC LL:2526 'IF' TA PROC PRINT IG>727 'THEN'28 'BEGIN'29 TA PROC PRINT IG :* 0: !30 ONL m;31 'END';32 OSP M(l); ;33 OTEXT M(TRACE STRING U);34 INC M(TA PROC PRINT 16,1);35 EXIT M;3637 VAL PRINT LL:3839 'IF' TA PROC PRINT IG > 440 'THEN' ONL MI41 OTEXT M("£VALUEXIN%");42 OTEXT M(LATEST PROCEDURE IG);43 OSP M(1);44 OINT M(TRACE STRING Q);45 OCH M(TRACE STRING Q):46 TA PROC PRINT IG :» 10;47 EXIT m;4849 STRING LIST LL:50 ONL M;51 OTEXT MC'fSTRINGXiNX");52 OTEXT M(LATEST PROCEDURE IG);53 OSP M(1);54 OTEXT M(TRACE STRING Q); _ _ __________55 TA PROC PRINT IG :■ 10>.56 EXIT M;5758 EXIT LL:59 'END'; . ^ .6061 RETURN LL:62 'END'TRACE PC;636465 'COMMENT' THIS PROCEDURE SHOULD BE A MACRO BUT THE COMPILER COULDN'T66 HANDLE IT:676869 'PROCEDURE' UPSTACK M:70 'BEGIN'71 INC M(STACK MARK IG,1);7273 'If STACK MARK IG>STACK SIZE M74 'THEN' ERROR HANDLER PG(6,"STACK%0VERFL0W");75 'END';BT3*BT3*BT3*BT3*BT3*BT3*BT3*9T3*8T3*8T3*BT3*8T3*BT3*BT3*BT3*BT3*BT3aBT3*BT3*BT3*BT3aBT3*BT3*BT3*BT3*BT3*8T3<

TING OF iZZZZZZZZZZZN.ERRORHANOLERdSZ) PRODUCED ON 24MAR82 AT 19.40.32 PUT BY LISTFILE IN » :TLFAK-10.RPSMITH* ON 16AUG82 AT 11.04.09 USING 1381 MENT ERRORHANDLERdS/)

012 'PROCEDURE* ERROR HANDLER PGCVALUE' ' INTEGER' ERROR SEVERITY Q,ERROR STRING Q)l4 'COMMENT*5 PURPOSE6 OUTPUT ERROR MESSAGES TO THE USER IN THE FORMAT I7 ERROR NUMBERCFIRST PARAMETER),SPACE,ERROR STRIN6(SECON0 PARAMETER)8 MACROS9 OCH M10 OINT M11 ONL M12 OTEXT M13 OSP M14 ISEL M15 IF TTY M16 GLOBAL VARIABLES17 CHARACTER BUFFER OG (R)18 CHAR BUFF MARK IG (R)19 RESTART LC (E)20 LOCAL VARIABLES21 KL (LOOP COUNTER)22 METHOD23 1. THE ERROR SEVERITY CAN BE W (WARNING), E (ERROR) OR R(RUN TIME ERROR)24 2. ACTION IS TAKEN APPROPRIATE TO THE SEVERITY25 3. W - message GIVEN26 E - MESSAGE GIVEN 8 COMPILATION STOPPED27 R - MESSAGE GIVEN & EXECUTION STOPPED28 ; :29 I30 'BEGIN'31 'INTEGER* KL: . , .32 ONL m; ! '33 '34 'COMMENT' THE ACTION HERE IS DEPENDENT UPON THE SEVERITY OF THE ERROR:353637 'IF' ERROR SEVERITY Q ■ 'LITERAL'(W)38 'OR' ERROR SEVERITY Q ■ 'LITERAL'(E)39 'THEN'40 'BEGIN'4142 'COMMENT' A COMPILE TIME MESSAGE - PRINT THE CURRENT LINE BEING PROCESSED:4344 OTEXT MC'LINEX");45 OINT M(CURRENT LINE 16);46 OSP M(1);4748 'FOR' KL ;■ 0 'STEP' 1 'UNTIL' CHAR BUFF MARK IG+149 'DO' OCH M(CHARACTER BUFFER DGCKL3);50 OTEXT M("X— X");51 OTEXT M(ERROR STRING Q);5253 'IF' ERROR SEVERITY Q « 'LITERAL*(E)54 'THEN' __55 'BEGIN* ' '56 ISEL M(IF tty M);57 'GOTO' RESTART LC i58 'END';59 'END' .. , .60 'ELSE'61 'BEGIN'62 OTEXT MdRUNXTIMEXERROR”);63 OSP M(1);0TEXT M("%— %"):64 OTEXT M(ERROR STRING Q);65 ONL M;66 'GOTO' RESTART LC:67 RUN TIME PROG MARK IG %" PROG SIZE M ; (TEMPORARY MEASURE)68 'END';69 ONL m;70 'END'ERROR HANDLER PG:

r*BT3*BT3*BT3*BT3A8T3*eT3*BT3ABT3*BT3*BT3ABT3*BT3*BT3*BT3*BT3ABT3*BT3ABT3*BT3*BT3*BT3*BT3*BT3ABT3*BT3ABT3*BT3

w wV. IV)

wwrvtvrvnj-virvrvMiviM-»- -&3'OXN9'V!f'W(\)-*=: o x

m

X - < > H 1-1» JO Z 2(~ o m » m ff>< m » 2 » z •-» -4 » r>

crt X 7Ï TJ >M X XX o X r> i-im i-

X : o *

-V o- VI f' w rj -» -4•• ■ • • • t z x cnox>-4i-ii-t»-^omx

z X cn3 r-3 -< M

Z Cz X r>

1-1 i> -» G X -n X X X

z c r> mm m M M X-4 X > XX r~

*H »-• > »(» (A m gj —4

X |- Xf < cn I- J» > S»< z X <z > z-4-4 0-4

<A 4-4 X -4 z m o o X3 »

X Z C X m z r- c |—

X Oo X X » X o » f -

1-4 X 4-13 (A <-»

< m r- 3 33 » - I

G O OX X cX X X » m

X o z

►4 O

> < < J> 0 Xz *-«

X I- 3 X Z> c m

(A X XO ^ X 4-4X m m» 4-4 XI» o x

-4 X CX ^

X 3 XI— X -4 m > » X o-4 03: m 4-, <74

4-4 X z X X 4-4 X 4-4 c «A m (A -4 I- (A< m -4 -4 » -4 Xz c m -4 -4 X > O Z 3 «Am X

7^0 »

4-4 (AX

J»4-4!A4-iXZr»-4X x s A ^ x m m x x x m i-i X o £1 Ï» 4-1 o(Axmmi— x(A(A

z m X r 4-1 4-1 3» X (A-4mx»<zox m o < m m -4 Xo x » o !A m oO o z • X o

-4 < —40* (A mt o s m I» m • o

X X o c -4 cX X X (A o X X:m c X > m\ m mX m X X (A o |—3 - » C > X14-43X0-4 3 < mz : X X X 3 » » :j>« i - i m m > z o

X X X 4H » o X3 X O « A Z Z X Xc (A c m o > mr~ X m X m x x z o c A x x «A z o o m o z

O m 3 C 3 X X03 z c z X m cc - m x z x o x x m m X X m O <Ao o m m X r «aX m X o %» Xo o m o z X Xz o I (A m m» (S o X » »

3 m I X X » 3m o » z » » r“cA J» r~ o r~ J>% C X X z zcA X X m m o o

m m r" m X c01X o X X X X m

3 X z o z » XX X 3 X m o XcA m X X 03 X Xm r~ X X m o m zX X X X (A

X <r m «A X X <A3 X P- X Z X Oz X X o X m z

x x < m x o c r *<A X X m X X Xo z 3 3 m

IV X X m X «A 3X X z X X

Z X (A Z X3 O X

o r-

XX m CA o

«A < % X

o r s f S > 4o o f“ » 1 8 b mo c sc X C A X3 X X 0 4m *IV X 3 z 30 1 XX 04

X o 1403

X r - Xm 04<3 »m X OSX N X B m B

«V 04f“ |S4 * B m Mm m r v X

X r * XX o N 04 ■o z rv »o r v

t vz 04X *

X i~ X 'm X g g g

0 4*

1 XXo m 04

|—X o XX r X Rf-aCA 043 * f t ' - #m 03

r~ XI 0 0 04 f t ' ' ^o J*' ■

Z 00X O XX z X 04

X » ■X o 00 IfeiM0 1 3 > o X

c 04 W ^ mC o0 1 m 0 9 f t ^ lCO o X # ' ' ar v 04 E ' g

o * ' %z X I f 3X X

rv 04 A04 * ‘ A03Xo z 04rv 00 »

XIV X» X 04

X *c mCA X

•o 04z »01 o CDo X ■ ]0404 IV *SO a 03

X04 "*4

04»04»

0 4»(B

04»orXo.»0004»o rX04

04»WX04»CDX04»00X04»mX04

-»-4-*czc = ccc: = c •<0'0'C'0'0'0'C'C'0'COcOCOcOcOc.OcOOODO:OcXXXXXXX“>4-v->40 O-O-O'O'O-O'O'O^O V. OlUlWiVT 'Ca->a3vn*'Wivxc<os-vo-oi 'u:ru-»c.'C3:xo vr.PO.rj-*3>caxcvi3-ui(\i-»C'Caxo'-n

■D Z X »• z m c o -

<n . X

tt rr m r - z XX z

O X «X 2 X »• o X

m X X X 2

« C5 c zGC-4 • "> m 2 3m z X o r~o o m

m m </i m c (T c X X -4 mX z z r z r C m 3 > m X os>m m > > CO X > XX X < X c o m c X >

3E > > c > X r CO X XOD X z r> •H z Œ > a T) C QDc -4 X V) H r r X CO X > ^ C Œ

c X r a o cX f" > 3 X c o # >X X z r -0 23 m a O 3> z X X X o -4 G » 3

X z X 1- > > a X X Z O X >m TTf X r* > m CO m A Xf- c w X CO -H o 7

c n X > X Wz r* Œ r- X 3 X m z > <r>ir . a m CO -4 X % O

3 4 3 rr. -c#a

z"4o X> 05 w C » # a

1 3 > C mz 1Xc

o f o -4z Xm m m c

3 c X r c cX r» CO

X zrr > œ m c oz » c X*4 iM c z

1” r m X a mCOm >Z A COc z CO

X r X

m X> CA cz o X

XXXo > >XXXm >X X f* C X XI - Z X

e

-4 Z » = C 3

% N O VI f-

Z 03 C O r>

2 o t- e- G

(A V*I- (A -4 I-, m -4 XI IV«n Ti 3 -4 >3X 3 X7 «3 C

3 w

IM (V•C' C' U 04 -* X -O X04 04 Lm 04 Oi -4 > VA «- W4V4 04 04 f\) IV C >o iMivivrvrv-*-»-»-*-»-*-»-*

I 04 (V -* X CX->4>VA* ' - 04I V

i KomcAOTiTJ 3 m m > i ~ x f ” - 4 » » x > r ' r ' «A > m w r " O O x m m Z4>v:03iv en o 3 3

(— m z c x x c m m < -iO *-Z (n 3 » 3 > > 3 Z 2 4- o I- -c X3 3«---1 -4

X f* » X (A J>

«-* »Z G SI -4

X X -4 » X mo > X

3 0-4-4 4-4*» ffi » -< c;X X X

X 4-4 o o o X X Xs: X c. c_

X f- o -4 » -4 >O < r

-n > VI 4“Z -4 m

-» -4 X o 4-4 3 (A Z » O SI X

l~ oc X z Gm m -4 -4

» » X

Z z-4 m (A (AO X -4

O G X-4 3X4-4X > Zm 3 X s»C > o r- r* oX m -V m

3

C 4-4V» <n

X oG X SI 4-1

.X m SI’ Nv o Gc G a X

SI

1-4 -n cZ C X z «-z r>- 4 z -4X m c tA —I

-4 > X XSI o r— XX -4 o w X SI

O -4 -4 4-4 ZŒ X X Z >

I- 3 m4-4 z c -*

< Z *» f“ % » - 4 3 m »X X m z4-1 c —I O

X C C Xr* G -4 ï» mm -4 o z X(A 4-4 3 Z

O > O > z - 4 X 3

S? X

G C

m CA 3 m

z m S>C X (A

» XO V

r* -4

o oc c

CA X O

,0 1-4 Ix X

z-4 SII

CA Z -4

X X X oo o G c

c o

o m m» cr CACA m c o

o -4 G -4 0 0 X Z m o <A X m -4 z » m o z r- -4 -4

3 «ïm » » z r~-4 G c SA O mX CA » m -4 z X %» o X z m -4 3 CA m m < r- z 5» m-4 4-3 c m : m z2 • -4

, 3 -4

X X Gm X O -40 3 1 C G XX m I- »z o mm z -4 G o X m O m r rIV V. |-z X m-4 m z G O CA c -4-4 3 4 V-4 X m O X 4V X z m G IV

m m o H r- z 3 X m o > m 3 z I- m l

3 Z » < C -4 G » G CA X X m I4V X »

I I m

m XG > -4 03O -4Z IV

GO-n G

Z > C X 3 %»X -4

G -nX O

Z c Ç» -ci X VA ^

X -c G

«A -4 O > -4 X C m m T i Z X X 3 3 X 0 1—0 3 t— 3 G CA CA m G IV X -4 m z o z » X X - 4 G i> X 3 > X C -4 I> Z O z m G CA G CA c —4 G m% m > o

X X -4 o o -< «A IV XX z m

m E SIG IV X IVX -4 IV ►« «A> X G -4 X m X X

G » Z «A -4 -4 X -4 X m » m O O X X zCA c SI - CA

G X m IV O » o G X m -4 C m G

IV X 3 mz o z -n

O —4 Om I V m I V » o IV G IV CA X

tv CA z CA G G c ■ n X Z -SI -4 m - 4 m -44 » •V X

« n : s m z » m m S I - 4 z X

o m X O O m X » -n »

< I V G m o CAm m G Z o> ( A m X G -< z - 4 » 3 > vG 3 IV z - 4 m 3 C Z

« A m G -4 o »O m z o m z G m CA CA m

-4 - 4 z X 1 X G • • - 4Z CA > z X

- 4 ; i v - 4 G c » 3 m - 4 m mS ' OS»» 3 3 m S I X Gm ; Z G m m z m m 3CA : - 4 o X - 4 - 4 CA 3 C

m z «A z IV X G m GG I CA G - 4 » I 2 mm - 4 O - 4 -< G »■ —4

G z » G O X m X C A I VG I G Z I X m % » z

» IV ^ - 4 » a G » XZ -4 IV w (A X z z - 4 X c

m «A » c r n m m m — 43 X c G G 3 G c Xm » V> X Z -4 m m G G CA

G m M O m X 3 IV S I o -4V G V X IV m z X 3 X

3 z m ( A G z m o Œ m: - 4 - 4 * v c I V »

o » - 4 G % X Z 3X z z - 4 CA »

-4 m M » -C G -4X CA X O » IVm »

G- 4mXCA

m 3 X o CA 3 m z

» CA CA

OO O G »

c a- 4 CA - 4

3 X - 4 0 4*

Z XS I

ra 04-< O *

œG -4

04m CA rv »-4 - 4 N XG rvX 04m G »G m Xm3 04m z »

C 3rv -4z 04

04 *O G Z

m - 4» -4 04

G *1 X

m - 4C G 04

*X 3 aX m VCA z 0 43 - 4 »

a- 4 0 4 — 4X O 0 4

»a

O - 4Z X 0 4

X *o a

» - 4c 0 4

c »S I aO B - 4rv W

o »» z a- 4 - 4

0 4X »

aX - 4

O X 0 4rv o» »

IX a- 4

-O 0 4- 4 »

c aCA - 4

0 4Z »S I rv a

0 40 4

0 4 0 4 »0 » VA a

I

04»co0 4»X

04»0 4»X- 404»m

■ V 'JJ f 0 4 IV) - V 3 -O * - 4 '«nO 3 3 3 0-0-0

- » 3 O X - Vo o o o o o o x> IX. C' 04 t\J — 3 -C

■X 0000 -4

1 X X * X X -4 N V — c X

-4 —4 -4 -V--V4 —4-yO-^^O-^O-O- - 4 O - v T ♦ 0 4 ( \ ) - * 3 C X - 4 O - v n f - O '

O ' O ' O - v n VJl V41 v n X - 4 O'

o* • 3

3

2 zO I V G G X

It m MC G 3 a m I X » IV ®

MO IGG X- 4 r n

- 4 V - »3 IV •• OG O MO »X 3 O> G X XIV I X GG >w IV O

3 -4 tv IV Vm X z 2 3z > - 4 - I -

m mX 2 X X

» o -X » a » X X X X c IV »

o G - <3 72 % G m: » G

- n X m m » 3 V w i m o X z X - 4G G O m % G ï trt G

-V O

IV oz XS I *

X fi) V

G X

1 04I V ( A m X o Z G O o o m » c/» X m o m o

G c/i G t» > m» z G (A X O X z 3 m G X G 72 o 3 3m Z 3 3 Z 3 m

S) o I m 3G G E z X G3 3 G z 3 G •O » 3 0m G Œ » m>» X G G X mm m X G G

G W m O in z 3 J» 3 m C G O m m c G G G G 3 G m </) m GG G 3m O O m O

0 3 3 Z XX < «- G G ^

G O G X Om Z 3 G Xc 3 G c o »^ m » G X Xz 3 m »

G G G G Ow* m m WJ GG z m

: X G < X XX m z G mm o X > «AG o m o o G3 3 X z XX <- 2 G GZ m G m «A 3m o «A z filo G G G I: : X rr• G X G m G(A m m » G. G z G mG c G m Xz X X o »G z G G X m »o o m (A z o = X X C • G » G O CA Om G G SX o G CA z

» G» G G 2 CAZ G Z m o SXG CA X »G m G OCA z G3 0 G

O G X G CA a c_ X <- m m s m o X o G z m

3 m X G 3 X» z o X z

X m G33»03mmZGOa » X o X z m C o G

G m » »» » G< z G

G O m > 3 G

3 »O

Z G Gm G G X (A2 Xr r O O r n Z3 X X G m

» » o

I G G »I m XI X o G• XG X c X » X

m z < oms» c X 3 X G Gm Gz o

z G o o o oo 3 m X C G 2 o o

OCA > X G G G G X ma X m z G G G » oX 3 a » X C A m G G G X Go » X 3 m _ »fil z o o G o 3X G o G »

a oc e_ fi)

C A C A G G X r v

o s3 G

3G 3

G G G G

-V r j

3 3

» G C C G X G Z G 2

Z O X X G2 o a X om fi)' CA aI fi)

z o o G fi) m m m 2G G G X X G G >

G G

m 2 o G

X X X m CA.

Z X» o »

m X-r O G a

» Z 2 0 C A G G X

» oG G

O OZ o G 2 » 2Z Z

G ZX fi)

a G0X0; X X o 2 »G (A CA

m z m G

: » z X 2 mm CA : CA GG a » 3 a fi)

X 3 Xm e »G G oC m Gz G X CA z CAaG c « X G C

GCA

X 3 O - m X aX G G X » » G 2 X X < m 2 m » » X m G o z 2 o »G G G G Cm z » »X o » G z

< 2 m » • %G » o

CA O

m - » z -fi) a G (A TVa T i GG o a G a

o X G m C Am > mX 9 2

O G X X » G m C A■n X » • z o 9

m o e xG G G 3 mX m z o »m X fi) — 9

L

2 C

I

m m

s 00 s A o. -o oc> f' f • N > U 1f- f- f 04 I

3 - C■> 2 G

C

m CBm o o zo M n i • • 3 ^ X m m m «" % r " - 4 • m r * f“ r * mz « H m m m z o oz X X X 9 « «

Z m r r fTi • ^ - 4 Wz z z z % . X - n X -ti3 3 ' H « 4 - 4 r n • m •3 Z Z m

• ^r * O - < r * X 1 "*0 m w » m Vw m o z X X m % 9

<-i z■ ■ w , t >

M #-# X Xo »

- * r * n% X XM C m r - im - 4 < n o *• r > ■ X r -o 1 K c X> 1-4

> r - J3 z Z -4»H m 1 X m^ r * - A m c r - p -o m » # z Xm z - 4 1 - X z

OX O r - z X - 4m ^ > X w m m Xm X # zr " » m z - X% m f > f n mX w m M

D n t H oC » z m %^ s X ^ X

C fX r - - fr- c Mm W Z

w g1 A «Vr* oo m X V)z z »m X> Hr* X m z- 4 S)m

M m( n nc - 4X X 2mZm mMf“X- 4 r “o mz X» »X r*Mi "(A

O M X -nG Z

(A CA G G X X

Z z

r G

r » r >I X

o 9 G G

m mX X

f" w V . I M L A L N iN L 4 w U4N sT w r u -4 c.

O cz 3 « «• wz 2 Œ m r rm m G 3en z 2 fil (A cH

X

Om O

C r >r*z o O

>m X mX f

mo H zr- mz

m •4■ X y )

- 4o XX

Z »X ZX r

f o( A X-4 mX X

>Z f - HA Or*H -4m - <

Xm

n z

- z G G G »• O m I -n2 m - 3 rr z

G z « G^ G X G -X ^ C fil m - * G c G'• TV O <

G • > G Z •• w Ga c

G CA

X G» G a X G a

:

I

# %>

fSi • à - A • A « A ^> f' w L 4 V a L 4 0 4 o , L m 0 4 0 4 A ) O J f U p j f\i Ci O 3 o 43 o •c ' O 4 3 'O ' C •O c C X X X

— 'X o C n (>J - ' O 3 0 N a U : ^ O # r u - A c C 3 0 N o V ? fNJ - * c C 0 0 * > 4 < > v n ^ O 4 r u - * c O X - y O ' v n f- 'V4 * V 3 <3 X N o ■C- L 4 P J — 3 c X ' N• .

o r » mc O o O O oX 2 f " 2 2 3 m% 3 - 4 2 X m 2 œ - 4 Z fm m Z O m m m X m mz z z • m X J) o m C i m 2H m - 4 X - 4 H f - m X C7 r - r - H

z • m e n z m m c O m z ZH T X C7 m Ci 2 M C m z

H X o H 4 Z X m f m a 2 n - 4z X m C C O O z O z z z m m am o X n 3 X f“ H 'X Œ - 4 2 X - 4 m e n 3 - 4 | -m X X X f - fît 2 m f " r * m - 4z z m Z m m - 4 z w m o z - 4 m Xo X > (7) m X o a - < - 4 C i 2 o H O P "m 3 z f- m H 2 z - 4 m en X a m 2 1 m e nX </9 m m m c O - 4 m •• z Z 2m X r * e n e n 2 C H C i X a - 4 m m e n a> m # M r " m e n X X f” r * O Z - 4- 4 (/) 2 X X n Z m o 1 3 O z o - 4 >n m c c X m a * f " 3 1 C i f -2 z o n 3 m H 1o H X q X e n O a m C z >■ • 4 (— 2 n - 4

4 - 4 o X X m X 4 Z- 4 f“ 5 ^ o m r r * 2 O mX m X m m m m r - r * - 4 - 4</) m X f H z e n X z m X S»

X z r * c m - 4 r * - 4 O mm w X e n - 4 f X Z Xr * c X X z ■< X e n o r > >

X O f— m A f" m - 4 Ci r - X X • <X ♦ 2 V m - 4 - 4 X 4* > >«r- m X f - O X V z X X «z 4» z O O r - O - 4 > mo > o - 4 X X -4 < n C C o r > <—2 m f " X A X e n 2 X H mm V - 4 m m 2O r i A z z X Xr o - 4 a m o m m o z e n z- 4 - 4 i— 2 r > C i r * - 4X </) o m 2 < f m X o m</) - < - 4 X 2 H > X e n X X z oH X m r -; m e n c o m C i f "X - 4 m z < = ‘ > > ; • 4 H - 4 •X Z m H 2 m X o C X XZ m â > - 4 - < C i X m

o Z 1 c z O e nz e n > - f m mo m o - H 2 n o m r * r e n< n X X m c m m -4 m- 4 X X e n c 2 2 X - 4X r- Z < n X m X m m m> Z ♦ o H m m z z Cc/» X O z X - 4 - 4 m XX 2 » o X H n m nfî» u% o m r * z O m e n

X n o > f - 2 Cr“ X -4w » z X s O Z Xr- e n z o m z - 4X > 1

m o 2 X »n CD m r* Zf- m e n : O

X m »

t w w wt O' V)

w 04 M Ot MG - A ^ _ k 3W fO G 3 ,004 04 04 04 04 04 W

a •S O' VA ^ 04 M

04 04rv(\jrui\)rjN(UM O C ' O ' O ' C ' O ' O ' O ' O o Gcoa O'vnt'Otro ■C • O Q c 3 o o o x o o a o o a o c a ' \ j - > 4 - v - v - V ' > 4 - v - j - ' 4 - v o o o o O ' 0 ' 0 o - o o w i v n v n m o i v i v A t G3'0'3o-40iJlf'04(VG3.0iX'>40U!»0*IV»GO,CX-40'At'O.IVG3'0 3C'*4 0\A«''v.;

r t0 03 33 3m m

X z z G aG G X m m

G • m z r tX G 0 G 0m » Z z 3 X X X

z 0 0 C rr c- CA t-1 9 - a X X1 3 0 G X V) 10 fi)

z 0 a X3 0 X TV c G >v N1 » 0 c e- G G G m1 en <n m r t 31 X G G G G X > 3G ■ X m a

: G CA m G A 3« G en o » A

fi) G % z X m 3 X1 m Z X a TV ' » G a» G » M G 3 m G 3 01 m r t z X: 3 JK as en >> m rt 0 G CA) z > G 9 « 0 0: G z 0 a> c G » X »

G G X G Z C. X1 a G X G X G• G m X » G m G ft)1 Gl G m en m Z »0 G X « 0 9 X 3

w m 0 X m G-» 0 G TV X m a

a G G A1 G m r t . 3: G a r t TV A G z1 (A G G ■ G a fi)1 G 0 A

G •« m Z» » ■ G G G ■

00 m 0 X XG m 3 m 9m G m G m

m z X 0 ■1 3 Gm

m XX C

z 9 en » Gz G G G r t en GG a G X0 9 O 0

G W z M G X1 04 GA

X Ga

G *-

X G G CAG » z GG X fi) Z Gm G 9 m

ien m G

» G 3X X X

G m

'

G m

caG

rtGG

2 m 3000C G 3a 9 Z o • G

a oCA «-

z o G G

C G a XG t~> z O

CA » (A G G G CCA G a Z X» X 3 G G m GG a I Z rtG G m fi) XG G m

m G O m

z z CA 9

G IZfi) G

XG G» enXG Cm G

GG GO

3 - 3» rt z0 Z 0 c c z i3 3 3 9 3 3 G3 G I m 3 3 ' am X m CA m 0m z > z X G Z za G G G G m c0 - m G z rtC Z - » fi) CA9 G m X It) Xm » m G z G G rt G G m G *• G >X a 0 X G X X z - C. X marnaX m - G m 0 m Z m 3 X 3 1> z a G X z z rt X z

CA m X X - CA A 0 Z G Z G iX z m c 0 a z G G G G 3 g'-m G CA z » G X CA X ♦ m aiZ a G z a X G r\j G «• G Sifi) a z G G z a m » G z G G a ■0 G a CA G 0 z X X c G a ». oi3 a a 0 a a ft) z m 0 a m V X 0 im 0 9 z 0 CA 0 G X X 0 a > aG X c 0 9 X G G X 3 G a mX » X rt G c x> m C z m fi) 0 X a 10 z Ci rt z 9 a CA 9 fi) m » '9 Z » m a en G m G G M G z ;G ■ X z 9 G a a G X m A a m G 9 !X ttl X m G 3 » X c c a V Ia a » G G a X G G X m G + 3en z z z G G a G 0a G G X a G G rt fi)» m a X ». 1z X fi) 0 a > fi)fi) m m X G G C- !0 X 0 X G 9 a rt X ta 0 amG «- 9 z - V C ' G X G it) a G rtG 3 m c m G G Z » X m z G !X rt rt en G 0 a r t a itt a G 3 a am G G G G G G X ft) » tam m G G z X a z 9 Gz a 0 9 a X 0 !T) 9 a a> Z X » G Z 3 m G Z G G• a G a G en ftt z 9 3 X Z; 0 C - Z X G G > a* z G G m c ta 9: z c It) rt m en en en Z It) Z a’ c G ■G G G G GG G % G G z a m G Z 1» 0 X Z 0 0 3 G » 1G ' G z It) fi) G 9 ft) CG am 2 • * C X c Z » X \9 G 9 r t 9 A , rt G 0a It) m » m Z ft) G i» 0 a ta a 0 9 » Gen m G C X fi) 0 Wc z G I Z a AG rt a V -*• Gfît G G ft) a 0 GG en z < » m0 0 G c. !» Z C z Z 0 mZ M 3 0 X c 9 rt9 0 a G m ta 0 Gz z G G ta iG >« V rt G G îX » G iti 3 3 am Z X 0a M ft) G z

srf' v / J J J ; J J J

»»a 04040404040404 04 04 04 04 04 04 04 04 04 04 04 04 04 04 04 04 04 04 04 04 0404040404040404!G f» f» f- p- » 04 04 04 04 04 04 04 04 04 0410 r\4 to ro »o (O ro G _‘M 04 l\4 G 3 O œ 9 O) 04 ru G o 'O * -J 9 vn 9 04 ru G o lO X N 9 VA 9 04 ro G o ot

TS - aG m m rt rtW z G O o O* O c 3 3 3X m 3 3 3G -n z z m m mW m 9 z m z z» G G m G G G GX rt G zG z •• ir m G X X X X O.Oi Z » G G O Z G G Z a a a X X"* »• I a -n Z O X X rt C O o c GX G 9 3 3 c m - a a a a a» m;G z 3 z 3 a a a a z rtW 3 - z 3 Z Z tn - X » » G Gl» m » » 3 G » G G G G G m a X 3 3 3 3X z m a x Z Z O X G m o a rt aG G a X M 9 > G G m a a o 9 9 9 9 o G;W a O G G G a 3 C a a a a a a 9 a>* X O G a O a G G a O X o 3 G GlX a a G «- a G X G G a 3 X X X X z iG ♦ Z m ■ m G a » a a a G a04 X INI G a z G X I A a O o o o o* » » G a 3 o rt m A a aX Z V X » G rt 9 X G Z G 9 a iG 9 G X » X G a 9 a 3 3 3 304 G O m G ■ a G m G a > rt i ;* m G rt C o G m V a a a a G »X a «- 3 z X C a 9 A A A » aG > 3 G «- o G a X a X :04 a a a m m z X a m» a G A O m G 3 a o a G:X G a A a G O » c ^ a 4- ♦ G G»G a Z » 04 (U X ♦!04 G « a O a m G G G a m foi» a < G ■ 04;a G M V m G m G G ■ O tG IV a G z 3 a m m ■ ■ a04 a o 9 » o X «- ■’♦ » 3 X G G a 1 » 3 G m X G mX G «- o Z 3 A G G G rt XG C rt G t» m G G 9 G G04 • G a X m m m G G* • m » o m a m a m o rt ma 1 w a ■n 3 a -» fO G

w ; * m»saHM»•aGW#00

G z I G

O z

a a

z r~

a

zoX

3 »G 3 3 a

» 3 3 A » » 3

Oa O O «- a aa > »G a a

a » »A a a

A A

a a G G w a

3iG|31

SI

a:g ;itif3

a i

»aw»aGM»aGW»aw»a

J •J

3 * H I rJ*BT3*BTi*BT3*BT3*BTJ*HIIJ»BIIa«BIJWBIO^Bf.3ttBT3*BT3*BT3*BT3*BT3*BTIJ»BIJWBIo»BIj"o i a"0i j«o iT I N G OF : Z Z Z Z Z Z Z Z Z Z Z N . S T A C K P G ( 8 / > P R O D U C E D ON 2 0 J A N 8 2 AT 1 9 . 0 3 . 5 1 P U T BY L I S T F I L E IN 'I T L F A K - I O . R P S M I T H ' ON 1 6 A U G 8 2 AT 1 0 . 5 9 . 5 7 USING 1381 MENT STACKPG(8/)

012 'PROCEDURE' STACK PGCVALUE' 'INTEGER' OPERAND TYPE 0);34 'COMMENT'5 PURPOSE6 TO PLANT CODE TO STACK THE OPERAND HELD IN "ELEMENT IG".7 PARAMETERS8 operand TYPE Q (THIS IS THE VALUE OF THE INSTRUCTION TO BE USED IN THE9 STACK OPERATION OF THE MULE MACHINE)10 GLOBAL variables11 ELEMENT IG (R)12 PROG MARK IG (RW)13 MACROS14 INC M15 BYTEO M •'16 BYTE1 M17 BYTE2 M18 LOCAL VARIABLES19 LOOP END IL (LOOP CONTROL VARIABLE)20 PROCEDURES CALLED21 ERROR HANDLER PG22 messages PRODUCED23 3 NOR PROGRAM SPACE LEFT24 method25 1, THE STACK INSTRUCTION IS PUT INTO PROGRAM MEMORY26 2. THE OPERAND IS PUT INTO MEMORY27 3. MEMORY IS CHECKED FOR OVERFLOW !28 ; I2930 'BEGIN* .31 'INTEGER' KL,LOOP END IL) - * ;32 PROGRAM DGCPROG MARK IG 3 :■ OPERAND TYPE 9:3334 'IF' OPERAND TYPE Q < 435 'THEN'36 'BEGIN'37 PROGRAM DGCPROG MARK 16+13 :■ BYTE2M(ELEMENT 1 6 )138 PROGRAM DGCPROG MARK IG+23 :« BYTE1M(ELEMENT IG):39 PROGRAM DGCPROG MARK IG+33 :# BYTEOM(ELEMENT IG):4U INC M(PROG MARK 16/4);41 'END'42 'ELSE'43 'BEGIN'4445 'COMMENT' STACKING A CHARACTER STRING LITERAL;4647 INC M(PROG MARK IG/1);48 LOOP END IL :"CELEMENT IG3+ELEMENT IG: ("ELEMENT IG" POINTS49 AT THE STARTING LOCATION OF THE STRING AT WHICH THE CHARACTER50 STRING LENGTH IS STORED)5152 'FOR' KL :■ ELEMENT IG 'STEP' 1 'UNTIL' LOOP END IL53 'DO' _54 'BEGIN'55 PROGRAM DGCPROG MARK IG] :■ CKLD;56 INC M(PROG MARK IG/1);57 'END';58 . ♦ . .59 'IF' PROG MARK I6>PR0G SIZE M60 'THEN' ERROR HANDLER PG('LITERAL'(E)/"NOXPROGRAMXSPACEXLEFT");61 'END';62 'end'stack pg;

iBT3*BT3*BT3*BT3*aT3*BTi*0T3*8T3*8T3*BT3*BT3*BT3*BT3*8T3*BT3*BT3*BT3*BT3+0T3*BT3*BT3*BT3*BT3*BT3*8T3*BT3*BT3i

- 4 f U r\j r u r v r u r v »U * c oc - U o f ' 0 4 r j c c X O' V i f' o : r u ' C o c o V I ^ O J r o - * O - 4* C iC X Z Z X C l X • X o »

rt! -4 X m m X > r c o X cUi Z X - 4 0 4 r r o X X X o G X c X œ» o X C i c X X X z X X X X X z c - 4

- 4 Z X O > X c f i - 4 c o c > o z 0 4X o c O Ci o o Ci e n C i Ci r C ft

U i c m C i O m c Z X e n m z Z - 4* z X Z X e n X en > c H c f i N - 4Œ D X X > c N O .- 4 X X 2 « H X X > fSé f i X X r N ftU c X en c X z m > 7 T - 4 O m N X» C o o C i c G f i r Ci Z N - 4œ z X Ci C i X c r- z r * X N 0 4- 4 c z X c r r r C i r c . » z N ftW n > 3 X X . m z o X r 3 £ r r Z 2 r - r u X» > X X o m m m f i r * N - 4cr n X X o e n o X X • 4 O *

r * > 7^ C i c X Ci - 4 ftO i z z > c C n X* X C i Z f i r * Z C - 4O C i f - O r r m > O #m V X f i f i ftu X c o 1“ > 1 X* X z z m c no; X X o r " C u- H Ci c C i m - 4 f i ftO ! C i > X n X» i - t • r C i X x>m < n r f - C e n r - 0 4- 4 a Z z r ftW H I M X» r r ITi X z f i - 4 v rW X « n 3» Z 0 4

> 2 n ftw r X r * X» c Om z o o z X 0 4- 4 — 4 X X ftW n X» > C O ' G - 4m : r ~ z > 0 4- 4 z f“ - 4 c ftW c C i m X» K z z O O C o - 4œ X - 4 Z r u 0 4

r rvn vn vn U) u. fu -* c.9 9 9 9

» rt -Z. > rtr c r* w I- zX rr z

cX az z - r s r r •V r- z X m - (C w X «r. fr» X» ac -tz oo rt a j>

9 9 9vn 9 WX

— Cl

999LkMUJUlWWO<l>IUlWrvj-»C'Oa>iO'vn9</.fvJ-*Cfv (\j ru ro fvj I < Or 9 vn ru ru ru ru -k -» -» >1 ru C -û o. -u0'Ui90<ru-»C'Ca->jO'vr>9 cm ru -t -

s z -I H rt > X c*V « c 1-1 a X z IV m oX -) a

o 9 -I : I V - 4 X a o rr IV a a -r c rr. z X rt —I 9 m 9 rt •< a

r rt c £ -* 9 XX -4rr X ZIV tv a 9 fr IV

-*arra*n-rrtcaxxa a I —I c m rr, (-> »■ m 9 > 9a9Z-fXfT-HX-l-< amortrtrtivc rrrr-<ma7v-ticnzC9art Z a. iv X a -4 -4 X c —( i x o t r x m c cz rt Cl a 2 c

o14 rt 9

rt C rt rr rr O O a Crt rt X rr X 3m rr 9 9 o 22 3 rt rt a rrm rr a rr z

X -4 O IVZ C X -n XIV rr XX X Cl *- z —I 9 : a a X O -4 X C 9mao

c X c I V

0-4 0-4 9 1 X 9 a 9 rt m m rt9 3 IV rt 3 a TV-4 9 Z m a 9 IV

X 9 X 9rr X a z X ce 9 rr c rt -4 a c rr O a rt a a c rra 1z c

z rt X m X 9 9 Z m rt -4 rt rt 3 C m X X cO a

rt o IV■V Œ IV C rtrt X m

-< o 9 XX a

IV oz aIV JE. a fr o ». 3

r X > O -< • z z o z r I I rtCO z r- m œ -4X r -4 7 -< m m. m rrm ft m G m o 3 X c Z rt 3

r • G % X > m o c oco > z > X > c I rt Z

m > c 1 G > c z m r- z . -1 V IV O -4 -4n c w co X c X X a -<

o m > > X > % -n co o fn 9 rr a IV^ m z f- C o H r*z : m G m z X w m

z n Ti W X o m 2 a c IVo % w -4 r* X z m m c rt

O -4 r- C eo w f a zo -o o -< z w •4

z G X co c en z G CO> m -< z -4 fU O C X

-4 r- > fO 2 • o O OX f- f“ œ 2 > o -nm rr C r eo >

n c z r eo r* o Z -4 z TV rtm w m % X X X ir o

-4 % m -4 «H -4 3 m -4 -4 aX -4 X -4 o z m I 14co m O m IV Z-4 X O X ♦ m c C M O z a

m X Ci % X Z X rtO m s 1 fi #-# X 2 9-10X X % > m O a x am n > > ft r X X X zX z z % f- m a> X ^ o O rt 9z rv -4 X a 9 -Ho co z > m a O

X I > m G fi Xc m ■ Ci ^ > 9 »X o rs > M Z ♦ OM -4 Z G m a IV-4 fTt O Z en -* ♦ mO G X M -4m i/i o • 9» ^ >■ 2 X « *

O z > m • CDX O •< X

-4 c < z -4fi

>1> o -e > o ir

CO r* -4M W G O W z-H•<

Xm

r-r- oXmX î • ,

-4rt

1 f

rt, >)O o rt J»rt c CDC -c a -43 a -4 CMm c »

-1 I—1 CIs CM-c. C »03rtCMZ »

-1 fu O,IV -1IVa rt fv »«n rr IV IrvN Cmu Z rv »œIV -4

Cm»rt Xz

9 iXTV »t X Xa -4O o W

»a Xa Iv -4a CM3 »

X■V -4X a W

»o XO cz c CMrt »rr CD9 99 CMC O »a Z 9o: -4ru W

vj *9 3 X■V -4a CM

tt *ru œ-4

O 9 CM-4 *

mc -4-u CM CM

»c W Oa 9 -4

CMz C »o 00 9CMw »

OD 9-4

L O L

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

s O o o 2 O -O - o o 35 00 X X 2 œ O C O D N N " u N N N N N N " U O o o O '^ O ' V I ÎNJ - * = c 0 0 - V > c n 9 C M 2 - o a a 9 V I w r u ^ C G 35 e n 9 o . r u -0 o c - U > V I ^ w r u c o X - M > V ? .p- C M fVl a

9 r t V > o •< D 9 r t o r t r j m m X r t m C l > o

z z 9 r t O 9 O o o z a r " oI V r t 3 3 2 2 G c 3 a r - 2 -

n r - Z 3 a 3 z 3 2 a o 3 m 2 2 3 m m X - 4 o- 4 m C m m z X 70 a r t

a I z Z Z r - z z z - - X X î> </> o m o mn f- O m - 4 m - 4 r t — t m - 4 f " - 4 3 ^ a a m X - 4 r n ^ M

a - - - 4 - X • m X « a Z X • 2 X z m m zCl m m a - 3 X “n o m X • O " p * r t 9

r r c z - 4 C r t a o a z V a - r s c z c r> m m- < r X z z z z a m z m 9 H 1“ m X m X 2 z Z X 3 3 aX m o r t r t z - 4 X > 3 w a r t r - m m I

m m c r t r t r t m > — 4 m - 4 O > z z am 3 3 - 4 9 Z r t % • ^ ■ 2 a 3 H #-# 2 w ^ - 4 a

o m r t o r t 3 Z a m O m 3 G r tr m z o z - » Z H r t z - 4 a Z 2 3 z 2 H r ' a r t

f - a o m X n X E a - 4 C m Cl# # m r t m O X m m X a #-# O X a■ 2 z J* a a a 3 - 4 a X a z > X> C O « m

m f - a r t m fi> a m X - n r O r " m Xm z « - a r t m a a m Z X i-i f n m cr " - 4 ■ o o 9 r t - 4 r t 1 « om a Z Z I V fi) a m X X M -42 w m cn Z » a O 3 z m o o <— A

z 9 9 Z a m X Cl - 4 a m 9 X ^ z VZ % # o - t 3 z O m a G M - 4

9 r t - 4 O H o X 2 r ~ - 4 m mr * O X m 9 a r t » o W C O X 2 r tr 9 Z a 1 r n G a - 4 2 m

- < r t O 9 a 9 9 O C l > p *X n Z I V > m m 70 Om z o a z f " a a ' 3 r > X X a

a - v a c a o m C a r~ X X c m m .» . o z r n X r t 2 a z - f o O 2

o r t r t a < m Z t n a n m 92 m - 4 a a c z r t X 3 Z

9 M o r t - 4 - 4 9c c O 9 a z c o za z a o - X z m 3m m O D r ~ a a m « <

r t a m m r > oa a 03 X

: r t a a a 9 m s f - ma r t O X C O O z g ) 'Ti n Xc a 9 a >z o ntj 3 Z z o - 4r t a » r t O X- 4 m m r t 9 C * - 4 m O« V a o O W X zO 9 a a a o > wZ - 4 9 IV o Z H

♦ z c O e/1r t O 0 0 o z f i X X9 Z + 9 zr t r t a m r * ftp ort 9 • o 9 f " 2 • H

Z « c G Xa 9 • z 3 X <s > ■ 9 a < n M »: I V : 1“

0 0 3a c n o

> oz o r t z9 74 o

m- 4 a a - 4

Ln VI VI C % N O' VI

>1*»»3-t CMCMCMCm tu «a tu tutuCM 9 c 43 3 N <9 9 Cm ro*3 a m mH m m m rt rt O 3CM Z a Z a m m O m» O c m 3 3 3 O3 m m m 3 a

z z z z m ZCm Z o a a Z « a a m m;» i— 3 a z C a rt rt'3 r* a 9 z ma 3 rt r» r> 3 3tCm a a A m♦ a m m z;

o 9 ■ rt c a aa m nCm 3 a *v:* o a a 0-.3 rt aa Z ■ A rt a m

9 rt a V rt H)Z a

= m m 9 a a fi)m.z rt a o rt’CM a » m < m'» rt r» 9 m iX r* rta rt m rt rtîCM rt 3 rt» m O 3 m »«i3a o !CM > a a» a z z m t3 m o m aa a z 9 1CM X z* rt m o3 aa 3CM o* a3 maCM 9* a3 oa aCM*S oa rtCM rt» o3 c

u

ting of :ZZZZZZZZZ2ZN,ENOFUNCTIONO<8/) PRODUCED ON 24AUG81 AT 18,57,08 PUT BY LISTFILE IN »xTLFAK-1O.RPSMITH• ON 16AUG82 AT 10,53.01 USING 1381 WENT ENDFUNCTI0ND(8/)

I)12 'PROCEDURE* END FUNCTION DEF PG;34 'COMMENT'5 PURPOSE6 TO MARK THE END OF A FUNCTION DEFINITION, WHAT HAS BEEN GENERATED7 TO DATE IS A BRANCH TO ZERO AT THE START OF THE FUNCTION, THE PROGRAM8 ADDRESS OF WHICH IS REMEMBERED IN "FUNCTION START IG". THE BRANCH TO9 ZERO MUST BE CHANGED TO A BRANCH TO THE CURRENT PROGRAM MEMORY LOCATION10 AND A STACK OF THE FUNCTION START LOCATION MADE.11 GLOBAL VARIABLES12 START HERE IG13 FUNCTION START OG (RW)14 FUNC NEST DEPTH IG (R/W)15 PROG MARK 16 (RW)16 ELEMENT IG (w)17 ELEMENT TYPE IG (W)18 LOCAL VARIABLES19 remember PROG MARK IL (MEMORY FOR THE PROGRAM MEMORY MARK)20 MACROS21 ELE LITERAL M22 INC M23 RAT FN RET M24 RAT ST LIT M25 PROCEDURES CALLED26 ERROR handler PG27 STACK PG28 MESSAGES PRODUCED29 6 FUNCTION END ENCOUNTERED WITHOUT A FUNCTION BEGIN30 method31 1. A CHECK IS MADE ON WHETHER A FUNCTION DEFINITION IS BEING32 PROCESSED , IF NOT THE PROGRAM IS'IN ERROR,. ;33 2. THE BRANCH TO ZERO AT THE PROGRAM MEMORY LOCATION DENOTED BY THE STACK ITEM34 "FUNCTION START D6" IS CHANGED TO A BRANCH TO THE CURRENT MEMORY35 LOCATION.36 2A. A FUNCTION RETURN INSTRUCTION IS PLANTED BEFORE THE STACK INSTRUCTION37 3. A STACK INSTRUCTION IS PLANTED USING THE FUNCTION START ADDRESS AS38 ITS OPERAND.39 4. THE FUNCTION STACK IS "DOWN"E0 TO DENOTE A REDUCTION IN THE FUNCTION NESTING LEVEL40 ;4142 'BEGIN*43 'INTEGER' REMEMBER PROG MARK IL;4445 'IF' FUNC NEST DEPTH IG < 046 'THEN'47 'BEGIN'48 ERROR HANDLER PG('LITERAL'(E)/"FUNCTIONXENDSENCOUNTEREDXWITHOUTXA*FUNCTIONXBEGIN") ;49 'END'50 'ELSE'51 'BEGIN'5253 'COMMENT' PLANT A FUNCTION RETURN;5455 PROGRAM DGCPROG MARK IG] RAT FN RET M;56 INC M(PROG MARK IG/1);57 REMEMBER PROG MARK IL :■ PROG MARK IG;58 PROG MARK IG :■ FUNCTION START DGCFUNC NEST DEPTH 16];59 ELEMENT IG ;■ REMEMBER PROG MARK IG; - *60 element type IG :■ ELE LITERAL m;61 STACK P6(RAT ST LIT M);(PUT CURRENT PROGRAM MEMORY LOCATION INTO "BRANCH AROUND" CODE)62 FUNCTION START DGCFUNC NEST DEPTH IG] %# PROG MARK IG+I:63 (UPDATE FUNCTION STACK TO POINT AT THE FUNCTION START NOW AND64 NOT THE BRANCH AROUND THE FUNCTION)65 PROG MARK IG :# REMEMBER PROG MARK IL;(»EST0RE THE PROGRAM MEMORY MARKER)66 'COMMENT' TELL THE INTERPRETER ("INTERP PG") WHERE TO START/67 IE AFTER THE FUNCTION DEFINITIONS;68 START HERE IG I" PROG MARK IG;69 ELEMENT IG :« FUNCTION START DGCFUNC NEST DEPTH IG] ;70 ELEMENT TYPE 16 :■ ELE LITERAL M:71 STACK PG(RAT ST LIT M);(STACK THE FUNCTION START ADDRESS i THEN CLEAN UP)72 FUNC NEST DEPTH IG :■ FUNC NEST DEPTH - 1)73 'END'74 'END'END FUNCTION DEF PG;

'BT3*BT3*BT3*8T3*BT3aBT3*8T3*BT3*BT3*BT3*BT3*BT3*BT3*BT3*BT3*BT3*BT3*BT3*0T3*BT3aBT3a8T3*BT3*BT3*8T3*BT3*BT3a

•TING OF :ZZZZZZ2ZZZZN.FüNCTI0NDEFP(7/) PRODUCED ON 24AUG81 AT 18.58.26 rPUT BY LISTFILE IN •:TLFAK-IO.RPSMITH• ON 16AUG82 AT 10.52.19 USING 1381 JHENT FUNCriONDEFP(7/)

012 'PROCEDURE' FUNCTION DEF PG;34 'COMMENT'5 PURPOSE6 THIS PROCEDURE IS CALLED WHEN THE "FUNCTION" LANGUAGE SYMBOL IS7 ENCOUNTERED. FUNCTIONS ARE ANONYMOUS IN MULE * HENCE THEIR8 VALUES NEED TO BE ASSIGNED TO AN INTRODUCED IDENTIFIER. THIS9 PROCEDURE CAUSES A BRANCH AROUND THE ACTUAL FUNCTION CODE TO BE10 GENERATED AND REMEMBERS THE START ADDRESS OF THE FUNCTION.11 GLOBAL VARIABLES12 FUNCTION START DG <W)13 FUNC NEST DEPTH IG (R/W)14 PROG MARK IG (RW)15 PROGRAM OG (W)16 ELEMENT IG (W)17 element type 16 (W)18 LOCAL VARIABLES19 ELE IL (ELEMENT READ FROM THE MULE STREAM)20 MACROS21 RAT END M22 ELE LITERAL M23 RAT BRANCH M24 RAT ST LIT M25 INC M26 PROCEDURES CALLED27 ERROR handler PG 'LITERAL'(E)28 FETCH ELEMENT PG !29 STACK PG J30 messages PRODUCED '31 5 NESTED FUNCTION DEFINITIONS ARE NOT PERMITTED32 METHOD i ;33 2. THE CURRENT PROGRAM MEMORY MARK IS USED TO REMEMBER THE START34 LOCATION OF THE FUNCTION.35 3. THE BRANCH AROUND THE FUNCTION CODE IS GENERATED.36 ;3738 'BEGIN'39 'INTEGER' ELE IL;4041 INC M(FUNC NEST DEPTH IG/1);42 'IF' FUNC NEST DEPTH IG > FUNC STC SIZE M43 'THEN'44 'BEGIN'45 ERROR HANDLER PG('LITERAL'(E)/"NESTEOXFUNCTlONXDEPTHXEXCEEDED");46 'END'47 'ELSE'48 'BEGIN*49 FUNCTION START DGCFUNC NEST DEPTH IG] !■ PROG MARK IG;50 (THIS IS TO REMEMBER WHERE THE FUNCTION STARTS IN MEMORY - EXCEPT THAT51 THE FUNCTION STARTS AFTER THE BRANCH WHICH IS ABOUT TO BE PLANTED)5253 'COMMENT* NOW PLANT A BRANCH AROUND THE FUNCTION CODE;5455 ELEMENT 16 :■ O;56 ELEMENT TYPE IG :■ ELE LITERAL M;57 STACK PG(RAT ST LIT M);5859 'COMMENT* INITIALLY POT IN A BRANCH TO ZERO (ApOVE STACK IS CONSTANT ZERO)60 UNTIL THE FUNCTION END IS ENCOUNTERED. THE PRECEDING CODE PLANTED THE61 "STACK CONSTANT 0 CODE" SO NOW wE PLANT THE BRANCH CODE ;6263 PROGRAM DGCPROG MARK 163 RAT BRANCH M;64 INC M(PROG MARK IG/1);65 'END*66 'END*FUNCTION DEF PG;

*8T3t»8T3*BT3*0T3*BT3wBT3*BT3*0T3*BT3*BT3ABT3*8T3*BT3*BT3*BT3*BT3*BT3*BT3*BT3*BT3*BT3*BT3*BT3ABT3*BT3*BT3*BT'

o o o oo M, H»

9 9 9• C o e v j 99999991MWIM9a9tnlU-*O'C0c-4 MbNLNMU'UiMIUlUruru'UrvjtUfU'U'U OU'9U»IU-»0-0*'J6 a 9 W lu a c= c x a » VI 9 V . l U - I 2

Œ -<T.

X M C. r

c aI IX r~

M : m a a

a sa rt z c rr a c 3 C m 2 r » z - n m a

o a a z o

a a 9 a m a O a a c » a c * m m I axmr>9xxrri»œmrtrto t»aamrtct.aat.ammo a c a o o o o a m m ca - n a m x z c m a > e a x r t C z z a X 3 a a C a Z a aa a a i m m x l u a l u a m» z » a » r t a m 3 m 3 m x» m X X z m 3 X »

C C 3 0 3 3 » Zm C m e r t m 9 r t cX z X c m z r txt-xoxart 3 3o m c m mX r» X e a a ea o o• I

o X r> a m X 9 > z rt o 2 rt m a o a 3 < 2 m

a » a z rt X X a a o

9 ac r t o a

X c a

ff)rtm o 9 r » 9r t c a 9 Xm 9 — 4 c mS r t X «rtm a m «rt z < Œ «rt aa 9 c m

X a a ofil 9 «rt m art o m m 9 0

•C*-UV'Vrt9tN«uaca a Xa Z a

a o c (rt (rt«rt m

9 rt I a rt r»

o oo 9 C r t

2 C V i - 4 W X a Z C 1 cz m ( n m f t c m - 4 O c z 9e n z H z o o 3 a r O : w- 4 I f i z e n c c m m -< C f iI z f i f i a — 4m > - 4 - 4 3 X o - 4 c O M e n X- 4 z e n f i m r i 3 X z f i - 4 e n Om w X a - 4 f - c as - 4 X Z 3 Zf t ft ft m Z - 4 C Z m

O CD e n f z w 3 O " H Z m - 4 9M a O z m Z 1 - 3 Zm N > f * m m z e n % c m cz m X <-i œ 3 rZ - 4 f i m z C Oo o a z m < z m z , 2 X- 4 X o a - 4 = am - H < O - 4 O O> a c 3 ^ % en X 3 C K- f M m z : c a c r - e C i c . cX Z o ft f i e n c f i - 4 Z m f i> m c 3 m - 4 a - 4 f i C i9 « 4 m - 4 ft - 4 - 4 O B 9m e n C i V f i Z - 4 O • H m O fV)- 4 > z rti - 4 Z - 4 - 4 Oz Z M X w m a r% X 2 ft Zm m z e n z - 4 m - 4 - 4#"* O i m n X Z z - 4 a r uz X z - 4 - 4 m m C w m f i o ftX O f i % f i M e n - 4 r * Z o O ftX o - 4 - 4 z m - 4 m m co f i tfi Z z Z X e n 3 - 4 f i V i C io m Z X m m - 4 M a m Z ^ f t O Bc m m n m - 4 O zf i c o f i s m X o Z f i - 4 oa M — 3 C i m z r u ftm f i : m s f t X r ~ % - 4O z e n e n c - 4 C i ftiX am o n - 4 ft X a

m mZm 3 e n m - < en

O-4 m X z z z zC % C i ft - 4 - 4 C i Oa m 3 f t « 4 c e n ftz z - 4 - 4 e nen - 4 C

r-n- 4aZc-- 4m

m9

a3C- 4me n

O • WQ D

f VO B

Z wa o *- n a

r t aa a a o .

a z rv

Z 3 I x

- a »

W»m

w»saCN»OBa04»Z

>•»

« C 'C o a a a a a a % O c oc a a o a » VO » r v - * z o a - u O ' O ï ft 0 4 r v — c c O c -SJ o - L T ft V 4 f v - * c a N o U ) ft c c & N a k Tt£ * #-# X 2

rr, z r r e nU »» ^ C X Z zcc z X f r 0 5 m rr. cr- H z X z r rC n X f r X o X X C r r» c r > m K a • 4 r r ft ZX X n - H - 4 X z r m m X Mc X •• C c e n f i C rr. n c r r rc o 2 X X r r c rr. rr. X a r r • - X r r* c z m r z c r r - 4 Z rr. - 4 XX n X c c o e n c X c r r - 4 O - r rr. n rr,

# % X c « M rr. ^ X z - 4 r r r Zu f r ( - z 1 X z rr. X 3 Ci» c c X c K o r - r r m X m #c z > r r r e n X ft X rr. C r r r X - 4r r r ft z K 3 c m z r r ftu X en r X • 4 N Z X f r X - 4 n X» Ci r - r r z c ft Z r r r r r r f rX X Z % z - < z C l X X c% C i s - 4 O m ow O X n B z - 4 C i* X X X - 4 fl

n m ft o X X C l 3- 4 m M r rU z • H X o m X m C i f -» c 1 r r c C i - 4 r rX m Z m . C i f t O Z• H 1“ > r e n • A m C ‘ r r cU i o n w — 4 f V r - Z X» z z f t W f r n c f t r rm C l m 2 - 4 r - z z Z X Xm r r z - U m m O r r X ftw X r r X X ft 3 z» 1“ Z f t r z z O B cC D X r m c f o m cX e n n 3 e n - - 4 X X X 30 4 o rr. — 4 ^ X z» z Z r r r r r r cC - 4 - 4 m ^ ft X r f t X« H m % f - m HO * e n X X m X ft» W C i e n X n mX % m X m z - (- 4 C i m X - 4 f t0 4 X o m Z» c C z ft f -m z X X - 4 Z r r- 4 o O0 4 1 f t rti» z M - 4 9 o zX - 4 C m X z o

z X mO : O e n e n m» o z X z :œ c o f U f t - Ho t m z0 4 - 4 z M ft - 4» w f t f tX O m • H - 4 Z- 4 Z r - 4 - 4 C C0 4 r r X X Z X» 2 #-4 C DX r r O B O D m f t- 4 z C C X0 4 - 4 - 4 " 4 r >» m m c oX M z f -- 4 O w o

c

»

oc- 4 k X C n 0 + r v r v r u I V r v r v f wO ' a L T f t ( X r u w > c a - u O ' V I f t wa

fr. cr o c m9 • • ► h X z r 3 C i

Œ r X 2 m %n c f r ft m

U . C i Z wH e n X 3 X - H e n - 4s - 4 • -0 ^ ft- 4 ft X X Z XU » O m C X X C i m» A X C i c c ? r » . ftc X ft r

X c s ru . c X ft 2 X - 4% % . X ft Xa X r: X C • H r

ft 7 0 C mz m f t

» c C i 3c c r C i ft c e n

m V % X mu X e n X» X - 4 C ia X X ft 2 • 4

C i O C i^ C l 70 - e

» ca n e n O-4 # XI X - 4 N fT m» X X ftc r X f t f t f -

f t 2 - Ho * r f.» O oa z

f n ZI Xn - 4a C i Z- 4 Z 7 0 mI X o» M . 2 X< D X- 4 X C l< X O Z» C i - 4W X

f t ZI X 2 ft» M zQD e n . o- 4 XO # f t o» o Xm m

M XI X r ft» f n zm o- 4 « 4i XftO )

a w * r X X r »

X c o c r- X >> r r f - 2X1-a > «r«rt 2 c :a ra c i r r r T i Xc a (rt r r Xa Cl9 C : o r r X (rt a a a o r >C l m c

X r r

X fil X -X r - c r »o X X o e X ©

(rt X 9 x x r r o x x œ r r x s 2 9 C a O X X r r C C 9 9 C 3 . O <T fil ( r t C a C 7 © o r - r “ ( r t r n

X (rt c X (rt r r z

o X a © X r r 9 X c o 9 c X X 3 c © 1 (rt r r X c

X XX 9 i <% 9 9 r(rt X X a

o X a an Ci 9 X9 a Xr~ a © r~ ar - c r r xrr. w (rt r r

O f s f S >O c fz

C - 4 e n - 42 X Ln

C '•-1 »a

c - 4Z O .

c ftCruen »en c

ft fs«fi rrrr N aXC- u.vn cN

uftr crr. - 4ft en O »7 0 - 4 ftt f t Œri - 4C 7" O»X ftX C i CX - 4

U l U *2 ft

Z- 4

Z X e xX fto c

CZ c o»fi ft

ffi cOft L4C O ftC l Z Zexrv rv Uft ftft zc -4

C ia »

C Zft ex

o «H ftw

N « ex»C O zen rv exz ftCl z

exu* ftO D z

>1»sVI L/l Vf! VI r ^ t' ft'ft ft ftIK W IX w w w w O. O. U rv rv rv fV fv fv rv rr cU fV C C a -si a Vi o« fo C < a -4 O' V ft o* rv -* X < a N o vn t" Lkrv C 'C a "N O VI ftLX rv c C a N o VI ft Inrv C -4 z XCl -43 X 3 r C. X I 04X ft ft o c »c en X O ftr- en 3 en o fi 2 c en en c -M -4 X C z a% X • C: # X M ftX G X -4 ft w X ftm œ -4 -4 X c X O X 2 -4 1- -4fr c -4 % -4 #M C M 2 G -4 O rr X Ktrr. r- 2 ft ft ft 2 rr X O.

t: X Z r en ft ft ftfi G X en X rr.X C fi f- rr Ci O en »en en Cim ft -4 • N- Z X en en ft c -4 70 A z X m z rr. X H N &z rr r -4 *-4 •-!z m I rr. z ft ft fi c c -4 X Nëen -1 ft NI z m c* rr ft s c fi N m -4 M 1“ G X X 2 C -4 ft C 3 X ft O»rr. r- ft z X fl enrr r c C ft Cl X C r r »<T X m X X c c c en ft c X ^ M ft Ci X rr —1 c rr N. X% - o X X c 3 2 -4 #M C n a Ci 70 m ft X m NX 2 n X m X > m r 2 r X f- c X fr X X Ni O"f> -4 c -4 w m X -4 •“ fr.^ rr c n ft C c Ci z »r w X •• -4 ft X X en CR «4 n 0^ X #M en X O Cirr fl en fi NI aX a rr, rr en C » o ft z -4 rr. -4en X X X fi s X X % C ft c a Z O*a w w en c X C enrr. en rr G X en -< fi c -4 »X o z ft X M en -1 X -4 A X f- X afi O X < en X o X m ft 2 ft rr m CCi -4 Cim X X rr f- en < ft X o4M a X X 2 M, 2 X f) X Z G 2 z en ft A »n r~ % 1“ rr -4 m m z C en r X 1 ft cX en o •H Z % fn -4 r c Z en X c X c c r -4^ -4 Ci ft o ft 2 o #M -t X C c Wr> ft C #M X X r fi X N -4 fi »O ft fi en X en X Né en m X c ftm w fn fi X #M ft c X X arr ^ X -4 m < m X o c m m Z X r rr m fl Z ft X Cia ft 2 ft -4 M » w r- N4 G f- en uc) -4 en % m o f- #M •M -4 fT C o fl r o m c 2 %> w ft X X C r* f» I X X X 70 ft rr O aO N X X z » ft C Z ir r A en-4 O -44 X rr X 2 -4 w 3 M -4 2 m f- 2 ft 4M Z X X 04X ». ft ^ o G m Z c Ci #% #M X Ci m X -4 2 a> r Ci X W C M Z O O ft O -4X • en Z X o N» CD -4 -4 Z X 04X en *M a fn r en X ft•M Ci N en <r o -4 rr. ft o aCi N W f- fi rr ft ft fi G X -4 r O' G0 w X -4 r -4 m m O m ft c ft C OfX c ft r z fl O X #M fr c ftc r en n -4 ft X ft Z Ci ar X ft w Cl X C 2 H ODc r en < o ft o f“ -4 rv wz ft' c -4 ft o X o 1“ -4 X c ftn 1 o m r fn f- n m rr ft z 2 aX c en m c c X -4 -4 -4C 3 CD rr -4 ft s o m rv 04n fn en z X X X X ft Ci O' ftZ #M -4 •M o fn m #M o fn en r- m C e_ Wc m Z ft ft X X c c ft

r> Ci X C en X ft VI Z 04r* -4 H m » r z z IV a ftm X >c o m en G #v ar c fi fi 4M 04en m r~ Z m m -4 Ci O' ft 04-4 Z -4 ft7 -4 en ft o 14 G -4 Ni c a3 en m -4 en O ft G en -4D X m m -4 rr W Oin Ci ft X o z X fi z ftz f" f ft ft Ci rv a

/) fn C C Z c CNfl Z o c m f- -4 n OiO en X -4 -4 Ui c fto fl z t -4 OD a> N4 ft m X C O Oz f c o Oir- ft

CDW»(CaiM»m

saut»sw(giM»»>

1 1 1 1 1 . 1 1 1 1 O 3>1»»*â • C O - C « O <cC "O 3 3 3 3 3 3 X 3 X 3 N N N " V N -V N N N N O ' » O ' O O O' > © 3 » V I V I «w O (rt 9 Cm r u -* < X > en 9 C M r u ■ o % N O ' VI W rv 3 • V > V t W r u a 3 > o 3C N iD Z . > •m o nW z (rt o o o C» o a z X i Z Z3 a a m 3. m 3 3 Œ - 4 * M

3 z z a 3 m X flW C (rt r> â Z < n z o Z © m •» X C Z S m X a a3 m - (rt r = -n m za X 3 (rt % en Ci e n enü > > m > a Z o ft ft ft» r* X r » X 3 O m (rt m N • O # M Z z 9 z f ic. c > X A - X 3 c 3 m m CD -4 m G © t n Aa m C m a c m z f t t a m m £w (rtX 3 (rtX m z Z m -4» 3 c © Z A a z r- e n - 4 f c X -<3 © r r Z X (rt r t . o z m c ft T

X > X E r t m m ® f t f l N4 mW z M o ■ X m n» r o a X ■ r t X m m c: -43 r* r t © (rt (rt ■ n o N # C i c X •• Ci

m a a a rt m r t V 2 r - m 9 B nC M X A > r t m c ■ a m r- ■ o r - r t» 3 •• “0 - 4 f t O -4■X 3 1 ■ c (rt > # m X fta © a 1 (rt v> X r t a c * M Ow z & a a r- o ft Z X o 3» z > m (rt -4 m 3 z m C i m3 (rt X 3 o < - o ft 2a A c a © O X < n z cr ftw a m m 3 z a a - 4 © X» m X a Z c o 9 r t f t o AQ © c r " •o 3 + X Oa t © M V» A mw r t r t A o %) e n z r t» r t r t O » o © A m % -43 » + 1 3 z z r t O c C i > W

X Ov a 3 m a 9 O X ft X f i BW a 9 > 3 1-4 -4 A* X > 3 m n w G3 : !♦ c z c m f X X < O 9a (rt ,3 X w o r t 3 9 m C i C i XC M a ,m a a a O Z X» 9 : 3 r t NI O f t A t n X3 o o m m r t o < n - 4 ma A . » - , ♦ : ft r *w » < a , a r t z f% f i 9» C A r t wi m ♦ o A3 Z o r t + r t e n 2

© A (rt r t < o 3W m rtl «rt (rt f t ft» X A a N r * « - 70S r t m m c c Aa r t la 3 m enM o fi» » # - 4* c m r t C i3 : z > 3D

3 z mC M - 4»3 r t z Xa ZC M m» © - 43 maC M»3 Ca zC M»3

o i

>1»»- 4U » N i O ' V I f t o . r v - » ' C Ô L N i 0 ft o . r v —nc z 3 Xcr f r ft C mu Z r r z - 4 f i - 4 c» G X C i o % r r X C X 3 - 4a ft - H • M r r O C c 3 f n

T z f l e n C e n e n C lC e n • ft X Z m

» X c c n C - 4z m n X X• H X • 4 c

z X c» G O a z XC X X - 4 C r r X

rr. c > ft cU . X r e n e n f i» c. X ca X rr. N« H X c f%4 fr. oU . o n o m X A X» c C i 3 mC m % 3 : C

ftu X o n X» C i X Z O ca c C XX S c

m C ft» m X o5 ft X o o- 4 C z XO.' r - c f r* o e ncr e n- 4 o % - 4O é Œ X» 3 C iC O

e n X cL K> N r 2cr m o c

fr. m OU i 2 r *» r - 4 ftc « n O G- H OI W - 4 ft» OC O- 4 o > XU J m m»œ e n Ow o 3 3» z O >m O - 4M mu *> o œcc >• H . zO f» occ z

e n0 4 w» oa m

XOi wn z9 Cl

O t s f S > >O o r

c M zc - 4 e n3 X - 4 o .m »z cr

Cw u

Oc

r- - 4X o:c e n fsiX .-4 N Cft NG NC r N >X i r N am N *e n N i O ie n t v »X N cC i N

of V »

r X aCX o .f t #

1 c cG - 4

c X o;m n

X e n cX e ne n X O i% o »

t rr v

z Oicr

oz X Oi

Xc e r

O ' GC o

c »o so c - 4r v Oi

C »f t Z C C- 4 - 4

O iO ' »

C 3 C D— 4

e n OiO f O C

CCV ) - 4f t ft Oi

- 4 »c C Ce n - 4

Oi Oiz ftC i C D

O -4Oi

Oi f V ftO D Oi W

- 4

> ' o r*. > i» o O r t» c œ» c a © a( g z X a C Mc »

O cr. 9 C M r u a « X - U O - C / 1 9 C M I U a ^ z z C» aŒ Z X œ Cma a rr c c »C m z m C a a X c z Œ» c X © I o o X z a r t(g a o X c z r r X C M

X Z z © c 3 X V. r r © c »C m c V) m 9 c z r r X C» X © : a X Xa rr. X Cm

X c rtz 3 X X rr. ©

r r X ©c « r X < X m Cm

Ci c 9 C 9 c • X zC M rtl X rt a r t X a» t e X C 9 © «SIC . < X 9 r r r t o Z Cm

X ï> c A c r u »C M © t~ X X r t X a.» c ( g c . r r cC D m s a 9 9 X

r t AC M X o C X 1 z c» © X O C m c a a(g c 2 z X C Cma 9 X © A ©C M r r a m X» c X rt X X aCC r r o a © X 4 M

X z r r Z © »C M z © Xz © m r u( g © X X Cm

»C M 9 X X» © o aO C 2 z X C M

m c X »C M 9 a c X» o rt o 3CC C 9 c Cm

r r C rt »C M z © X» a OC c a(g m o r u C Ma r ~ X C »C M r z 9 X» z 9 a aO C a rt C m

r r © »CM tn 9 o 3 (g» Z X 9 a(g © 9 c r C M

r t C M 05 »C M © X X» z 9 Z30 X a> 9 C Ma a a »C M a c X» X ©( g 9 3 CM C Ma Z r r z »C M a a a © O X» z o c a0 0 a Cm

r r CM 4 M »C M © K X» a

ftftft ftftftftftftft LKVfV4Vf Vf VfV#Vf fV<é a •V o VIft04 .*NJ•A- c oc-43 V ft *-*-ic

m Z D3 ftm Z z o O ftCD enV)Œ- o c X z c X z G -4M<no X m o z ft G -4•4 ft N wc < % z z r* P" X X C Xm -4 H HX m ft cn ftr*c o X -4 f--4 enn r> m m z z cnX f-X m o enX cn 3 r A c A r-X f"Q o m o o en c enC (A <n n H “ft f> rH m -4 z X fto r* o r*r“ft -4 X nH O z Z m A -4A m m 70 o c ft G A c Xo X r Œ mz O n z en G m r- X mtnA m n 1“ X -4-c m 3m en r- en r C -4 O r fiftcno o r*c m en o -4r* -4ft M o M m ' m c Zm H -4 ft X X-4 f> c X ft enB c X £> o X > A X -4fiN ftl3 -4<nr* X G ft O O m fH -4o cn G G 3 "4 «< X CX 70 o H enzm -0 -c m Z T3 o -4o Z G O A < cn3 Cl enm X OC X z p* X Z cn Z X r*en Z-<-4 -4-4r -4 m X z ft fi cnm o z o -< -4 co » z z o 70X -4 o Cift X G C Hz ftf- z X o -4X Z fi» f-l 04 o z enft O Xr-70 o W r* -4 -4 m z enf ft f 70 O 3 m c< -4 z 2 H -4 Wf z O 3 en m Z -4z cn Ci-4 m XZ r* o fi ft -4 f- m m o A fim 10 -4X o -4 Cm o n-4 en o O fft c Z cnO r- -4 XA •H -4 en X CO z ZZr- O -4 Ci -4m Oo <D ft z 3-< r* mw m c en•Hen -4 ft"4 X fift AO -4A

1 © •© 9 VM is>r t C rtO 3

3m O O M C r t X X O T I » © © © © S O a r t X x n z x x c o r t C C a a a œ m x z » x a x r t r t e - o x x m z r > > * » * - 3 * » r t o a X tn o n o o o c r t x r t ©

3 2 © a 9 c a A A A a X o m m3 3 a Z C X © a 9 a < C C

a a a m a z a o z m 9 am m x © r t m a © 9 o x a a

© m X X c © a z X3 m © r t s x m M s A © > m cX © 9 9 X X MS 3 © 3rtXOCfZaMsXrt x x r t A © © a © c c m c :© © m a s, © X a

O a 2 MS MS a Z© 9 X X rt aX c z X m

MS, A a a X

C a a o

r t X 9 Xz m

© r t sr t a rt o

r t z

c z © c

G f S t s > tO O r * » ic M z

H e n - 4 i3 X - 4 V #m »

- 4 Z-4 Ci

Z V fX - < O »

zc f " - 4f i Z V *m e n »G H N zC f N

Nm n N »

Z m N zX ISI

c Ci N V fc z N »

ft N f zf - NH Z V i

- 4 »n Z s

Z c - 4ft V 4

X A f #C i 1 -4 Z

o V f< X *ft X C i zn X H

c n f t Wm 3 N , *

z- 4 • H 1X V f

» ï2 z<■4 Cm Z X V fC i »m O z

G ' if t C w jC »

œ C i z tc Q B " Hf V W 1

r * O » (- 4 f t Z œ- 4 t

V 4z f t #

3 Z îX Mo O X V 4 Ic f t 0 » » (- 4 r u C DI V i

z N j > V fm - 4 ft

C Zc o e n « Hm O V ff z ft *m C i W zf i - 4H V fO V 4 f U ftX O D ' C zO V i

ftz

mw»03aw»sCM»asaw»as

O o o o 'O•o <c 'C'Co < c X X X X X X X X X oc3 u c C X 4i O' v/t V4 AJ-* - c OD41 O' S3tX- u fv ■0•X o VI V#Nw »« X X f\J • 3 X Xz c mX o 4 4 X o 7C 4m c/>V)X n > X C X 3 m X c X X m z O X zz 3 m o z 3 X o X z 3 o >o o -4m X m X w V)"4 X X m X •4 X z Z 4 c c n m m-4 n m m c > 4 4 r* 3 4 CwS m r m c 3 r* c m cm f-r r K3 s X 4 z 4 X3 r C 3 > m 8 3 (/)c r-O O m 4 X 4 O 4 4% X 8 -4 ffi > z o X 4 Z >M > o c 0» o > 4o e > 3 cnX 1“ X zo r-CDX z X X X 4 X r m >o X c m o > X £-m > o c > Z X O z o z X mX 8 X J» 7 cr m X o mX N 3 X > O cn3 r*1” O m % X ri Clm 4o X . z m 4 o n X z o X« o m < m f"0 > 1-4 X o m X X Zc QC «n o 3 oo H 4 o >1“ X X 7 mo n m m zI -4 3 r> o3 V) </) > 4, as-4 O X C c/» X c zm X o z rs m m O-0 o z o 3 r- z 4X z 4 X C4 cno M<n O 4- Z r-C»X 3 4 7Tc o z z m3 z o 4 zH o o ■> Z z >X </>4 m 8 3n K X > mm 4 (/)1 c Zo O 4 z oo > o cH 4 m X 4 zZ X ZX m m O-4 X z c-4 f- V) zC" Z r>o m cn z 4o m cX o 3 O

C'ca=-4i>vi$'v.fv cojc'NOvif'U.tM-^z.'Caç^:"^

- TJ O -i O V -t » C r>

C f- M Hr >HM -0z r (A O ov>

< c f l r > " O t f ) ' B C ) i - i ^ 3 a c o o c 7 0 o o o o o o> C 0 3 3 —4C.C'ni-i>-t>-4»-<»Hi-<>-tl-i>-i>-«>-4i-«i-i r - z 3 — I > -q - 4c«A*ero cr“ o o o o o c o o o c o c s ;ai“ t“ > or>r)r>or>rjor; o o o o

r m i-i z » r <AeAiA(/>i/)v)(/}CA<Avi(/>iA(/>»• r~ r* -4» I-

r* «- > 1“

rrrrri-f-rr-i-i-r-(-rr-rf-f-i-f-r-rr-r-f-f-% » » » » % » % % % % » %

* WO ».c

3B DX X -< >3m -4f- m

■1 n

X ( X L/i M X e s -<4 - * C - c

N ■'JX N

-M -s; ->l f- O N O' •Z 'C» » O' O' O' o >eO'OivAuiv oiwtvjivr. uïv/i*'

X * ' 4 O ' V A S ' « N ( \ ) - » 3 ' C ® " J O ' V J 1 . t ' l A i P 0 - i ^ ' O

*>i O' Vil c» w f\i -» s .« •• •• •• •• ••S' fr-O ' Vil f

t' f' f' X ( V -V

X w w ' c. -O X «J

- o >g) Xo o

% m C l r ( D r - cr m c X e n 33 W 5

o c m m —<y>x<c M ' r~ z-1 !Z1-1 (/) Xf- r- -< r-

r- XX X

X Xc o

X X

C O » A « V A VZ X Z V N I

A » I ♦

O -» C o 3 M 3

o Z

- i »-i X m

m - 4 *-* r - X -n

C O 3z or> r~ X

3 O Cl

^ 4 ii M v ; r u f u r u r u :

I V -fc c o a 0 V î r u - *o X4 « A X c 4

e n « n X # > 4 o4 1 - 1 4 0 s

o x> rsi X z o c' X X m > > o X z

4 O XM m X X X

7K f " n n 3 > e n > zr 0 2 1 - o 4

- 0 8 4 X m >m m X

4 C e n Z(/) f“ Z - 0- 4 < - X O X> •• o o C zX 8 e n o O 4 r r

X X" D N S

r - C m % c X 4 Co T3 :o z MX P I X ■X e n o -

o e n o Xo 4 c Cl >

r * X > 4 H t X< ^

e n X O m oe n z z — •

. ^ > a X ■T J Ci m c 4 e n

e n : 2 .4 4

> %• r X Xz m o ;

7 C % :C o rZ 3 z m >4 z

X 4 C i o( - Z 4

m X 4> -

C/ï et o O4 z 4 >> > X ;

X 4 m4 > z

o mr - 4 .o a Oo >

c n 4 > i>

c 4 ?#— > - W )♦ r " » f - îe n r -

r* !N Œm m

z :4 o mr - a1 4 Z ;

3Z œ.m m-

(I>

M o j r j r o M M f' t-O 3: -'J O Vf f-i\»fv»fVi(>j»\jrv>»\irvj»vjrjf\jfv»fviiMfvj»vjrv)(\j'\j(\jrvi»\if\j(N>t\jnjMr\j(N)fvj(\jiMi\jf\>rv)ivj(\jfv»iV)fvif\»'ufv)M-»-»-»-»-k-k-»-*soczocco-o-o-o-o-c-o^o ■O'Caraa. Vi«fVJ-*~'Ca:-siO-iJl«'>.f\}-»C-C'»-S0'Vi>*'Vi<(\)-»C.''O'X*vJ0-v/It'UJf\;. C'Ca''4O'Vf*'<x(\J-»C o a -y O' V) Lw rvj -& — ÆJC*%

1“ X t lm z

-4 M X - n= > . I- o

-1 m

H 5A m

3 -c

0 f“ 0 r - ' m 0 X<n cn X cm z r*z z z z z m Z c z z 4r* m 4 m 4 f - 4 m 4 r m 4 r - X 4 z X m 4 m

r r - z cn r X cn r- r - X VJ r Z m cn z m cn z4 cn cn m c > cn m z 4 c > 4 cz f “ z r * r 0 4 n r“z f- m 3 1- 4 3 r 3 3 m n 3 mX z r-3 z C 4 2 c 3 z f- 2 M z

r* r r r - r

■ **X o I - 3

m » -0 XX m . H «/>

C/J *-H c: J» r- f“ r> f-

3 -4 fn ••

*-> 3

I- »X o

n 3I »X : X w Œ

$ 0

0 0 0 0) o

•VjrUAJfyMfUMAJr u fU c c oc -N C vn Vt O oc -u > VI ^ V i fU - -C O: N O' V* l\J 4 - ■O >x N > W ru c c OC N O' V ^ V« ru - * z c X o VI fUj

z z %a z z •> c c > c oc r>z z z c n j ru X z z o> o z z > z r - z z 3 m 4 c > r% 4 o o % X m œ 4 r 3 Ci o c 3 m m 2 fTm cn o 2 m cn X « 4 X < cn m 2 3 O C

4 z C? X m X o 2 4 O cn <n C c Z 4 X Z r m X z z■» z o c z n 1“ 4 4 Z z 4 n X 4 r* m 4 r -

2 2 4 m 2 > > en cn r en en n f— en X r 'z m m X o z O O 4 f— 4 C 4 c cn m c >n 2 X 4 3 r m X X O r* n n z r4 O 2 c r * 1 4 r - O m 3 4 m 3 4 m 3 r 4 m

m 2 r f - 4 c c 4 X o XZ o 3 m 4 > r IT C f z Ci 4 Ci 3 % 3 C 34 tt 4 2 4 Z 3 3 r n

z ■ Z O c en m 4 4 f -C o z O C O o > > AC X c A o z C X o ■ « V ■

o V z o r> o r> Z z Z Zc z z X 14 X Z r - X 1“ X Xcn 2 3 X 3 # en o X c X o o

> z > 3 4 3 o oo : a c X Z > f "

m 4 - o Z z 1" 3 i— 3 3r> o a o o X

D o m r* r - r m 2 24 z C* X cn > 2 3 c 3n cn V) X 2 Ci Ci X z X X X

# »-»at ' «-I^ ■-iX f -

cn -4

r*•H O Xm 3

oz- o » zX c

a

O O O ' O ' O O - O O V / ' V i i V f V f . -\,OLr*'wfv-»COC:NOa tt t t Hi Hj Hi N N N -si 4 "Ur v -V C e tt HI tt v r U ru4 C

X % * z z f U •X > c

X 4 X Cc X z > o z 3—4 -H 3 o c 3X c e n rr,

-H> «-I X H t mm r cnz rr -4 z zr 4X 3 r- > >c -X r~ XX -4 •• r r

> 4o %z X rrX

m cCl >m rX 3 c

c mX : >o X ctto >c a >

r* zmz o

w

S U'w w w wVf Vf Wt f' INS -» C 'C

WWVXWlkWWWWWUi OC-S.O Vf. «'vniv-»c:o*

w vx w w w V»: U u o; U «g a Vf. f- V»-VkWlwWWLMlXWVXWVXVwlf'WU UiU.Uifufv)rv)A)Mt\j*v;«V!»\>rv<- — nj-*3'CKNOvff'u;rv)-»C'Ca

fTiC«tA-»»CA» “ “V-i-HfTl-t -4fTi ŒOm e— t n n v r r r — ' n c ' - ' C r — A A m = z. A » c -< *- 3 — — — 4 % « o - H « -■He ms.< e -* c. e *»

tP. « A » • % T V

> »> TV A

«H #e

C -4 -c > -4 r> rr TV

M aa *- -< r~ -H-*» ID f'w er

» -4 f *»a r,lA TV

> f-lo aTV -C

lA tr c ►« -< X

— m3 a TV *.c 3tt *»

Z CAe -Ie m m TV«A 3-H > » * X TV

X VA X me - 4 - 4 TV X > X X » z > -( m >c m z c r rr. X c 3VA X -4 r CA > —. *H

X f“ XCl X

X C 3 m tt » 3 v_ :c #-iC CA tt"3%> z2 3 > > 34 X 2 - 4 X w

3 3

X 4 C >3 n

Z r u z % • z z r u CiC c c c o c

4 X O z X o 44 C z 3 Z z O c z Z ctn c 3 X C 4 f - > c z 3 C

Z c n m 2 X f " X <r X c r r X r *c C m 2 4 O > » m m z 2 > ra 4 o 4 3

T: 3 m z C 3 m4 4X > 3 m c r r r r %m 3 X <

r r 3 4 c n > z4 > > X >> X m X cC X Z o c zr X 4 Xr r z O C z co C i > r >zX 3 X 3

m >z cX C ir r c X Xc n z Z C im o m C2 z 44 en X O

4 c2 O z

w cn

•;.c (I d c & (C

t- t' t' *- t' ^ S' t' U V4 V* U4 On W LM fU rufUnj r\3 ru fUru 3 X o c X 'C G 'C c c <s c c Oo 00 X 00 a X:> vn f-V»r\j-* o c 00 fU 3 00N O LT On fU -* -w O' \n Ü4fU - >o X •U O' vr rw X c cc •SjO' VI l\J-* X -c X N O' r *

(A z Z ru 4 » cn • • », z z rvc c t-* o O o 4 m o c wX z a cn 4 4 4 z o O z o 3 » X o

> r~ X X CA > 4 X X Z O z X M 2S > 3 z o r> cn K 3 z Z o z za X X -4 H % > m 4 o cn 3 cn c cn 3 O X X m •z o 4 4 4 n z 3 4 3 o o 3o « X cn C Z z c m m f- m o o r- X • m n m o cn cX X X cn O z a z r m 4 Z z z Ci z r cn m 4 Z z m 4 m 3 Zm r~ r~ l~ cr. m m m o cn 4 ff) 4 o z z 4 8 z o m z(A m r* C X Z • z cn cn o o m n X z cn

n z z 4 4 4 z r"c r~ cn nm B 3 c o 4 Z 3 o Ci o 3 z mX o X o Ci m o >

r X c m r 4 > m c m z z 7Ç4 r z z 4 r>o X 3 c c G > r% cn z e e r > > 4 mX o rr > Z cn o m 4 cn 4 m

■ X c 4 > m X 4 fTî z z z r 8 r- m Z 4z m m 4 z Z X r* z G 4 4 o z Z

X z -4 C f“ Œ < m o o o >o m f* o O o m LM m r X z 8 zX m o 2 < O m 4 r> X cncn m 3 z n 4 z z z Z cn X r-

» m cn c C o O 3 % 3 m n r- Ci r* 4 >X c 3 z z 3 14 4 o Ci 4X a a cn % r o c O n o

X ff)X en o n 8 c K X r- eo z > o cn z

c > <n z 4 3 o 4(A X m 4 m 4 8 # r- > > z 3 m c

CA(A f 4 z ZX ffi o O 4 m cn f- f- cno X 3 m z O 3 4 0 » 4 r- f- >

: m cn 8 3 m2 z cn 0> 4 m » a r* C i c 3

o o > m Z 7C 4 c 1 X CCA 3 o z w CD o O 4 o cn Ci r-4 o o z 3 0 0 z as m*• 3 r* n gi G% ZX m c o < c z 4 f4 • cn Ci z-4r- ® a 4 a 4 X cn 4 r- ITT c|— CA -< o X on z 4 cn LM :> z m z

3» -4 4 m 4 A 4 > m cn 9 3 z <->z X o O Z Ï - Z 4 cn o X 4 Ci n z 4c m « < O 4 ^ > 4 » m cn m

X % Z f- > z z > Z o m r> cn cn Om X cn f“ o Ci Z o > O 3 > r- z K 8 4 o m zCA m cn z • I- K > O f4 cn o zCA r> P“ o z . 1 - w Z 4 cn z 4 n X 4 c

X > r - 4 Î ® K m 4 o > 7^ > cno n z m ! c > cn f "

m > z Z 3 4 r>a X 4 c 4 X X

- 4 o U 4 z o Z o mX cn r- X r- 3 ‘ %# Z r- 4 O Ci zm c ' 4 o Z rn 3 cn

r* o Z o r cnX ■< c m > r> Î» |—HI m m m -I r~o c r* z o(A

-4 r> X -4

#) 0 ;3>

> <A ZŒ rr m m c- rc. cn o > en >## m « 0 4 0z - o N o

M O0 ao en >z 4 oN o > m X0 3 cnX n cnm cnm 4 ocn > oX K

I- • r-« a I• 4 z X en o4 • z

4 OD XOD W m \ > cnO o en 14 o

m

0 0 3 4 Z m 4 ZO 4%%4 Ht o OD 4 >en enœ4 I4 Oen X 4

1 4 >m 2X X

4 2 0

2 en r» o cn m ao c- < m > c o r“ a 4 cm <n fi 4 c 4 4 X

1 ) •) ) ) 1 ) ) > ) ) i i )

f* f' f' f'f- f'f" f' f' f-f'f' ^ ^ f'f'*- f* » f" f' r- f-1' f'f'X' J>c o c ocODX « X 00Oc 00X X HJ•MH|4 4 4 4 4 4 4 > a > : O' 0' O' Vi VI ViVI Vi %.ru 4 ■cceHlO Vfr- V4 ru-* -c00HjO- vnf'U4 ru 4 C -O» 4 3 VI Utru-» 2 'C % 4 O Vi f"V.ru-* ■

z < *. z X X 4 .4 > » Vf z Xf- X 4 X o m oc O o X 3 rrcn enC fi en C a %m 3 o < 3 4 4 z 4 4 z m m O o -n 3 a 4

m •Hm c z CA» > > enO > en f 2 z 4 C m Xf X Z H fi fi4 X fi 4 m • enO o « « 4 n z Cimf— m c K K > 7: > m K 4 4 O'c r- 4

3 > fi - X 4 X 4 3 O Zcn 9 4 K 0 9 ^ X a C4 O Ci 4 C Ci m cn K 2X m m z 3 X n 3 en 4 4 a zZ m en m X r" N cn r* en Ci

4 en 4 o ♦ m C m N ao CA > O en > X r(A fi X r- 8 4 C

r- m K n c 7C z f" 4 0 4 en X en *0m 3 c X en X X r* 3 m

o m m 3 4 4 3 z r 8 a 1 1 >o X > c V 8 >4 > 8 z 9Ci m c m X O X f- cn 4 2 • 4 Ci

Z m 4 X ^ 7 4 7 m 4 O Vi 9 C a cn X m■en z a X f- m m <

4 Z 4 2 m Z m 4 mX r> Ci > Ci z o X en O' c n4 X Ci 4 en 4 a c

K ^ n W z ri -* 3 > Km o Ci > Ci 4 OO O 4

3 •X 8 4 m 8 r* 2 4 X W m 3Cw. 4 Ci W • % > 4 9X m m ■> 4 9 3 » f- O 9K z o fi 2 O 9 4 W 9 > > K

o 4 4 X X VI 9 4 > X 9m r- r- 8 4 m > 4 X m 9

Ci X 4 z en r > Ci4 r fi <n > 4A m M K cn r* enV X 4 X K • V) 4 en en

X c n O < 4 en r- Ar" X z ♦ Ci > X VZ m r f- w oo X r* > I cn C % r- z 9c m % en 9o f- a 4 a s 4 4 Xj o 3 4 r en fi w X

m 4 4 ♦ 4 7C Z Xf- O C cn X X X 4 mo 4 X 3 M r*a * 4 2 C C

m < X Ci > Xr* X A f- 3z > »r- fU en Xr- M Ciru O 4-4 Cm 4X en Oc >

>1»»»3: vf\fvnuiuivnxfvfui\fcnvfiifvfv/ivf(f<jivfvnvn<fvn«fvfvfviis/ivntfvr<f*- C ' S f ' f - f ' f ' t ' t w W W v S L N L N L w U . W i N r v A J M r v r u ' x j r v M r u i v - * - » ^ ^

a 4 44 m X X X04 Z m 4 O r r X O# o Z c C z en 2 Z 4 cn cn •a 4 Z z X z C m z X 4 m 4 —t m a

a X z X 2 m c m X n > n X X z04 c o Hf Z n > X > r- o fr o 9 a Ci X» fi f- o C 4 o 4 fi ## 7: Z z K - z•z I-m r* O • m z 4 fi44 > X m S 7.W 3 3 > «t c z Ci Ci Z f» en z z w- ma z 4 z C X a4 > O : X cnX > 4 m04 X C X 4 z > o» CiZ Z z % > : z f)Ci Ci mX X 4 4 fi X 7:4 c m rrt 4 c en cnOt X X X Ci z o Z # X.» z > m en >X 3 X z X 4 fi4 m en m > 3» 7CO* 4 -n 4 f- O» z X ZX 3 X C C f' Z n

X Z z Z m >o. m o 7 » X 7» 4 r c 4 7Ka z cn O m m4 X 9 4 Ci Ci (— 7:04 Z m X ♦ z» > o zX r" r- Z m

cn > ■ Z04 4 X Z 4 7 î» C O K C f- f- m •;X r- Ci4 4 4 m 4 m f zOi X X Ci X 4» m 1 > Xa 4 a n.4 X Z cn *— en m04 4» z >.X 4 4 2 m m o

fi z 904 r> 4 4 o X» X Z r- m

Z en,4, 3 404 fi» Z C X ♦ Cia 4 n 4 r-!

o-n 9

♦)21

M»<s■HW»w

'•**■m-4CM»m

#

n n 1 1

-* 'C33N0'V1f-WM-» = O%Hl0'Vif'LNru-»CC%N?Ulf'WfU-.C'03:Hy»Lnf'W

X -* 1-1 s•H oX X X o cH» m o z X mI> o X -n X o (T.H* -y > cC I M X > r-

— iH c-n tH 2 X— es Cl m z > r~ X

X X ■< X X (A m -4 -H > ï»

X C Z X o r> X c X m z*• c 1

i O mz I OXtA CA X Ht t-i m X

> «; o zoo «A ►« c Ht Z Xo o X(A C X X

o t l& c

m m m X XC C = z z z3 m -I -4 -4

X o c > c3HlXOO-HX»ZX«Ar>2«ASSS -4 O X C

S> 4en c m a

z m4 XC O m 9 4 fi c 40X3> en 4 S

X r-

c X f- a o

X H > M X IZ r m94 Oen 4 a4 z nrN -t X X H

X > 4 4 m X X

X X > m

en en 34 4 f> fi1 fi C7 % X > 4 9 X Ci 7 9 Cit-s Ci X Ht

: C 4 Z m» m.cn X > o

O XX > > 4 Z 4O o z 4 en

9 :- 4 r - X X *» o > C A- » X H t m X - H z z X X « HB ' m z X o ( A X 9 4 4- 4 H t X X z C A O m T n OX o C C A m o C r - X 4 XO X - n 3- 4 X m mm X X C l P » X c C Am : c t-, m 2» m

« X e t » r * r -O ( A : tt c mo X • I Hz m c z -4X ( B z C l o Ht

» 0 - 4 t l O- 4 - 4 t-i - 4m H » X r - Ir~ o m X / A ,a z o m C E 1■ n Ht X Z 4- 4 > - 4 »O Z - 4 1 0 4 OO X m C l 4 Xr » m X X X m> O ( A » m encn X m » zm m a1 X m : z X» » X I o-4 C » Ht C iH t ( A |— mz O m - 4 Xo z :- 4 Xm Ht C A 7

X Z-4 -4 z C iC X- 4 X C XO z o X- -4 O- 4 t-t C l

O O C XZ >X X

1 1 1 1 1 1 1 (o rs rs >1o o f - »f i Xc 4 en 4% T 4 exm *

O X N O VI f ' Ut ru -À C 4 XCi 4

Ci X Xr - c X 4 O

a en X o 4 o% 4 œ c a 3 O r -o z o 1Ci f 4

7 s 4 Z m< 4

z % X wm X X X f -

a 4 -D X Xm Ci X > X m

X X r r 4 ISI u .c r - 4 X N »

Ci en Ci r r C i tu X

z X f ' Z uX X 4 *

| - Xz Z 4

4 4 04n 7Ci m X 1 X X

Ci X 4c O LMa m »

c m X XX X X 4

cn Ci CM4 2 *

f ' CDO OOZ ■ X iMen »

a30 O

Z a cmT> X »X o XO > 9 4

> C Wf i »

o C i m SODru w

2 o #"C > z Xr 4m ru w

O ' »r r O a

4z 04

f i V) OD »c ru O4 ru 4

TU > WO 4 »Z c a

cn 4W W

z # . »o Ci a

4I - 04

W O# »OD ru a

Zi CXsI V/ïf UJf\>4 O' tt tt a o- H| tt- V f' w tt> tt U1 v/l VA tjl VA -* C « tt HJ tt %A.r- = m(A c m oAI « tt (-1

o c o « — ttTI X 13 H Ht -4m I -n 3 m tt m - r*o o >- s c e -4 .X rr c

S tt X > c -4V 2 tttt 1 r»—4 Hi fnX m 2X H . IO X -4 io tt ». ■

o r» o r> » r»I o o -> fr > (A _) (A CA E «A CA <A (AI jx m m m m mI c -n X Ctt VA t' Ch=c m I- r r-m r> o (- I- r- (-m fr fr » . % % % .

o •o H,

«X -

f' n= »w i' O W X cfr tt-4 fro -4 tt O

■ ttX o X tt Cltt c 0 0 2 O fr tt 2 tt fr fr K

2 0X0tt 2 C A fr oH. X 2

fr -4 -4 r- «Am

- - z - o> CA fr (A o fr M H)' C SA C < X 2 2I HI rn H m .h -- 4 •H tt t t mo ru o i— -I o' X X fr m- r* - X tt o ' ” - t t -fr fr CA o oCA CA — i X2 m

X H m -4O m Xm o

o M r-i f- AttC — tt z # c z- 4 t t H# C -4 3 Z H, m 2-4 m X H, tt 2 X

O OX S7> 2 tt fr O 2 tt O fr TV ttI 2 X I HI fr O tt MW X O2 z m ».o -4 O O HI O -I tl O X ►4 mm

o fr tt -» X * fr X — I

1“ o HI ttr» f~.. O » H,■ «-4 r- f- o X »fr - cSA X SA X m Ht H4- 4 A4 o-* 2 m O • cX » HI-< tt I— — I »- CA Xfr M 2tt m O■< f- Ht- » r-

X »X r- H4 -< » z -4 a -4-4 ttISA m X-4

f r CA m o -4 tt X fr tt o o o X tt p-1-1 2 HtO fr r-H tt » -» X CA iH H4 ». Ht A4

2 -4O X fr ttSA O ' rr. o I i tt ro frZ C Ut _ .fr c .. 2 .. Ht

fr Z HCAI C X ru Z m « ol\) -4 SA

fr tt Oco -4 SAm C mX 2 ru m

ttm c m 2 C : tt

c

c fr fr z oSA X

-* s H. » J,

fr X c Ht tt fr tt X —4 m• ? v t i < o c : o ^m o c m X

o frHt XO m o fr r ~ HOC O rr: X Httt z a fromz »4 ,O 5 2 1 Z a O Ico Ht z X I- m Im -4 o ;

H z Ht Ht cz o •

2 tlfr CX CA 5 CA tl

C H Z 23 0 0 -4m X O a t-t —

= c o

fr m Hr~ o o oH tt tt rr 2 -t m tt fr X tt Ht H m frZ H| _4

** X C OO o H O X » o(n X Z m z H o

9 w o X O Cm c f i z c nX » mr * c c n v>"4 o -4 e n " Hw m > MC 3 c n o X- i X - 4 c »m m X X a a o

« z 2 ca O «4 2:- < X m Ci X c r»> w » o z -4z > 1“ Or o M 3 O1“ e n ^ e n Zm m 3 o -uX < n o > »

m » æ r>X V) z Œ -« 7 m 7o «H Si C mSi » w r>

r -4 X Ci3 X

m-4 m > 2

Z w

0 tO-4O zoo 50x z f r o f r o f r a c z "c- SA CA tt SA t_ tt H !rr rr. -Hmmmmmc ;0 rr I X I tt I o ttH 2 m fr _v -, frc • 4 Z , z XH t t V A C A t - O U t O C rr:;1 fr H. z Ht %''r - t i f r o f r o f r o fr ,fr c .r 5 = 5 • tt = : m z 'o » CA -4 5 Ht ‘i

-4 O SA C CA CA iZ O C fr -, a -t io a fr H fr fr ;tt frHxmofrzo»= tt X X Ht x io m m r- o z n, *c Ht o fr rr z fr iO C S A - I t t C T O C z , j m X -1 m >-i o » m o ïo m fr tt m tt X itt o fr o m fr

O f r X f - CA z ► « X ( ® “4 5 H CA o z m 4c- V- 2 0 5 H jm C fr C I o SA Io z tt X H o m - , , 1H 5 X m X tt z -I fr ,SA m tt m m o X o,f

o o f r t t m m X i fy: fr H CA fr ,i

— *• Ht -4 H H4 O 2 l|H S A C A O f r H I - 4 ttfr,i X m z o o C A c - ttifm S A 5 X z r r x i^ r - o • <. r * m . it t l A H t fr o f r - 4 o - jtt H C fr r- ilfr fr m SA C C m m iCA m fr Oi(5**1o o s m o rr fr CAm -4 -4SA o X X

= tto r -

m 5 i

§11 r r c I t t r r I

:?X r r i r r t t î

o o >

m m ICA (—CA O ;

3c oe- * c

-J -4 -U -Ij HI ->l C X *4 O' VA

o(A % c

H4-4NNOOOOUlt\j-vaC3CNO

-1 a X

m ( A>c -4

T) -» HI >> Ui -4 0

n

o o o o o oU1 04 %J -» C

S . 12 - 4 3

- V

VI VI U1 VIV/l V! Vt VTVI VI >C a N O'V: iN fU-k z o X

r >o c n

C 3 X m X X - "X % - i rr X O - n

m X - k H o c ov > z > r o C-% - u O X

- n r - z % Xf - > X o

7 O 3 •• 3. X C ' aX 7 < r « -

3 m X% « X > >

> 0 2 0- 4 X

XO o W O WZ w r -o 3o > C - ■

: X- H > O

c n O -4" 4 % O >O< X # 4 W

m f -r * u z

X : M mO O *« X

■ m1 a wo ' o

0> 04 O 04 O. OS O. 04 o-oot-uooifrsfrpa 0 4 f \ j r v j ( \ ; r o r v j f \ J f V J r u ' v iZ ' O O C ' U O V A B ' O . f V J ' H ;

- 4 Om 2X 3

r rc> Xz X -4 O

m fr

o r c X

oX O fr

X z n

T m Xf“ Z rr •r m X

» - A c M » o o rr

m ® X 1-4 z > X wm n X z O m m z o

c - X 4- X • X2 •• 2 X >

o 2 X Z 2o O X c o o

> c C O oo z Z X w

> f -r * H 2m VX V I :* o * A

VX m Xo X X X

X c o >C 2 O - 4

X f - O Xw >

r - 2 w 2r m > 2o 7 OX f - X r n

#-# X X X2 o o cC X % o z r -

ww 3 - 4 « 4

n o X 2 2XmX i-« X> O X-4 ♦ o

II

- 4 O' *%n W f U W c 'O 3B N O ' L n w n j C ^ X N O V I U 4 n o X - 4 O V I w r j - & z C X N O ' V I f ' L 4 f U ' C X N O ' V I " V - *• . > • • : - mo n c n o >c Ô o o -4 C O o o% z z n 2 X c > z X m c n 3 2 c c n c2 2 2 > C Z - 4 -4 X w 2 - f m X c •< X r > 3 X - 4 3 3 X -Nm m i-N r > > > c n - 4 m z • z 2 C - 4 cn N m > m

z > O' - 4 f i r > m z m w o 9 w X o z V » w r > z r> 2H • 4 2 7 7 X w z z 7 Z ^ O - 4 o 7 - i 7 - 4 7m p “ 2 o • -4 O - 4 X y > o X • r -r 7 f 2 m X 7 - 4 7 r % • c - 4 O 9C 2 •• c - < o X o o 3 o f - X o 3 o X • < 2 7 Cim X Z X »-t 3 o O 2 > X C Xm B H m m - 4 1 7 X - 4 7 » . H cn - 4 m X 2 c nm X ■ 4 - 4 f“ - < > 3 8 > - 4 » . — 4C X > c o -4 rt > z 3 > H 9 >Z • H X 2 o r > O X c X -4 X O z O -4 o •4z w X z 7 Z X 7 m m 2 7 mm C c 7 r * o C m O3 r X - 4 2 8 -4 f - w Z 3 I - 3O > rs O M 2 > c nX c n o o o X C£ O X ♦ 3 n X - 4 -4 X no 0 7 7 7 < - k m X o 7 m > 7 9ISI > 9Z m 3 X w X m ♦ X 8 n m V i > 2 f Po > > O o -4 O 1“ Oo o o X X w 7 c n o rtX r “ 7 7 f - H 7 H o X c n 7o m 3 > r *< X -4 M »-• » • 4 > w r> 2 8 8m X m n 7 > 7 OX r m X % W X X 7 X X Oo c X o > 2 - k 2 7 3 o o X Oo r - > z mo a 1 O 8 X n t 8 X 1c o > < n 7 7 O 2 -4

o X r * X 4 o X cX r\i X r * X- 4 Z -4 O » r " r - O XO » 3 c n ma > O X P S o 8 m - 4 X n r - >m - 4 2 X •f z > m 9 ■4r-i f C 8 m -4 f -z o X 9 Z -4 X o » 9 co z C z m . X z H ZZ 2 -4 m X 32 c n J O 3 O 3o - 4 3 c n •H I O z O•4 > Xn 3 > > c> O 7 3 . Z mX X 7 - 4 . Xm X o 3 ' w , m mo X X o > > o r X z

o Z X oO 3 o 7 mc n r - X y* z cn3 X 3 c - 4: » 7 1 " z r

o X cnm 7 w -4 - 4r > Or M ♦ - 4 3

O - & Z m 74- W m

X f "c n X♦ c n w o

% » 9 # ^

O' (r

HUiOiiuJWOWWU40iWW!>iWWfurufVJfVjrurur\ji\)ru'SJt\j»>jnjfUf\jf\jrofv>f\>(Njf\j(\ifvjPor\;rjrvjooiv)(\)f\jf\jrora<\irjroru(\)f\jf\jrjAJ(\)'vjrvjrvj .***-*-i-»-vc = c. = oc;aac:.e!C'0'0'0-C'0'0'00'0»aoo*ac3D3:3ï»(x-j'j-UHi-><'H-H-j->i'j3'00'0'0'i>>»'>0'VAvAcnvAvx'VAvA. At'OlfVJ-HC CX-U»O,t'Oif>J-*aC0t'UO'VA*' WfVJ-*C:-0»*sJ0'VA«'OIM-*C CX-U0'Ul*'O(M-»a>0X-J>U1t-U;f\J-»Z'0X-40'«r.t'U.

t X m» ru Hi z> H O *r> o

* rifr oZ 3

- C X H

C 33 I-». tt

TV H =

rr a H HtZ m X -nD rr Cl (Tl »- * HI =». * Z - -nC - Z

2 HI -n

C 2 Z O rt X

» 2 -nfr C

(A X ZH TV rtrt HI (ATV C-. -I

» rt o -»c H. a

= C Hr z X rvj rt rt fr

rt tt z X rr z fr -12 fr 2 rtTV -, r- O fr I-cn on ct X f“ti r— 5C |—

C t, C •• z C rt rt z rt 2 ot »

H Wt 5

TV X I-

m m a H wr- z m X tlCA o m zi m —

rr tt X c »- 2 H rt

HI Oz œ2 H ►» fr1 Œ3 O Cl2 rt fr C

X tt TV mHI fr<r. z » o

X HI 1-1|—2 f .m ». m2O 2

# — ■

I O HII Ct 2 I rt m: H tt I fr a : ft oI'TV Ct2 3fr frX tt TV TV

z w 2fr m 2 H 2 mo m 2 tt 2 a

I HHI C

C CA Z »-

J J

'.W W W L W> O O > > O O' > O 'N O \jy t- L N n j <s a > L n f' f U - * - % O '

am o o - 4z f - X o3 c r H z XX n Xa Z c n m c n > » oa W z z z XO o c 9 tn*0 X a XfT> f - c m m

Z Œo m > r r - 9 r r

> z z9 r - c 9 9r u m P “ M > r om • 4 9n n O r c nw C B M oA X Œ ■V m z X9 r~ 7 c ao c n -4 XT 5 a > - 4f P N n • <X O m T“ 3 X> z 9 m m m Nz 3 9 f cn9 O 3 7 o m9 z o 3> cn 33 c n z w O c n9 Z > X> 9 r > o7o Oo C 3V> (A H » 2

o m z«A CA "4 fr > 2 z m -*Ir*fr r*

o

m ( - z

Z - z -n

- tt

O tu * IT!

Z I - 9 ■r- o

m

o tt a o m -X X a H, z« - ( - Z - ( A

« « tta a oH i H , tt H H

O Oe CA

C O ttœ a <n

o o o o

2 tt rr.2 HZ fr

tt r- » r- o «•

tt o

X H, m c « Z 2 Z

VI tt z 2 H m

Z H, tt H C: ttz c

r 2 §

fr I c•H -n Zmer» o z2 -t rr 2 fr 2 m mO 2 TV t t C

Cl c r-l Z

m frtt 2 TVtt MX B>

tt m•4tt rum mm z

H "4fr C tt tt Z ttC I”

0 $

i

> fr> f r \ i >

fr fr fr fr fr fr frfrfrfrfrfrUiUf \A fr U. fV Cf r f r f r f r f r f r f r f r f r f r f r f r f r f r f r f r * ^ * . * - f r f r ^ * . * ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ . .U«»MLNWUiWWUiWWMr\Ji\if\jr\;rur\3l\3r\3ru—».*— — — — — — — — —'Cœ*>jO'ij!fru.f\j-»c>oa>j><jifro»i\j'He'OocH&mfrUjru-ie-oa"sô'ùrjfrCjrüHkeW W W W W W W W l M W W W W W U i c-c-o-c ■O'C'O'C'C'Oxaaat.<!OS'NjfrVAfrO.M-‘w'Cœ'Ufru>

z 23 2X X m

z N

m ■X cc =X ï - > (A

X -, m fr

rt o AO fr

tt Mm rsi

z c (A

X z mc H, 2 c

« H - z m ► -z » . m 2 zH O -m 2 ttC l « H

fr C C c c e_

< ». t-,

3 H H Im z t l

3 2 2

H» fr |— O I T V

O l-i

• 9 X • • • • « - • m w X r z• O m Z 9 m m m X -4 W m -s z -<c X rr. O C f- rn f-9 w z O • X o X c ffim • en en« Z m m - X z z -4 en o mz « X %» w Xw 7m 3 X r- ao ■< cn 7m a rr 9 Hi 7-c 9 8 N Z X W » r*-H O m w > I X %o en r f- o z >s -4 en Xen r > r- •4 -4 w 7H w m 8 8 X I -N■> 7 V m m Xf- Om 7 8 o 3 X a r- C o3 X X X o r” ••9 O 2 a Sfr ■> *< I- 7 X X z3 ■ X H7 m m o z z -fr- m -#w en en 2f- H m f- r- o -4% > X 8 r- r- -4 X 7o I <a X V) 3X w >-4 -4 c c lu X3 n m en W W mc O enH s z cn Z m wX -< -4 -4 1— aH > 1m f- c z f-<n 7 r- a ow en 1 a -H-4 O 3 f-> ar> X X7 7 o mc cni % 2 w on# r Vo r* m r- -# 1“r a♦ r* f-1“ r* a -< 1r* m cX zX en oM XN

O2 -X -, HI mm m X t l z

n O a

O'lAfrU«'NJ-» iO0c.>ifrvAfrU<(V|.*e>C'30.U <U,fr»MfU —i-Z Ha c • u -4 mm m X 1 «-# X Xw 2 X z m X T l r > r -

m c m o m • n o n H> 2 •• X f- mm r - - 4 ». X - X z m c zc X 9 e z z - X * :C > - X m2 2 4 * m 3:* 4 O X c • 7H f- )» X 1“3 fT* z «<9 m Xo f - 9 ■r r X X W ff)X X X o r ^^ 9 m 1c XX Ci o mm § c - |o r * B c -3 C> 3 H O > r - CASm X 97 X O7 > X c m :f > w =O z f - H l ]e n 9 ♦ i - jV X C A »•!# 4 r - r u >X r - 1X X m r o co c > w - »o z O ' 2 f r ?

f r iX c n a .Xo l u >

X aTVr~

O !• 0)o m X 1 m jm - 4 tt|> 3 3 m3 X z iX c c o lX c I3 z - 3 H * ir ~ r -|3 X O m ••1O H XX m c-< 3 X A fM m > r* fr * M z Vm o o !3 X î

X fH o fM X< % #

U)»03HW»

U

c c r» c c H Z Xfrfrfr fr fr fO ufruifv— Z'COi-tO oifruMfv- O'COî.miOvA . = 'C0s*»O'V/‘‘ u«ru—-cr a.

X X X X X X r ~ r ~ r ~ r - r r - t ~ r ' t ~ r ~ r

« H M«A (A cr en (r (A <A CA

3 Ï Z Z Z Â 3 3 Z Z r Z Z 2 2 Z 3 Z Z 3 â .frfrfrfrfrfrfrfrfrfrfrfrfrfrfrfrfrfr***-»-x x x x x x x x x x x x x x x x x x x x x

fr -1 -i -» H -1 —I -C —I H -i X x x x x x x x x x x X c. Cl c. C“ c- c. en C) cv c c H.

tnCACACACASACACA —i—i—«—«H—1-4—I (A CA CA CA CA CA

Z Z 2 X 2 Z ifr fr fr fr fr fr frX X X X X X Xr r r t- r r rH, H, H» M Ht H, H.CA CA CA CA CA CA CA

H. I Z -4 C

“4 fr cr fr u. «V -* Xi z c o o c m

— 4 C A H * C lm X r ►-V -1 z

X X X X Xc- r c c c X X X X X X XC l c c. c. c. c. c.X X Xc* c. c X X X X XXX Cl c. c

f- r r- «- 1- r- f-r~ 1- r r e- r r f-r r r f-r r r r f- r r r-r-n r f-r zc o c c c c c c c.o c c o c o c c o c o c c c o c G o G c G C c wm fi m ri r> rt r> n r, i~> n (t et et et o o o o o o o o o o o O O %■> > > > » fr fr fr fr fr frfr fr fr fr fr fr> > > > > > > > > > > 7 >W W W w -4 -4 -t -4 -4 -4 -4X X w w w w w w w w w w —4 w». ►. «t H4 ►. H. HtO C C O C C C c c O C C G c c c-o C!o c c G o o c G c c G o G2 z z r z z z z z z z z z 2 2 2 2 2 — 2 2 2 2 2 2 2 2 2 z

X X f» f» fN H H H H H H H H HX t! "Tl X CA o o et 3 en X O O O z -nenCiX 7 X r W Z O O rr.rr.c c c c c c c c X z c z m w X 2 c z TT C -1 c C C X > > > c c rz t s: 3 z z z z fr t_ 3 fr 3 c 3 > 2 2 c w 7 TTi3 rr rr. 3 r> r> r> n et 3 X c ri O m 3.m O X 3 3-4 TV X H fr tt7 » ri •< z 3 7 W enX C rr rrrrX Z CA 2 fr frct X > w w o X a 2 7 % w o a > Z Z 2c fr -4 rr t? oc r-l W 3 % ttc X -N3 2 m Ci o aZ 3 fr S en c -c tr> z c 7 O > rren X Xrr m c pt o L_tt enT 9 -4 o c X w 7 X X w %CA TV tt o Cl ». m C X C a Œ w Z 7 m X O X > > W -<CiX o X Lu pt % c c rs w % enz C> > X 9 w O a 2 Xw o % fr Cl O w c 5c X c 2 2 3 > w X o m 2 r 7 rrentt Pt Cl CJ » L- o o % 7 Ci G CiX —4mï r-i (T o —« o Pt Cl r ». c rs w :w 7 % co O n Z i- z r-l CA » 3 Z N4 % : X Z CiC LU Z 3 c X c_l c X 5 3 tt 3 z fr o X rrC.3 w 3.Cl » X fr O X Ci C 3 spero X3 » f H Pt S » ». m œ frO 3 % X C w w 7 Ci G w 7 m(= X s» jvi-PtCîO : o w z 2 S> > Ci Ci OX X = fri_zxs G rt tt CA en X :X :> Tlo X W a*t C X PtX z G X C3 X H C X w X 'k Citt X c 7 w Ci Z % > Ci» r> Z C O fr -» > > : o X 7 2 > := r» z Pt Œ LJ 0 3 0 > 3 X c X n X w ir Oc * m ü X z et G S» en7 a w > 7 > X > ZC fr CA ». O X 5 r- o t» Cl C (TX o w o % z W wZ 3 -4 3 CA Cl ».et c O a : H 7 m c w m o >rj rr fr m X pt I ». c w n 2 2 Ci en X z r ws X ».X o Z fr O fr z "O c w TTi : w X >X o TV o r» ». m ## O z CiCi X O XZ oc. » TV c fr 3 X en a > : %. X a rr.z rt = X 00 et CAo X w z Z 2Cl c en CA c_ X X o o a rr > 7 o Wrt o en rurs Ci w o % m o w CiCi Ci-4 X o Cl l»C X * m o z w 7 X X >fr C ». rt m fr M en Ci Ci w o Ciw-* O tt z X c OC (S z Ci w O z c rWl ». X o c »• z r- G LJ-H tu o o Ci Ci X rrLJ fr. z X c-i m X :> m Ci m %.o CA rt c : o m z Ci zCl X z X «A 7 3 0 > >rt rt «A et ». Ch TD X Ci Xe x N Ci : o 7 7

X CA rt cn en O w ceX X X en ru w ftfr tsC eu CA ct z m O Ci Ciz m X u. c Ciet eu CA = z «H

3 rr. X X W . 3DH c z rt! ». r s

%. lOo

C: H .H. r3 CA fr - t X

c. - HŒ Ch- : t- -4

Z It »

W*aUi»

n n

S o Ga-u<>'J?frU4fO-‘C'0X-U9-oifrLMfV)-*G«30-u>vrfr.u,ru-kGO3e-u0.Oi

H H H M—4 rr rn m OX fr r- r- I- ttm rn m c

tt «ntt o o p -c tt I HIIt m fr -4* tt mz fr tt z m frc H, I-

tt o P "r r (/> r > t! m m o% m fr c r - I - tt■fr P " r -z m c H fr

H» tt z (A H,

f~ fr P - Œm r X ( A mHI m CA«A r~

rr

H, Cl tt

z m m frct z z P- o■n H Z c z-4 fr mtt tt

r n o r i i ' n ^ l - n f r c I z t t 3 » . V C Z ( A I

Z m (A ct -I

o tt ttct c H X HI rr.o z

m tt CA P" m I m o X I 3 rr, tt I rr Hi c I z c PI I -4 H mz c

Cl c tt

It (A 3 E C Hi

H Z H O H Ctm I r- tt -H

■fi c c CA Z met CA

Hi -» Ce 3 fr

c E m «ACA(A 3 1 X (—X Z z -4 m c Z 1 ttm -4 Ctto frtt(Az -4 1 o oc c Ct z -4PI 1 ctz tt X X X (t fr O 1-4 c -4P» o tz z X X X X o X c 1 C mr~ fr ClClCl3 z Clct 1 Oz Z X -4 1 cfrZ o Clo 1 o zO r - 3 P> m O 1 r- 33 Z m Z fr Z 1 fr p*fr 1 tt P* 1 r- o (Stu o t- X X 1n cCtm X 43 Cl 1mz tt Cl X 1 p z PIo Cl Cl Xz XCl s Cl (À

o a,' • I -nfr c c z V)

■ 3 ■O Z t, fr VA frCm rvj -i C _4X zttO m

Z 4- X -4 X X 3 ct1 O 3 3 C r-1 z E 3 m ct (ACAm tt m CA11 Z -4 (- X -4i «H -4 1- tt tfi1 Z (A -4 (A 3 m X1 O fr ct Cl1 -4m fr z -4 rr1 frX tt 1- z c r~ 0 41 z m m m c m tj1 (T c tt1 m fr X iH X rri f- C Z tt CA1 3 c HI 3 3 HI1 m r* m Ct CA X r -1 tt• -4 X m Cl1 X 1 c -i

HI z tt z -4 z tt tt rr z 3 m HI H X «A CA 3 m - -4

tt m fr X -4 m tt » z tt -4 -4O m m ct m X z c

X1cttXCA3

• m m 3 tt X1 I- o c m m z1 tt 1“ CA r~ X1 3 tt rr m m tt1 m z 3 3 G1 Z1 -4 tt z HI z m

r r c z — t o

m o H ClCA z Z • 3 m cm c X z m X

z o z tt 3 m H m c z -4 p-- n m t t tt: m C z m tt r p * f r z m r " m o C A z o ■ <E tt fr H,HI m CA 2 ttz H o O OCX Z

t t m z

o

H z I N

n n n

H M mm c w iX m n 2 m Xm • y > 9 c/î o m2 m • W W w 2• m • > » z «r m > «m 7 Om

* C " C ' O -C C ' C c < c c X X X OC'uM r u c X - u > ^ U i f U c o X N 3

9czz X -4 w W M

X T l m W 9 X Tl% c m • m rt » m «w w Z 2 X 2 z• z • m m

r - z m 2• m w r m w Z

C i 2 m z Z o£ O w W 3 C ww X w c X W Z W m 9 m zn "0 O w 9 Z wf - z c n m w 9 e n

c X wX « n w 9 mm cn z z e n m C i O

> n A « 2 m2 J) w m a s # X 9 9

w o C i WX M * m w w

m Xo r *. c n C C C

> T l C iH o P S > m zm m z E e n w C ■

f 9 9c W 7 W •

X X 3 « w 2 om m W

Z r - m m wm m - 4 m 2 f " z >

2 m w 2 Zw w 2 m O OX O Z w •

m m ' U w z 92 > W 9 w 9

m ♦ w e n m Z 9W r * w u < w w OX m W 9 9 C > C im X m m w 9

m w s w Tl >"U z c m 7 C 3

- 4 G 9 Zo m z Tl J o 9o m W C iX en n o w :> m o c n% m < X z wo > m 7

w 9 r * o o 9c n X m C m w

m m m9 > c n w X

z z C i Z mo w r - w 9m o W mf“ X œX > o wo • H f- Z C i9 m

9 c9» > 7 Z A1" 9 O VoZ O w9 9 Xm r* mm 9Z c n m

c n

r- Om 3X mm wz Xw zC i

C iZ3#

1 1 1 i ) 0 0 »

X X 00 X "U N "N -u-U O'fr O'O' o O'> O' enLw PU w < X O' t'w -* c G % N O en f' T U ■Z 'ô X o%, 3 3

X mm W w w m c n en c n o

9 9 m m r* 9 O m C i w X X m X w wm w 7 z m c 9 9 m o > w > > Z Z% o C i z rr E z z e n C i ficr- X r» w 9 w m X Kri n r w r- W m W 9 z en fiz m n p- X X r P- Ci C c m X < f - C 7

f - o m o > 9 r- > z zz s # C i 9 z w m 7 X m z r 9

X C X G c C i cC r f- c m r*m X m >

r > r m r X X c m cn f-w m m X fi X 9 r-cn n9 n 3 C i 99 r n X o 9 9 9 9 r

en C P i T - c Ci C i C i CO 7 w w

X m X w cf- m fiZ 7m m ma r* p- p- cn 3m o m m C3 C2> o m zr- z Z mr-

X mr*r- 33 mzC 3 7 mc n z

X <r- o

z z o o

n>1»*O o o

Oc 0: ti H tj -» Z C 33 -u fr titlti Nfrfr VAfrOir\3-»C o (Xfr' fr fr fr tg fr un frfr fr vn V) VI VIV 1 V lV lV IV lV î f r f r f r f r f r f r f r f r f r f r O .O .V 4 O 4 0 4 U vifru>rv;-»c 'O0ctifrv>frUii\>-*C'O3ctgfrvifr04 o. 04 GX*ufrVlfr0.tj.H

r- z m X zHt - *m- g m fr Cl z M*• m z

H X

» . A » . V

m m tt Z mX z m - 4 r - XH t o 3: » r ~ H .

3 = z m 3m H. z H z m 4H —4c r fr z r r X z

o 11 tt

z X HH » frr - H P I

m mz

t t o3 c fr zz =

z -4m fr

X c -4►- z tt » -4 PI fr M —4 <t Clz H m z ». c H

Z 2 05fr fr frr~ PII— 0 Xz o -4

Cl Z mm o z z m t l M z P I m w z zX m -4 H X c z H -4 XZ-4HI (A tt HI % PI tt H. HI tl tt O DH -4 fr fr ^ PI fr O -4 HI fr tt

X PI fr3 m r >

c » . o tt E Z m 3

3 tf~ o fr Hr * m H I fr«• t l z

zz H I ttCI z o

H» I

c X z r~ o

X z m r

z. 3 m mt~ CArr HI3 3 4T1 Z Z f- —I fr

- m m z - 4 H ,3 » . f - Z m z tl» . C A c 4 P z C l m m

m - — 4 -4 H zfr tt z - mP I f r H r *m X P S r n

X z mC Cl 3 z

zC A tt -4 O

04»C D• H0 4»as

cCAPI »•O

3*8r3*8T3*Br3fcBT3»BT3*BT3*0T3*BT3*BT3»BT3*BT3*8T3*BT3*BT3*BT3*BT3*BT3*BT3*0T3*BT3*BTa»BTJ»BT.5»BT5*BTi*BT3*Bl

TING OF :2ZZZZZZZZZZN.END(22/> PRODUCED ON 31MAR82 AT 17.32,44PUT BY LISTFILE IN •;TLFAK-lU.HPSHlTH • ON 16AU682 AT 10.53,23 USING 1381lENT END(22/>

01 'ENTRY*(28);2 newline;3 'CODE'4 'BEGIN*5 SUSWTCLITERAL' (CD)6 'END' ;7 'ENTRY'(20);8V 'FOR' KG U 'STEP' 1 'UNTIL' OBJ STR10 '00' OBJECT STRING DGCKGD I* EMPTY M;1 1 CURRENT LINE 16 :* O;12 FUNC NEST DEPTH IG !* -1 ;13 OSEL M(0>;14 START 0 LL:15 LEXIS pg;10 REPEAT MCSTART Ü LL);17 MEM MARK IG :* o;18 'CODE'19 'BEGIN'20 SUSWT('LITERAL'(LE))21 'END';22 ♦ENTRY*(21 );2324 *COMMENT* TO REFRESH VARIABLES AFTER II25 OBJ tab 0GC21J :■ -1 ;26 PROGMARK IG :■ i;27 STACK MARK IG :■ -1;28 START HERE IG %# 1 ;29 FUNC NEST DEPTH IG :■ -1:30 MEM MARK IG :■ 0; •3132 'ENTRY*(22);33 RESTART LC:34 CURRENT LINE IG:"0 ;35 RUN TIME PROG MARK IG :■ START HERE IG36 PROGRAM DGCRUN TIME PROG MARK IG] :■ 037 ISEL M(0);38 FUNC STC MARK IG :** O;39 START 1 LL;40 LEXIS pg;41 REPEAT M(START 1 LL);42 •CODE'43 'BEGIN*44 SJUSWT( 'LITERAL' (OK) )45 'END' ;46 'ENTRY'(27);47 MAP pg;48 ONL m;49 'CODE'50 'BEGIN'51 SUSWTCLITERAL'(MA))52 'END' ;53 'END'54 'FINISH'55 'STOP'56

fcBT3*BT3*BT3<rBT3*BT3*BT3*BT3*BT3*BT3*BT3*BT3*BT3*BT8*BT3*BT3*BT3*BT3*BT3*BT3*BT3*BT3*BT3*BT3*BT3*BT3*BT3*8T3

tjOvrc-v.rv-^C'CCxtiO vi-#'CHr\j.*c:'CX*>jo vPC'u.(NJ-»C'CCx*uO vr lu ru<«r. mc<« zr. t-ccfrABVAVAf rCCC - 4 C C z Z t t Z V B B » ~ a . S — i f r Z H f r Oc IP z H" m c r m —i »- z X r~X r- H z c

+ C * H 2 m w | T ! e . . N I -n.t- CZfrCT Z ». V C IP • H m X c c z mo z m HI riz fr » I- -,fr t t C H H>X HI C

Hi BZ ŒC- -1

cn HI ru

lu Cz u

2 Lwa »

-» wtg *Z U4 oc »

«: tP o o tp Z Cl*> C C - C -i c. Or- z 3 -I fr z -4c (P z HI m % crr. —( H t r X I V »» X t- -4 r c -»r v » rr. » fr > cLP TV » fv 3 3.

f r f v r N . r r. fr 3

X fr 3 fr -H zc z m z fr r HI

w- H\ w HI

K> >:o o r »c ac w an3 9 wf' »v-*X <3a •uD erz iNru w c -s XcA m V A V A ► a 1 + XV a a c z c•CODN O'er fim X f-Z X 3 3 3 3 X X» Xü* % % > > > > C cn> % 7 7 7 7 7 Xs 7 fnrr.m m m fn ru rm 7 X c X a X Lk wm fr.X rr.X C c r -a a c C a > r rc c r- n r f - r 7 cnc f - «-M n w w w w 7 rr•Ni r r r r w rrX aH z z z z z a c INJ ar c 37 ÎÜ z

X2 f-n Cf- -H Ck

m n acz > ut7 f-f Xc ucn aX X9 a u3 2 ac arX o*a

— -Z ZX. — u » H . h k u v

z ►. -4 HI Ht

L L

0 4»z

*■ fr f f f fr fr fr frV'U.WLHCfrlAlXlwWWMMruiVfUfVIVfVnjrv-*-»..-!atizwnfrWM-JCcz-uO'V'fr4prv»~c,<ot*vo'Vfrt».fv>-*c.'Cz-gaH X > X

c c c c c c c< p c p cp (P c n (/) c pm rr. r r m fTi m m

r*itsfrzz>frfr( p z r - fr - ,

o- V» CT V vr w V CP vn cr cr cp cr. cr cr H Hi r a a » fic < •C c ■c C c <■ c- ■c ■C Oc a a 0 0 ce oc (X ZOetitltitltl-v-V Z rs X a a > > > Cc <> a tl o fr u rv 45 a tl 0 CP fr rv -» c "C Olt. 0 fr Ch ClC fs z a a > C zz > m> C # z er—, c rrw >»c c c c c c c Ct c C c c c c C C c C. c X ex s. X %>c.c X c X c t. c c c X c c X c X c X C X c X C X X c r: > >IVCT rv LTrv LTrv vt rv fr fr fr fr fr Ch -» Ch Ch (h Ch w 7 > a a art e. •o A <0 a tj 3 l-i c -, c r~ a > m c f- e; 0 1 4- -< z fi aN cac ru0 u >

+ 4- 4- 4- 4- 4- 4- 4- 4- 4- 4- 4- 4- o >+ rv tl fr Ch ru(fr O' C <C Ct a cr rv C c -C 45 <0 ■C•f V 4- rv + O 4- & 4- 4- O' 4- c 4- 4- ©■ 4- 0 4- 0 0 0 aa fr ■C Ct tl <c Oc OC -> C 4- a 4- Z 4- oc <■fr Or.fr a fr frU V. W tl rv rv c*i cr t! C 0 0 cn45 fr 45 Ch cLU<> C fr tj a ct ct rv O' (X Ch OC rv cr rv rv Ch 4>fr0 cr Ch tl X

• 4 >ru

tt tt tt tt tt rt rt tt rt tt rt rt r*.rt r». rt rt rt rt rt rt Xo C O C C c 0 0 0 c c c 0 c C 0 0 c C C 0 C 0 0 0 c 0 0 >c- O -* o 0 c c C 0 Ct c -i 0 c 0 C c 0 c c c c C 0 rO c C: (fr c (fr c fr c c 0 rv 0 0-c o- c o- O' c 0 C3 0 Cic c 0 c c c c c 0 0 0 0 c c c c c c c c C mo c o c. c 0 0 0 c 0 0 c c 0 0 c c 0 0 0 0 0 CLP rv u, rv fr fr fr -» fr fr -» Ch -» Ch (h Ch Ch cU. -» IV CT ti fr 0 Cri cr rv cr cr tl frO' fr cr. frfr Ch Cho. c fr C tj w, w rv fr tl frc 0 a Ch frc Ch cn Ch

mt ~ f ~ r ' » - t ~ f r > r ~ t / t i ~ f n t ~ a : r ~ o t ~ r - i r t n T ~ t f > r ~ v > i ~ t n r ~ t r > r ~ i / > t ~ c c o z C H O H O H o c o m o o c ? —, o - » o - 4 0 H o - 4 V 3 - , r r X>c>cC>c0X0><0>cXXZXft>cCX0>cC>:0>«C><C3

n X r t Ci z o o o o i t r t r rZH

O O C O O O O C O O O C O O O O O O O O O C O O O C C C C P

-‘u.'-‘u;-»u;-»04-*i>.'-»rv-»ru-*rü-iro-»rv-»rvi-oro'OrNJOru frVIfrfrfr-MU.'ruViCIV'OHOC-itilOO'OW’Cfr^UI&'IVU,.^ t j r u L H v f r c O '- u c x ’ U "—‘ i> J C O - * - » t > < o c f r v i f r r o v p o- -u c

0 f S r s >0 0 r0 c ac wZ 9 wm

- » X cc9 w a e#.C

> w X a*c f -c uc - 4 «r

X> u

r0 r r Z

C Ze rr. %

c Z »c r * aa

urr.0 r aw

> u7 »z 1wX c 0ce X 3c 9 C

e nw 2

c02 X 9

X »c a> 0 c

f i Z e >f i »r a

ow > u .c 0 »Ci Z aa , w0 r u r u

a0 > 3 aX w >m uf ï a »7 0 cw tr > u*X •u »> a

Ui w0 < u»

»w ae n09 z cr r Ci a%> uw L W »m a a«n

rt *** >to r - » o *H œc n V P f r fr fr f r fr fr fr fr fr 0 4 0 4 0 4 C h 0 4 C h C h 0 4 0 4 t v I V ^ r v t v r v t v _ k _ k 4 ^ % X H- * c o O S u a fr C h r v <3 a t j fr fr C m t v «C 0 5 t j fr v r f r C M r v -* -0 oc t j fr P O •o X ^ U w f U - k X Z H

W XcnH>

XX

§ c rm

</>m

Cf)c

(/> mert

mf - >

X <-1 cX

w — » Xo

- C * w o V ) o Xfl r t S m > m o > »o c n c n c n c n c n c r c n c n c n c n c r c n c r c n c n - 4 r t t - X X > o i/t H C O » m c/><c ■c c ■ o ■c o <c <o < 0 4 5 OS 0 5 O B O C o c 0 9 O c oc 0 0 O B t j t j t j t j t j Z m 4) r s X X X > c •H m m m »<c (X O ' fr o . r v « O C t j f r Olr v <= - c o c t j » f r r t X Z X X > c c (/) » H> 2J m X w 4 Xc •X X o z » f - 4c- 4

m >> > w

mX

*» I Î m X

c c o c c C 0 4 c o c c C C C X Cm -Sj > > m m *c c X X a. c c c X X o X X c X c X X X C > > (A *r v v n r v V I r v c n r v fr f r f r f r f r 0 4 C h Cj4 Ol C M « - -4 fr X 3 X w o * cr t A o o c - V 3 s H o r - o c > I X c m 1- 25 o • 4 -t S X » r w» m C h!= » w 4O f r r v • U * r -C l C M w »

f N * V .4 4 4 4 4 4 4 4 4 4 4 4 f r »+ f V t j fr C m - k - » r v fr » X» o <o 45 0 4 O C c n t j 4 5 4 5 4 5 4 ) 45 4 5 f t J f U w *+ c n + r v 4 O' 4 O 4 4 o 4 45 4 - 4 4 f r 4 f r 4 f r fr fr fr a 9 * co s fr ■o 4 5 0 4 t l 4 5 O S O C O B 4 O c 4 as 4 o c X 45 c 4"fra fr 00 fr fr o. o. 0 4 t j r v t v 0 4 t j O fr c n •c f r 4 5 Cm 4 5 t v o O s7 4• V » 0 4 o fr t j O ' V P 0 4 0 4 r v O ' 0 4 0 4 o c r v c n r v , c f r fr t l X 4 X 3r v n 4 v > W>. H 4

43 r-

Xrt«trsrtrsrtrtrtrtitrtitrtrtH.r*irtrtrsitrKrtrtttrsrsrt(txO O O O O C O O O O O O C C O O C C i C O O C O O C O C C f ro o o - » o o c o o o c t h c - » o - * c c o o o c c o o o c o z c r v o c o > a o o f r o o o 0'0 f\jo0'00'00'0 o-o0'0 >o o o o c o o o o o o o o o o o o c o o o o o o o o c o o m c c o o o o o o o o o o o o o c o o o o c o o o o o o cruviirvcnivvprvuiiNj fr-»fr-»fr— .(.h-tlh-tLh-tlhO i>J*'-*lh-*rv-*-tcui'4fr ihcncvjcfi, vntjfrO'frc»ifrfrOiWm w C t i - k f r C 3 - * 0 'a c n u i r N J f r - » t i - » f r C - » 0 '0 'c r w f r o w c P l h rv(“ r-i->r“ w»r“ epr“ (pr-crr-or-f-r-spr“ W)i-(rtr*rrtr” «»^«r-O O O Z O H O H O - U O O ' O i O O O C H O ' H O H O H O H O H mx x x o x o x o x c x x x x x o x o x o x o x o x o x c io X o r, X o m r»,o m o m

o o o o o o o o o o o o o o o c o o o o o o o o o o o o c nw-»w-*w-»w-&w-*rv r\i rv-&ru-hrv r\) fv rv rv frvpfrfrfruiCNtvjMcru'0-»a»-»-vao>ocjiofr'Cwo'f\iOj-» Nrvwwio»NO»cm-»ChOO'-h-hwoDfrwifrf\)cm ». *v <o

w»

c a.-* aX

a a- <Ca ■M O u.TV-Ac-cor o- CO TV•as> > c> fUe-> 1 1 1 1z r 1 1> > > V V V V o n V V O> > *» &» •4- f e.e.-e; aro%»C *■ & *> c c c♦ 5 *■ r- ISr c X-C C » X .cr>. + Ë.G, rr. w w a X- -4a a ■M>c •>1c m >> o m r> c rr;C> - 4 -MC %r*» -c 1 tZ -si V V-4 z-4 c e.e. zr>>C rv >-

C cx > > co - 4 >c Cf > zZ o-< >z or c-1 C rc TTîcrC- 4>- 4CmmIzzmm-4Zrr.

1 zmcr>cn

r\j-»C'Ca-NiO'Wm IT cCO - < I - X -4 IT C XCO rr, c rv -H cr —) COc C CO IT, X X -4c. c

Z. 2 - 4

CO TC T-

L

rufu(\)f\.r\jrjfv;rv;ru-i-i-» — -i—» OcNO'crfCwiv — ccOLsiO cr rv -» c <C oc -4 » sT f' Lw rv -s c

r*i IS >o I- *C » H C

z r > m > c c « - / c r

-4 -4 z cX X C H Z

^ c -,C. C OS CZ Z W ^ zrj c► 1 - 4 Xo *- cZ O »• XZ O-s

i w

I cV CO

r c m sI c r V m

XXI-,

C. z:> *1C «0

X X IT,>> C I-• > C X rr% c■H m X COX -4 X IT.

X <.- X t o ►-m c mw m c c CO o |- —1

-4 0-4 0C X > -n

X c cI- c I- r— X r r X

r > > > I- r - * T~ r r m > o o

T CO ^ V> T

I z1-0-4I -c «Z X c r> o >- 4 X - 4

O W COz :« 0 ■ - 4

O X zl-i o m #» z

■H O m z o »

>r* »M C

M TV IV fVrv rv _k wk X Xu. IK rv c <r X o *-Ui rv CZo o c - V Ui -4» - i œ-4 z z cU o r 1 V! X XI-» zI o V -4 > c r r>a V c -H> rv X •4X m -4 SLX z c a z O > c Xa c r X a o z crX m K n c o* c o C o o r>c o -4 c X% X 1c X c z c t/) C X X-H V X Cr c > C •Ho c X m» tr. a Ci % c z Mcc r 1c r : rr-4 m Zc c c V rr «4 C rr. Cw o z r c w Z r» X o a %r. O c c -4 rrc -4 —4 c-T» Z rr. Z- 4 c X c c rr. - 4C z O x~ t X E X r» Z m I X TC rr. «-I C >• H X r —4 o %» n > 7 rW O o X r> X H r t rr» X o c C X m ma X Z X X <r Or) rr. r r rUi X. X c X X a» > X c X o o XŒ X z m t/i-4 c o Cft t/7 z r r rO* X rr m c» o 2 V z z -4 <4tr -4 rr. - 4 Z X—t m en o t/iu c E c» f) •4 -4 C cCE z % c Z co X XZ» r c X o oes o » X >o o z w c oiM X O r" o z» m o ccr m -4 Œ r rv fV- 4 c I O oUi rr\ o c > 3» m m z X - 4o > JO >c o Xrr X # # aw 3 f P - 4 a f V

CEW»w

r- t~ c r-

ŒOI»«r

n o o o o o o o n 1 n

*c:'OX'4Gvo*' ro-kC:-ooc- 0'ji«'Utrc-kC'COc-'a3''/i*'i*:r\j-kC.'COCTjocr,( (>.!M — 0 'C»->aG'cn*'i/.r\j-»o

OISc -4 (I*3 "O -Hm C M

: C o a a c m C r O C rr.*4> n n f-l~(— r-r-r-f-P"n n c/> X X X en c #4 m c n m mX X X X X X z % c m N C c z c m z n m z c z C c r* wA ■ V A V A * 1 4" 1 X X > a >•c a 1 : c z c en3 V 3: m ■ a X X X X X V r- en Œ c 1 r~W en f V eno •H Gz X X X X X 1 X X Z X X C -4-4 X V c 1 m i o m 4 m4H Q X X a H C X X z m H r> V V a m Xr -4 -4 C X a > n o > r* r c0O X C o o c o o c z X O o X m c X X z n a o a n o z C > m G2 X O c o O c c c c c c X Z c m z X o -4 f z r o X o z> c: c c -4 -4-4 V)m -4 Z > o X X c z f c > c c z mf o -4 -4 r> 9 c C H o o r r* 1“ r -4 m Z<n c Z z Z Z (A > O en o H m o z G G•4c z Z z -4 -4-4 -4 > X m r“ r- C C O w 14-4 —«•H 1 C X m -4 -4z X X ZZ V en m -4 O r H enz en n m X en rr o a 1" > G%]%# %•». ''* aX »» X %» •4en c X c cn X Wn X m z m X -4 o > m m X m

%. » » » 7 *» $» *» ** »*»» o r~ ffîoc O XX rj 1 X G

» * m m X c èZ» n O m m O O o O O o» * c O C N A Ci en M Gm » o z tr X -4 Oo m o O o *4 * C eno o H » r* -4 X ZC W W w m V X > G03 o m X

w<o

w»m

n o 1 n 1 1 1

-‘' -•-‘-‘-‘-‘■OOCCOCCiCCC-O'O'C'C'O-O'O'C'COOC ■sO'cr*'u*rv,-»C. ■cas->40‘V/i*'tKiNj-*o-caD«j£>.\j,i'L.ii\ji ~ÆC'C'C'C'C'O ■O'O"C'C'C0c0B00000e3:00000C0c-J*>4"^TJ-J-^-sJ'>J-j-sJ> 3 O' 9 0 - 0 O' o O' o Vflcococnso- o-COB-jO'v,«'v/<iv*--o-ca.'j»-cof'wi\>-i z -o (x ^ o vn f lnIvi- zooc si>cn«'o.(\)-*z coc-a>cn^

•o z O * m o

2 z n > m c

* r c*1 -H z-H ï» TJ 2 3 X %> m M3 ^ 2

3* Tl-l » c* m » omo 2 n m » X C » X c“ m

2 22 SJ C

w - n O X 2 » A X Z wm f- X XX X X -n X M M C X Z Z 2 T. H H 0 2 2 2 -C -H > > -12 3 3 O > m m z 3 fs m w w X

r- œX c

-1 X2 X > —I3 Z IT —tZ >» *»3

0 æ a: (O Z m -41 IT c > V z X o| - X A«J —‘ m Z X z X J» X m 2 — o m2 o c

2 x 0X *» O X

II V

»* »«X » *2 IX * *> ♦ m m m3 * O o o IXm m »X o O » I- *w A X X mX LU u L. o

X a; X o w 3J c^ c X

IX r» «-I

> c o : IXu. (O c (O (O m -I X -I1 X %» —

V 2 m o oir X A 7T e; C X2 f~ ^ 2 2« z ». 3 3r ~ m m mz -» -Irr » m

c O n c

0 X -I z *» z o1 —I z X V r m Xf» X c a; X X 2 c ». c

2 C0 X Z o o1 X H V —. XX O (U 2C XA X

C O : IXV) c X X m X o o H X X X m L-2 X Xz -I m

IX xxxxg; Xl—QxO rri-r-rz» »o x I X I 2 » » X OV » o o > K* o A A X

C X X X X Xï» O A X X X X

H XxxrX» » IX » X X » » » 2 m X X ».<-mmoo

o aj : z1 2 *• XV X I X X

X V r - Oaj m 2X » f> sX o 2 f- C X

S C OI C A XV X I XXV C

a; rr. zo » &A C C XO mX X

> IX *2 2 » corneOX o c X c o A•C W X C

» O A A X IX

d V J J J J -J J J

1 1 1 1 1 1 n n 1

K 3 : 0 0 - J X I N N N - g - g O » o O s O s a > v % v n U l v n X f " t- ( x C n u » U s w w r v a : A l A il__M " * o 00 ■>4 C K V I *- w r u = - o 0= - g o - ^ r v c X N o V/l f V •c C e N o V I f " V . r v " * c c X L w r v — < 0 0 ■ M o *s0 : C : n

E en » »r\] M C C O m c o : m a X n o X o a n a » a ; » g 93 C c iL n v > 1/5 c o e n c c C r r r n X X o o X X m X m X m c/5 >1 1 m z z m m 1 X X X X X X O • H P- o 1 o o c o c o c c rr 4;V V c c 1 c z c c f A V V o c K « 4 m m z 3 r »

z z V 4 4 t~ o g' g z c z r n r X X 1 X c K m p - r m X - e X w -Tt c c/l m ia> %) o o z X r » m r » o X m X X X A n r~ en n r n ■4r u

— i H u r * z c • 4 c O H 1 o H w X en X m en r 1“ X a X XV » r~ X m X c O V X > > c m m m e n m X c

o O X I S - 4 X O X G O o K r r o c V I O s 1 4 wz z > c r~ > Z r » a o >■ O K r r - 4 m c > CÎ5

W » . O o c m o X o o r * c X w K r m X o - 4 r v ( A * s # sw X A A c c 2 X f % n O !-vj U J z z o m 1 m P " X X e n v> c/5 c/5m f U o Z Z •4 - 4 D C > m m r - V > c c C 1z C 5 O 1 - m O ■ 7 T W r m r - r c n c X w X X X X Vc m 1 X o o G O f“ f e n e n m m a e n c/5

z V I S O O c o ♦ c m en X X o m o * ■ 4 X g1 * 0 X X A z X m c c X X 3V g) m r > o - * > m r - 3 c 1 C

1 X X o m r m r * m X X V CDa ) V X » c # G e n r * e n z L 4

- 4 z V z m e n fTî r n P “ < iz a ) » » » I» ■> O .X O o » m a * » * (/i r— f“ oz z Z z m X r : r » * » > c c c C/5 ir Lu o o > X » o o z X m 4 iX -4 w> o G m O o X iG O r-» O o o » z(/) C D C D r > * n * o o m » Z j-4 <n o » » » o r* m o o c CD !c/> -4 c X c m # K e n o c c c LU (X % o K o m O •4

m o «4o O X m rv.m > A O X X f< W K »> 1 n »

z o1“ f-X OB%, -a»

ü J

irururoAjruMroroA»AJi\)AX- X- f W Uè u UJ ü« u lm LU LU rv» rvi A Ai A rv A 3 2 C 3 o <3 •o <c -c O •C c •o ■c X X X X .

V» X- u* nj C C « •V Ln x~ w rv - ■c OB■V O V, fs LU rv C O -V Os Lu A — -O X > V, fs A ■3 < 30 A t> Lu A sC X A O' :

r : r-, r-i p— m m 4 O — m ; :H » » » » » » * » » » z C 1 U) z A co m z * » » » » » » « » » X o m C z V m c m c C c C X oc en m m m m m m m f- r~ z z C Z C C z Z 1 A * t~

-4 o o o O o o o o o O ri1 o o 4 g X 9 C Z z m 4 r» » * X «u 1-4 o c V ■D C c o m r~ m A O f-LU r i z c c ■*■ Vm m m m m m X z X X X m o c 1 4 1 9 -n z O m A z C ¥L -»X z X X z z z z z g n z z c c V V X A Z c O » * r» X gH o -i -4-4H 4 4 X Z 4 o o X 4 X X » » » C c 1 4 » 4 z ♦ LU 4 A «*♦m 4 4 H m m m m rn c c m r» » » » g Z g V X v> Lu LU rs

G G Z C- z z X O m Z X O A O O- M ♦ oH C Z c • o o o LU 4 g 2 ♦ Z cm 4 z z i/) U * M + » 4

X X X Z o > A 4 Lu 4 AA ♦ LU A 3 z tn 1 ♦ ♦ Z or» # 3 X > X cm 3 *s ♦

4 1 f“1 X z + +V o •*•O O 4 ♦ Z Xg C r~ r-+ zr~ C X X X »o O Z ■r ♦ X »

»• 4 z14 »* » »• 4» m f4 » m O * 4 O » I -o m3 w o 4

♦ Z I O f-X c V! *4 4 4 * 4 VI m4 + + Ms Z

4 lu+ rs rs 4 us Lu4 » + 4

f— zX T~ X su om Z X

|— i nZ XUI

m ♦ »z C »o ♦ c mz4 OXz X Z o-X 4Xoc4

Z4 o »c »* 4

OZ4ALuLU»

»

rv»M<o

w»

Software portability - Open Research Online oro.open.ac.uk

Documents

Transcript of Software portability - Open Research Online oro.open.ac.uk