GTL Programmers Reference Manual for the Burroughs B 5500 Aug1974 pdf

(1)

"

(;e~rgia

nstltute

of

Technology

SCHOOL OF INFORMATION AND COMPUTER SCIENCE / (-/04) 8<)4-JI52 / ATLANTA, GEORGIA 30332

G T L

PROGRAMMERS REFERENCE MANUAL

FOR THE BURROUGHS B 5500

(2)

G T L

PROGRAMMERS REFERENCE MANUAL

FOR THE

BURROUGHS B· 5500

(3)

ACKNOWLEDGMENTS

The GTL compiler almost c~+~ainly would not exist today if it were not for the dedicated effort and genius of a single person, Martin

Alexander. His phenomenal talent was first recognized in the early 1960's when he both designed and coded a LISP interpreter in machine language (not

assembly) for the Burroughs 220 computer in one weekend! Furthermore, he was embarrasssed to admit that as many as about 5 or 10 instructions had to be changed before it worked correctly~ This success was followed by a LISP interpreter for the Burrougha B 5500, this time written in ALGOL, and

now---GTL.

Although Martin Alexander, who most unfortunately is no longer

employed at the Georgia Tech Compu~er Center, must be acknowledged as the sole creator of GTL, it is felt that he would insist on giving credit to the many people who have provided suggestions, advice, criticism, and assistance in the effort. Particular credit is due Marie Courtney, who implemented major portions of the double precision and complex arithmetic, checked and corrected most of the machine language intrinsic functions, and assisted in the design and implementation of many other features.

Credit is certainly due the Burroughs Corporation, whose excellent Extended ALGOL compiler provided the starting point for GTL.

This manual was prepared by the staff of the Rich Electronic

Computer Center. The GTL Compiler is currently supported by the School of Information and Computer Science.

(4)

TABLE OF CONTENTS

I. INTRODUCTION •

II. MISCELLANEOUS EXTENSIONS OF ALGOL • • . • • . • 2.1 SINGLE PRECISION STANDARD FUNCTIONS . . • .

2.2 CASE EXPRESSIONS . • . . . . . . .

2 .3 FOR STATEMENT . . . • . . • • . . • • •

2.4 EXIT STATEMENT . • • • •

2.5 RETURN STATEMENT . . • • . . .

2.6 ERROR STATEMENT • . • • . . • • . 2.7 MATRIX MANIPULATION • • • • • . • •

2 • B POWERS OF TEN TABLE . • • • . . • • • • • • • • • • . • • • 2.9 SWAP STATEMENT • • . • • • • •

2.10 RANDOM NUMBER GENERATOR . • • • 2.11 STATEMENT LINE NUMBER DETERMINATION

III. DOUBLE PRECISION ARITHMETIC 3.1 INTRODUCTION • • • • • • 3.2 FORM FOR DOUBLE EXPRESSIONS

3.3 DOUBLE ARITHMETIC .OPERATORS • . • • • • • • 3.4 DOUBLE RELATIONAL OPERATORS

3.5 DOUBLE STANDARD FUNCTIONS

3.6 RULES OF CONTEXT • • • • • • • 3.7 DOUBLE PRECISION INPUT-OUTPUT

3.B

RESTRICTIONS • . •

3.9 EXAMPLE PROGRAM

IV. COMPLEX ARITHMETIC • • . • • • • • 4.1 INTRODUCTION • . • • • •

4.2 FORM FOR COMPLEX EXPRESS IONS • 4.3 COMPLEX ARITHMETIC OPERATORS • 4.4 COMPLEX RELATIONAL OPERATORS • 4.5 COMPLEX STANDARD FUNCTIONS • 4.6 COMPLEX INPUT-OUTPUT . • • • 4.7 DOUBLE COMPLEX DECLARATOR

4. B RESTRICTIONS.. • • • • 4.9 EXAMPLE PROGRAM • • • • • •

V. STRING PROCESSING

. .

_·

5.1 STRING VARIABLES

.

_·

· _{· ·}

_·

· _{· ·}

·

5.1.1 Simple String Variables and Arrays

5.1.2 Substring Variables

_{· ·}

_·

5.1.3 Formal String Variables

_{· ·}

5.2 STRING DESIGNATOR

_{· ·}

_·

· ·

5.3 STRING EXPRESSIONS

_·

· _{· ·}

· _·

_·

5.3.1 String Expression Forms

_{· ·}

_•

_·

5.3.2 The Quoted String

_·

_{· ·}

_·

_{· ·}

5.3.3 String Designator

_·

_{· ·}

_·

5.3.4 String Assignment Statement

_·

_{· ·}

5.3.5 String Function Designator

·

5.3.6 SPACE Function

. · · ·

(5)

TABLE OF CONTENTS (Cont. )

5.3.7 The NIL Function

· ·

·

· _·

· · ·

_{· · ·}

· _·

5-9

5.3.8 The String Skip Indicator

_{· · ·}

_·

5-10

5.3.9 The QMARK Function •

_{· · · ·}

_·

· _·

_{· ·}

_·

5-11

5.3.10 The Bit Expression

_{· · ·}

_·

_{· ·}

5-11

5.3.11 The Restricted Boolean Expression

_{· · ·}

_·

5-11

5.3.12 The Restricted Arithmetic Expression

_·

5-12

5.3.13 The Restricted Symbol Expression

_·

_{· ·}

· _{· ·}

· ·

_·

5-12 5.3.14 The STRING Transfer Function

_·

_{· ·}

_{· · ·}

_·

5-13

5.3.15 The SUBST Function • 5-14

5.3.16 The FILL Function

_{· · ·}

_·

_{· · ·}

· ·

_·

_•

_·

5-15

5.3.17 The OCTAL Function

_{· ·}

· · · ·

5-16

5.3.18 The String Repeat Expression

_·

5-17

5.3.19 Parenthe.sized String Expression 5-17

5.4 THE STRING ASSIGNMENT STATEMENT 5-18

5.4.1 The Basic String Assignment Statement 5-18

5.4.2 String Assignment with SPACE

_{· · ·}

5-18

5.4.3 String Assignment with NIL

_{· · ·}

_·

_{· ·}

· _·

_·

5-19 5.4.4 String Assignment with String Skip Indicator

_·

5-19 5.4.5 String Assignment Overlap: A Warning

_{· ·}

· _·

5-20 5.4.6 String Assignment Statement Containing String Length

Assignment

_·

· _{· ·}

· _·

_{· ·}

· ·

_·

_{· · ·}

5-21 5.4.7 The String FILL Statement

_·

· _{· · ·}

· _·

_·

_{· · ·}

5-22 5.4.8 The String Addition Assignment Statement

_{· · · ·}

· _·

5-22 5.4.9 The String Subtraction Assignment Statement

· _{· ·}

_·

5-23

5.5 STRING COMPARISON

· · ·

5-23

5.5.1 String Relational Expression •

· _·

_{· · · ·}

· _{· · · ·}

_·

5-23 5.5.2 String Relation with SPACE

_{· · · ·}

_·

· _·

_·

5-24

5.5.3 String Relation with NIL

_·

· _{· · ·}

5-25

5.5.4 String Relation with String Skip Indicator

·

5-25

5.5.5 String Pattern Matching

_{· · · ·}

_{· · ·}

· ·

5-26

5.5.6 The SEARCH Function

· _·

5-27

5.6 BIT EXPRESSIONS

_{· ·}

· _·

_{· · ·}

_{· ·}

5-29

5.6.1 Bit Expression Form 5-29

5.6.2 Bit Primary

_{· · · ·}

_{· · ·}

_·

_{· ·}

5-29

5.7 STRING ACTUAL PARAMETERS

_{· · ·}

_·

_{· · ·}

_·

5-30

5.7.1 Ca11-bY-Va1ue

_·

· · ·

_·

5-30

5.7.2 Ca11-by-Name

_·

_{· · · ·}

5-30

5.8 USING STRINGS IN OTHER TYPES OF EXPRESSIONS

_{· · · ·}

5-31 5.8.1 Arithmetic Expressions

_{· ·}

_{· · · ·}

_·

5-31 5.8.2 Symbolic Expressions

_·

_{· · ·}

_·

_{· ·}

_·

5-33 5.9 USING AN ARRAY OR A STRING VARIABLE

_·

_{· · ·}

_·

5-33 5.10 OPTIMALITY OF STRING EXPRESSIONS ~

· · · · ·

·

5-34

5.11 READING AND WRITING STRINGS

_·

_{· · ·}

_·

5-34

5.11.1 READ and WRITE Statements

_·

_{· · ·}

5-34

5.11. 2 GTL Input-Output Functions

_·

_{· ·}

_·

5-34

VI. LISP 2

.

. · ·

_·

_{· · ·}

_{· ·}

_·

6-1

6.1 INTRODUCTION

_{· ·}

_{· · · ·}

6-1

6.2 S-EXPRESSION AND LISP RECORDS

_·

_{· ·}

_·

6-1

6.2.1 Record and Field Designator

_{· · · ·}

_{· ·}

~

· · ·

6-1

6.2.2 LISP Records

_·

_•

_·

6-2

6.2.3 LISP Lists

_·

_{· ·}

_·

_{· ·}

_·

_•

_{· · · ·}

6-5

(6)

6.3 6.3.1 6.3.2 6.3.3 6.3.4 6.3.5 6.3.6 6.3.7 6.3.8 6.4 6.4.1 6.4.2 6.4.3 6.4.4 6.4.5 6.4.6 6.5 6.5.1 6.5.2 6.5.3 6.5.4 6.5.5 6.5.6 6.6 6.7 6.8 6.8.1 6.8.2 6.8.3 6.9 6.9.1 6.9.2 6.10

TABLE OF CONTENTS (Cont.)

SYMBOL EXPRESSION • . . Definition

Quoted S-expressions • • • • .

Numbers and Arithmetic Expressions . • • .

LISP Variables . . • •

Assignment Statements • • • The Field Designators • • • Conditional Expressions • . LISP Function Designator LISP STANDARD FUNCTIONS

CONS LIST RANDOM APPEND NCONC ••

SPACE and QMARK •

BOOLEAN STANDARD FUNCTIONS ATOM . • • • . • • • ATSYM .

NUMBERP • ALF . • •

NULL . • • • .

~}ffiER • • • • • • • • • • • • LISP RELATIONAL EXPRESSIONS ••

THE LISP ASSIGNMENT STATEMENT • THE LISP ITERATIVE STATEMENT

The ON Statement

The IN Statement • • • • • • • • • • • The WHILE Part •• • • • •

EXTENSIONS OF ARITHMETIC EXPRESSIONS • • • • Arithmetic Expression Syntax Extension The LENGTH Function • • • • • •

READING AND WRITING S-EXPRESSIONS 6.10.1 Output Functions

6.10.2 Input Functions . • • • • 6.11 THE SYMBOL MONITOR • • • • 6.12 ATOMIC SYMBOLS • • • • •

6.12.1 Types of Atomic Symbols • • • • • 6.12.2 Nonstandard Atomic Symbols

6.12.3 Uniqueness of Atomic Symbols 6.13 THE LISP OBJECT LIST

6.13.1 The LISP Symbol Table • • • 6.13.2 The OBLIST Function • • • 6.13.3 The REMOB Statement • • • 6.14 STRINGS AND ATOMIC SYMBOLS 6.14.1 Creation of Atomic Symbols 6.14.2 The ATCON Function

6.14.3 The MKATOM Function • • • • • 6.14.4 The GENSYM Function • • • • •

6.15 LISP REFERENCE VALUE TRANSFER FUNCTIONS • 6.15.1 The CTSM Function.

(7)

6.1S.3 The ATSM Function • • • .

6.16 THE CTR FIELD • • • • • • • . . • • • • . 6.17 PREFIX AND DOT OPERATORS

6.17.1 Prefix Field Designators 6.17.2 Boolean Prefix Operators 6.17.3 The Dot Operator

.

6.18 PROPERTY LIST OPERATORS • • • • • . • • • .

6.18.1 The Property List.

.

6.18.2 ADD PROP • • • • •

6.18.3 PROP • . • •

6.18.4 REMPROP . •

6.18.S The Numeric Property Record.

6.18.6 Reference Property Records • • . .

6.19 THE SYMBOL DEFINE DECLARATION • • • • • • • • • • . • . • • . 6.19.1 The Standard Declaration

6.19.2 CDR Field Initialization 6.19.3 The Asterisk Form • . . • 6.20 STORAGE RECLAMATION • • • • •

6.20.1 Automatic Versus Programmed Storage Reclamation 6.20.2 Automatic Storage Reclamation • • • • • • • • • 6.20.3 Programmed Storage Reclamation • • • • • 6.21 AUTOMATIC STORAGE AND RETRIEVAL OF LISP LIST STRUCTURE 6.21.1 The LISP "Memory" • • • . • • • • 6.21.2 The REMEMBER Statement • • • • • • • • •

6.21.3 The RECALL Statement • • • • • • • • . • . • • • • 6.22 THE INTERNAL REPRESENTATION OF LISP RECORDS •

6.22.1 LISP Reference Values • • • • • . • • • • •

6.22.2 Atomic Symbols • • • • • • • 6.22.3 Atomic Number • • • • •

6.22.4 Dotted Pairs . • • • •

.

6.22.S Other Types of Records • • • • • • • • • • • . • • • • • • 6.23 LISP SYSTEM CONTROL PARAMETERS

6.24 PROGRAMMED STORAGE RECLAMATION • • • • 6.2S LISP EXAMPLE PROGRAM

VII. RECORD PROCESSING • .

7.1 INTRODUCTION • • •

7.2 BASIC CONCEPTS OF GTL RECORD PROCESSING. 7.2.1 Reference Expressions • • • • • • • • 7.2.2 Field Designators • . • • • • • • • • • • 7.2.3 The Reference Assignment Statement

7.2.4 The Field Declaration

7.2.S Indexed Fields • • • • • • •

. .

..

.

7.3 THE DISK SYSTEM • • • • • • • • • • • • . • • • • • • • • 7.3.1 The Record Class Declaration • • • • • • • •

7.3.2 The RECORD File Declaration. 7.3.3 The Record Designator • • • • • 7.3.4 Record Relational Expressions

7.3.5 Transfer Functions • • • • •

. .

.

7.3.6 Storage Reclamation. • .. • • • • • • • • • • 7.3.7 Saving and Restoring Heads of Master Lists in Non-LOCAL

Files • • • • • • •

(8)

7.3.8 7.4 7.4.1 7.4.2 7.4.3 7.4.4 7.4.5 7.4.6 7.5 7.6

Printing Reference Values • • • . . • . THE CORE STORAGE PLEX PRECESSING SYSTEM .

The Record Class Identifier Field Designators • • •

Record Designator • • • • • • • The SYMBOL PLEX Option

The ATSM Transfer Function

The RECALL and REMEMBER Statement • RECOMMENDED PRACTICES • • • • •

EXAMPLE PROGRAM • • • • • • • • •

VIII. SYNTAX-DIRECTED PARSING 8.1 INTRODUCTION . • • • •

IX.

8.2 SYMBOL FORMAT EXPRESSIONS •

8.2.1 Terminal Symbols • • • • 8.2.2 Nonterminal Symbols • • . • • . 8.2.3 N I L . . . . • • • • • 8.2.4 Statements

8.2.5 Labels 8.2.6 RETURN

8.2.7 The SWITCH Option • • • •

8.2.8 The Error Message Option • • • •

8.2.9 Syntax and Semantics of SYMBOL FORMAT Expressions. 8.3 SYMBOL FORMAT DECLARATIONS • • • • •

8.4 SYMBOL FORMAT STATEMENTS , . • • • •

8.5 SYMBOL FORMAT AUXILIARY DECLARATIONS • • • • • • 8.5.1 Syntactic Class Declaration ••

8.5.2 Class Variable Declaration

8.5.3 Getnext Procedure Declaration. • • • • •

8.5.4 Error Procedure. • • • • • • • • • • • • • • 8.5.5 The Trace Option • • • • • •

8.6 RECOMMENDED PRACTICES . • • • • • • • • •

8.7 BOOLEAN PROCEDURE EQUIVALENT OF SYMBOL FORMAT DECLARATION 8.8 EXAMPLE PROGRAM. • • • • • • • • • • • •

INPUT-OUTPUT FUNCTIONS •

GTL

9.1 9.2 9.2.1 9.2.2 9.2.3 9.2.4 9.2.5 9.2.6 9.2.7 9.2.8 9.2.9 9.2.10 9.2.11 9.2.12 9.2.13

INTRODUCTION • • •• •• • •

THE OUTPUT FUNCTIONS • • • • Extended WRITE Statement • • • •

The PRINT, PRIN, and TERPRI Statements • • • • The FORMAT Option • • • • • • • • • •

Literal String • • • • • • • • • • • • • • • •

String Values • • • • • • • • • • • • • Real and Integer Values • • • • • • • • • • • • • • .

Alpha Values •••• • •• • • • • • • • • Boolean Values •• • •• • • • • • • • • • •

Double Precision Values • • • • • •

Complex and Double Precision Complex Values • LISP Values • • • • • • • •

Reference Values

QMARK • • • •

(9)

9.2.15 9.2.16 9.2.17 9.3 9.3.1 9.3.2 9.3.3 9.4 9.4.1 9.4.2 9.4.3 9.4.4 9.4.5 9.4.6 9.4.7 9.5 9.5.1 9.5.2 9.5.3 9.5.4 9.6 9.6.1 9.6.2 9.6.3 9.6.4 9.6.5 9.6.6 9.6.7 9.6.8 9.6.9 9.7 9.7.1 9.7.2 9.7.3 9.7.4 9.8 9.8.1 9.8.2 9.8.3 9.8.4 (""

SKIP . . . . The NTS Statement

Conditional PRINT Statement THE OUTPUT STATEMENT .

The Standard Form The Output Procedure .

Setting Left and Right Margins THE READ FUNCTIONS . • .

Extended READ Statement • . • . The GTL Read Mechanism •

The SCAN Function The READCON Function •

The READN Function • . • • . The READI Function • .

The READ Function THE INPUT STATEMENT

The Standard Form The Input Procedure

Setting Left and Right Margins Sign-Number Separation • • • REMOTE TERMINAL INPUT-OUTPUT • The FILE REMOTE Declaration FILE REMOTE Side-Effects • • READ and WRITE Statements READ TWX • . •

WRITE TWX READN (TWX)

READN (TWXA)

TWXNUM . • •

Conversational READ Statement . • • • STANDARD VARIABLES AND SYSTEM CONTROL PARAMETERS

The Standard Variables • • • The Standard Variable TAB The Standard Variable COL System Control Parameters

SAMPLE INPUT AND OUTPUT STATEMENTS • • Card Reader

Line Printer • • • • • • Remote Terminal Files Listing of Input Cards •

APPENDIX A - EXAMPLES OF GTL PROGRAMS String Processing Example Lisp Processing Example Lisp Processing Example

Syntax-Directed Parsing Example APPEND IX B - REMOTE TERMINAL CHARACTER SET APPENDIX C - CONVAL FUNCTION • • • • • • APPENDIX D - GTL RUN TIME ERROR MESSAGES APPENDIX E - REFERENCES • • • • • •• •

(10)

I. INTRODUCTION

Since the beginning of Newell, Simon, and Shaw's list processing language, IPL, in 1954, the role of symbol manipulation languages in com-puter applications has become increasingly important. In 1965, a LISP interpreter was implemented on the Burroughs B 5500 here at Georgia Tech. For several years, it was used quite successfully in classroom instruction and in a few small scale symbol manipulation applications. Since the inter-preter was too slow and too restrictive for any large scale applications, a decision was made to implement a high level symbol manipulation language by extending the existing, and excellent, B 5500 ALGOL compiler. The result was GTL, an acronym for Qeorgia !ech 1anguage.

The GTL compiler is truly an extension of the Burroughs B 5500 ALGOL compiler; hence, it contains all features of Burroughs Extended ALGOL. (As used at Georgia Tech, STREAM PROCEDURES are prohibited.) Only one class of exception exists. The addition of certain GTL constructs to the ALGOL compiler has introduced new reserved words which cannot be used as defined identifiers by the programmer. These words are CAR, CDR, COMPLEX, GTR, EQ, FIELD, NEQL, NIL, RECORD, STRING, and SYMBOL.

In addition to its symbol manipulation capabilities, GTL also contains significant extensions to B 5500 ALGOL for numeric computation. GTL contains facilities for: double precision, complex, and double precision complex

(11)

extensions (including additional intrinsic functions, the BASIC compiler matrix functions, an efficient means of swapping the contents of two arrays, a random number generator, and several other useful constructs).

Almost all of the major features of GTL were implemented prior to 1970. Some of the miscellaneous extensions, some of the inevitable error correc-tions, and updates to later versions of the ALGOL compiler have been accom-plished since that time. All the features of GTL, as described in this manual, are currently being used by a large number of Georgia Tech students, faculty, and research workers. It is currently running under the Burroughs Mark XII Data Communications and Time Sharing Master Control Programs.*

Most of the features of GTL were implemented and made operational in successive stages. As each new feature was implemented it was described in a separate publication. Altogether, ten of these preliminary draft manuals were published between May 1968 and December 1969. The contents of these ten preliminary drafts have been consolidated into this single manual with a small amount of editing, rearrangement, and with the incorporation of some new material. The preliminary drafts are now obsolete, and this manual should be considered the official and complete documentation for GTL.

Comments, suggestions, or corrections to this manual or the GTL language are welcomed and should be forwarded to the Director, Information and

Computer Science, Georgia Institute of Technology, Atlanta, Georgia 30332.

*As of November 1971, GTL is being updated to Mark XIII.O which provides a new COMPLEX Polish statement. Since this conflicts with the more convenient GTL COMPLEX construct, it is planned to omit this particular Mark XIII.O feature. With this omission, GTL will no longer be a true extension of Burroughs ALGOL.

(12)

II. MISCELLANEOUS EXTENSIONS OF ALGOL

The GTL system contains a number of miscellaneous extensions of the ALGOL framework in which it is embedded. Those are described in detail below.

2.1 SINGLE PRECISION STANDARD FUNCTIONS

In addition to the sta.ndard (or "intrinsic") functions already provided by the B 5500 ALGOL

standard functions:

Name LOG ARCSIN ARCOS TAN COTAN SINH COSH TANH GAMMA LNGAMMA ERRORF

2.2 CASE EXPRESSION

compiler, GTL provides the following new single precision

Meaning

logarithm (base 10) inverse sine

inverse cosine tangent

cotangent

hyperbolic sine hyperbolic cosine hyperbolic tangent gamma function

natural logarithm of gamma function error function

(13)

as the CASE statement of Burroughs Extended ALGOL with the statements

replaced by expressions of the appropriate type. For example, if X, Y, and Z

are REAL variables, then

CASE J OF BEGIN X; Y; Z; END

is an expression of type REAL, the value of which is the value of X if J is 0,

Y if J is 1, or Z if J is 2, or an error termination otherwise.

2.3 FOR STATEMENT

The syntax of the FOR statemen~ has been extended by allowing a single

unsigned integer or simple variable to appear between the FOR and DO,

indicating that the controlled statement is to be executed the number of times

given by the value of the variable or integer. For example, if X is a real

variable which has a value of 100, then

FOR X DO ST~

FOR 100 DO STMT

both have the effect of causing STMT to be. executed 100 times.

2.4 EXIT STATEMENT

The word EXIT may be used in any block which is not a procedure body to

cause an immediate exit from that block. The EXIT statement may appear

any-where in the block and may appear any number of times.

2.5 RETURN STATEMENT

The RETURN statement may be used to cause an immediate exit from any

procedure in which it appears. If the procedure is typed, then the procedure

(14)

is given the value of the expression immediately following the word RETURN. The RETURN statement may appear anywhere in the procedure declaration and may appear any number of times (if the RETURN statement appears in a block, then that block must constitute the procedure body). For example, the LISP func-tion MEMBER (a GTL standard funcfunc-tion) may be defined as

BOOLEAN PROCEDURE MEMBER(X,Y); VALUE X,Y; SYMBOL X,Y; FOR Y IN Y DO IF X

=

Y THEN RETURN TRUE

2.6 ERROR STATEMENT

A convenient way of providing an immediate exit from any point in a program in which an error condition is detected is the ERROR statement. An execution of the ERROR statement will cause the value of its argument to be printed in a 2 character alpha format, together with the segment and relative address in the program of the ERROR statement. After the execution of the ERROR statement the program is immediately terminated. For example, execution of

ERROR ("E3")

will cause "E3" to be printed and the program to be terminated.

2.7 MATRIX MANIPULATION

(15)

ARRAY A,B,C[0:10,0:10] sample declaration

1) A:= B + C

2) Ao- B - C

3) A:= B ® C

4) A:= 1 / B

5) A:= B

*

6) A:= B ® primary 7) A:= B

8) Ao- IDN

9) A:= gER 10) A:= C0N

addition

subtraction

multiplication

matrix inversion

transpose

multiplication by a scalar

simple a~signment

identity matrix assignment

zero matrix assignment

unit matrix assignment

where primary is any arithmetic primary; e.g.,

A:= B ® 2

A:= B ® (SIN(X) + 1)

All arrays must be two dimensional and may never be specified as SAVE.

The lower bounds of the arrays must be declared to be 0; however, they are

treated as if they had lower bounds of 1; for example, the arrays declared

above are considered to be 1 by 10 matrices. The intrinsic functions use

the declared sizes of the arrays for their activities, not the amount of

information the programmer has p1aGed into the arrays, necessarily.

The last four modes of assignment are vastly more efficient than the

equivalent open GTL code and should be used whenever that type of assignment

is desired.

(16)

2.8 POWERS OF TEN TABLE

GTL provides access to a table containing powers of ten. It may be referenced with a construct of the form

TEN[aexpJ

where aexp represents an arithmetic expression which, when integerized, will have a value from zero to 69. The value of this subscript should be the

(integral) power of ten de~ired:

TEN[aexpJ is equivalent to 10

*

(aexp) l/TEN[aexpJ is equivalent to 10

*

(-(aexp))

When used in a double precision context, it yields a double precision value; in a single precision context, its value is the double precision value

truncated to a single word.

The use of this construct is encouraged since it provides a much more efficient means of calculating a power of ten than do the alternate forms. The object program uses the powers of ten table for 1/0 conversion, so its use will not further increase core requirements.

2.9 SWAP STATEMENT

The fastest and easiest w~y to swap two two-dimensional arrays is by the following construct:

SWAP(Al,A2)

where Al and A2 are two array identifiers. The effect is to swap the contents and sizes of the two arrays. The actual implementation swaps only the

(17)

2.10 RANDOM NUMBER GENERATOR

GTL contains a built-in random number generator which the programmer may reference directly through the arithmetic primary

CONVAL(O)

Each calIon CONVAL(O) will generate a new random number between 0 and 1, but never 1. The arithmetic primary

CONVAL(l)

will return the previously-generated random number and will not generate a new one. If it is desired to change the stream of random numbers being generated, an alternate form of CONVAL(O) may be used, involving the following arithmetic primary

CONVAL(O,~)

Depending on the value of ~, a different seed for random number generation will be used. In many applications, the following special form of CONVAL

is used once at the beginning of the program:

CONVAL(O ,TIME (4»

This presents the program with one of 64 different streams of random numbers, usually different each time the program is used, dependent upon the machine clock.

(18)

2.11 STATEMENT LINE NUMBER DETERMINATION

The line number of the current statement in a program may be accessed through the arithmetic primary

LINENUMBER

(19)

(20)

III. DOUBLE PRECISION ARITHMETIC

3.1 INTRODUCTION

In GTL, the declarator DOUBLE may be used in the same manner in which the declarator REAL is used in an ALGOL program. For example:

DOUBLE X, Y, Z DOUBLE ARRAY DR[a:99]

DOUBLE PROCEDURE DSINH (X); VALUE X; DOUBLE X; BEGIN DOUBLE Y;

DSINH:~ «Y:= EXP(X)) - 1.a/Y) ® .5

E~

Calculations with such variables, elements of arrays, and procedure values will automatically be done in double precision, subject to the rules of context (Subsection 3.6) and the available double preciSion operators and standard functions (Subsections 3.3, 3.4, 3.5). The Input-Output mechanism (Section IX) facilitates reading and writing double values.

3.2 FORM FOR DOUBLE EXPRESSIONS

A double expression has the form of an ordinary ALGOL arithmetic expression with double primaries andlor single precision primaries. A

double primary can be a double variable, a double function designator (a call on a double-valued procedure or on a double standard function with its

actual parameters, if any), a double assignment statement, a double expression

/

(21)

3.3 DOUBLE ARITHMETIC OPERATORS

The operators available for double precision arithmetic are +, -,~,

I,

and MOD. DIV may be used between double primaries, but the calculation of

the result will always be done in single precision.

3.4 DOUBLE RELATIONAL OPERATORS

All the relational operators, =, ~, <, >, ~, ~, and their mnemonics, are available for double precision comparison. A comparison is a double

precision comparison only when the expression on the left hand side of the

relational operator is a double variable, double procedure, or double

assignment statement. A double assignment statement is one in which the

leftmost variable is double.

3.5 DOUBLE STANDARD FUNCTIONS

The available standard (or "intrinsic") functions of double expressions

are as follows:

FUNCTION

COS

SIN

EXP

LN

LOG

SQRT

ARCTAN

LOPART

HIPART

MEANING

cosine

sine

e~ponential function

natural logarithm

common logarithm

square root

inverse tangent

least significant part of double value

most significant part of double value

(22)

The other functions available for single precision can be applied to double expressions, but the calculation of the function value will always be performed in single precision.

3.6 RULES OF CONTEXT

Whether single or double precision calculations are performed to evaluate an arithmetic expression depends on whether the arithmetic expres-sion is in a single or double context. If the context is single, the calculations are done in single precision. If the context is double, all the calculations are done in double precision except for the operator DIV and intrinsic functions not avilable in double (which are done in single precision). When a double va~iable or double procedure is used in a single precision context, the double value is normalized and truncated to a single precision value. When a single precision variable, procedure, or standard function is used in a double context, it is converted to a double precision operand by setting the least significant part of the double operand to zero.

An arithmetic expression is in a double context in anyone of the following cases and is otherwise in a single context:

1) If the arithmetic expression is on the right hand side of a := in an assignment statement, it is in a double context if, and only if, the variable immediately to the left of the := is a double variable.

2) If the arithmetic expression is an argument of a procedure for which the corresponding formal parameter is double, the arithmetic expression is in double context.

(23)

3.7 DOUBLE PRECISION INPUT-OUTPUT

Ordinary ALGOL READ statements Can be used to read single precision numbers to be used in double context, and ordinary ALGOL WRITE statements can be used to write a double value in single precision. ALGOL READ and WRITE statements cannot read and write double precision numbers. However,

the I/O facilities of GTL facilitate the reading of double numbers and the writing of double numbers and editing phrases.

The GTL Input-Output system provides a very flexible and powerful means of reading and writing many types of data using any of the files which can be declared in normal ALGOL. The system is described in detail in Section IX of this manual.

3.8 RESTRICTIONS

If a double formal parameter is call-by-name and the corresponding actual parameter is a variable, this variable must be double.

If the actual procedure corresponding to a formal procedure is to have a double parameter, then in the actual procedure, that parameter must be double call-by-value, and the expression used as the corresponding para-meter of the formal procedure must begin with a double variable. When the formal procedure and its double arguments are compiled, the compiler will print a warning message indicating the requisite type of the corresponding actual parameter of the actual procedure.

3.9 EXAMPLE PROGRAM

The following example double precision program is not intended to represent a practical program, but merely serves to illustrate some of

~he GTL double precision constructs. The GTL Input-Output system, which is described in Section IX, is also included in the example.

(24)

AEGIN

CCM~rNT FI~r nOU8LE PRFC1~In~

RCOTS Cr

~LACPATIC E'LATIC~S;

rILE

l~

INCO (2,1C);

STRING CROCAO)J

rILE OUT

PRINTER 16(2,15);

STRI~G LIN

(120);

REAL

J,K;

P R GeE D u R E Q II A

r.

s n L v E ( A , Ij 1 C ) J

VALliF A,A,Ci

nCUHlf A,R,el

tjF G PJ

nUUHI E 0;

PRINT A,8,C;

IF 0

:=

8 *

2 - 4

~ A x

C

<

n

THEN

pRI~T

SPACE(lC)

fCO~PLf1

GGors,

ELSE

I3EGIN

C

:=

(n

.=

SQRT(n)

+ B~ I

A

:= ;. x ~ :

B := (D - 8) I A ;

PRINT tREAL

ROCT~I #

8,

CJ

Ef<.Oi

END

nr

GUAOSOLVEJ

J~PUT(I~CD,CRD,eC);

CJurpl.lTCPRINTERllINI1(0)J

PRINT #GUAOSOLV[ PROGRAM';

CO~~ENT

READ IN

NUMBER

OF

TRTPLrs TO Sf RFAC

I~J

K

:=

REAC"";

FUR J:=l

STEP

1 U~TIL I( DO QIJAnsr:LVECFiF'AC",READt-.,J;EAljfl.);

END.

THE

PROGRA~

HAD THE

FDLLOwYN~

CARD INPLT:

5

1 2 3 .002 3.14 .42

.U01.1.1

AND

THE OUTPUT

lISTI~G ~ASt

QUAD SOLVE

PROGRA~

1 2 3

CO~PLEX

ROCTS

2~-3

3.14 .42

.01 .01 .01

.ee

.C~

.C7

REAL HOOTS:

7.e4a66230640610~02244?@2 1.56ge6623CE4c61C5C2244~3

1~·3 .1 .1

REAL RorTS,

4.8ge97948556635~196394~1 9.a98~794e5;6~3561~6394~1

U-2 1~-2 t~"2

C(1MPLEX

ROOTS

8@-2 6~-2 7€i-2

(25)

(26)

IV. COMPLEX ARITHMETIC

4.1 INTRODUCTION

In GTL, the declarator COMPLEX may be used in the same manner in which the declarator REAL is used in an ALGOL program. For example,

COMPLEX Y

COMPLEX ARRAY A[O:5]

COMPLEX PROCEDURE ROOTl(A,B,C); VALUE A,B,C;

REAL A,B,C;

ROOTI := (-B + SQRT(B*2 - 4~~»/(2~)

Such variables, elements of arrays, and procedure values will be automatically treated as complex numbers and may be used in the same manner as reals.

The Input-Output mechanism (Section IX) facilitates reading and writing complex values.

Complex arithmetic in double precision is also available (Subsection

4.7).

4.2 FORM FOR COMPLEX EXPRESSIONS

A complex expression has the form of an ordinary ALGOL arithmetic

expression with complex primaries, with the exception of exponentiation (*), in which case the exponent must be real. (In other words, in A*B, A may be complex but B must be real.)

(27)

parameters, if any), a complex assignment statement, a complex expression within parentheses, or :comp1ex primary. The colon (:) in a complex primary

indicates multiplication by

i;

i.e., the is syntactically equivalent to SQRT(-l)@. For example, if X is a complex variable and X :=3+:7, then the real part of X is 3 and the imaginary part is 7. Since the colon means "i times," it must be followed by a primary; 7:, for instance, has no

meaning.

Examples of complex expressions, where A and B are real variables and X and Yare complex variables:

A+:B X/Y

COS(X+A) + :SIN(:ARG(X»

::A - B (Le., -A-B)

X + : (A+B)

4.3 COMPLEX ARITHMETIC OPERATORS

The operators are +, -, @, /,

*

MOD, DIV. The meaning of the operators is illustrated by the table of equivalent algebraic expressions given below, where Zl and Z2 are complex numbers such that Zl ~ a + ib and Z2

=

c + id and a,b,c,d, and R are real numbers.

EXPRESSION DEFINITION Zl+Z2 (a+c) + i(b+d) Zl-Z2 (a-c) + i(b-d) Zl@Z2 (ac-bd) + i (bc+ad)

Z1/Z2 {ac+bd2

(cz +dZ )

i {bc-ad2 + (cz +d2 )

(28)

Zl*R Zl MOD Z2 Zl DIV Z2

4.4 COMPLEX RELATIONAL OPERATORS

IZllRei R arg(Zl)

(ac+bd)MOD (c2 _+d_{2 )} _{+ i «bc-ad)MOD (c}2 _+d_{2 ))}

(ac+bd)DIV(c2_+d_{2 )} _{+ i«bc-ad)DIV(c}2_+d_{2 ))}

Two relational operators, = and

1-,

and their mnemonics, are available for complex comparisons. Two complex expressions A and Bare = if and only if the real part of A is equal to the real part of B and if the imaginary part of A is equal to the imaginary part of B. Otherwise, the

I-

relation is true. The left hand side of a complex relation must be a complex variable

(including complex array elements) or a complex assignment statement

(i.e., the leftmost variable must be a complex variable) and the right hand side can be any complex expression (including rea1s). For example, if X is complex and A is real, then X=A only if the real part of X equals A and if the imaginary part of X is zero.

4.5 COMPLEX STANDARD FUNCTIONS

The available intrinsic functions of complex expressions are given in the following chart. Assume X:= 1+:1 and Y:= 3+:4.

FUNCTION MEANING TYPE OF RESULT EXAMPLE ABS absolute value real _{ABS(Y) = 5}

ARG argument real _{ARG(X) = .78540}

(29)

FUNCTION MEANING TYPE OF RESULT EXAMPLE

SIN sine complex SIN (X) 1.2984 + :.63496 COS cosine complex COS (X)

₌

.83373 :.98890

~P exponential function complex EXP(X)

₌

1.4687 + :2.2874 LN principal value of complex LN(X)

=

.34657 + :78540

natural logarithm

4.6 COMPL~ INPUT-OUTPUT

Ordinary ALGOL READ and WRITE statements can be used to read and write complex numbers if the real parts and the imaginary parts of the numbers are read and written separately as real numbers. However, the I/O facilities of GTL facilitate the reading of complex numbers and the writing of complex numbers and editing phrases.

The GTL Input-Output system provides a very flexible and powerful means of reading and writing many types of data using any of the files which can be declared in normal ALGOL. The system is described in detail in Section IX of this manual.

4.7 DOUBLE COMPLEX DECLARATOR

In a GTL program, COMPLEX declarations may be replaced by DOUBLE COMPL~

declarations for complex arithmetic in double precision. The "Rules of Context" described in Subsection 3.6 of this manual apply. The arithmetic operators available for DOUBLE precision COMPL~ are +, -,

®, /,

*,

MOD; the relational operators are

=

and

I

and their mnemonics,and the intrinsic functions are REALPART, IMAGPART, ARG, ABS, CONJ. All the other operators and functions available for complex can be applied to DOUBLE COMPLEX, but the calculation will be done in single precision. When a DOUBLE COMPL~

variable, assignment statement, or typed procedure appears in the list of

a PRINT statement, the real and imaginary parts are printed in double precision.

(30)

4.8 RESTRICTIONS

If a complex parameter is call-by-name and the actual parameter expression is a single variable, this variable must be complex.

If the actual procedure corresponding to a formal procedure is to have a complex parameter, then in the actual procedure, that parameter must be complex call-by-value and the expression used as the corresponding parameter of the formal procedure must begin with a complex variable. When the formal procedure and its complex arguments are compiled, the compiler will print a warning message indicating the requisite type of the corres-ponding actual parameter of the actual procedure.

4. 9 EXAMPLE PROGRAM

The following example program uses a simplified portion of Robert Rodman's "Muller's Method for Finding Roots of an Arbitrary Function,"

(Algorithm 196, CACM, Vol. 6, August 1963), which finds real and complex roots of an arbitrary function. Given the starting values PI, P2, and P3, a limit MXM on the number of iterations, and convergence criteria EPI and EP2, the procedure Muller listed below attempts to find a root to the func-tion FUNCTION. This example also illustrates the GTL Input-Output system as described in Section IX. A listing of the compilation of the complete

program and output is given. The card input was the following set of num-bers, in order:

-1 0 1 30 @-8 @-8

(31)

tH.G!1'l

FIL~ iN

INFILE (2'10);

FILt UUT LINE

1b(q'1~);

STHIN~ CRU(~O)'LI~(120);

CUM~LlX PHUCE~~HE Spr(A,~);

VALlJE

A,~;

COMPLEX

An;!i

dEGIN

A

p=

SQRJ(A)J

~lTlJRN

IF

A~S(~+A)

<

ABS(~·A) THE~ ~·A

ELSE

BtAj

ENO OF SPfi

PHUCEUURE MULLEH(P1,P2,PJ,MXM,EP1,EP2,FUNCTION);

VALUE P1,P2,P3,MXM'EP1,EP2J

HEAL

P1,P~,P3,EP1,lP2;

INH.GER MXMi

COMPLEX

PHO~EDUR~ FU~CTIONJ

~EGIN

INTEGER ITC;

COMPLEX Xl,X2,X3,fl,fXl,fX2,FX3,H,LAM,OEL,Gi

LAHEL M9,Ma,M6;

Xl

1=

P1;

x2:=

P~i

X3

1=

P3J

txl

1=

flJNC1ICN(Xl);

FX2

.=

FlJNCIIONCX~);

FX3

.=

FlJNCTICN(X3)J

H 1= X3 - x,d

LAM

.=

IF

X~

EQL Xl THEN 1 ELSE H / (X2 • Xl)'

UtL

l=

LAM

+

1J

M~I

IF fX1 EQL fX2 ANU FX2 EQL FX3 TH£N

BEGIN LAM

1=

1i

GO

TO

M8i

END;

T1

1=

4

x

Fx3

x

DlL

x

LAM

x

(FXl

x LA~

• FX2

~

DEL

t FX~)j

G

1=

LAM

x

LAM

x

fXl • DEL

x

DEL

x

FX2

+

fX3

x (LA~

+

UEL)I

LAM

1= (-2 x

FX3

x

DEL) / SPfCG

x

G

+

Tl,

G)i

Mdl

ITC

1=

ITt

+

1;

xl 1= X2; Xi 1= Xl; fXl 1= FX2;

FX~

1= fX3J

H

1=

LAM

x

1'1;

M61

UEL

1=

LAM

+

1;

X3

1=

X2

+

H;

FX3 1=

fW~CTICN(X3);

IF fX2 NEQ

~

THEN

If ABSCFXJ/tX2)

GfH

10 THEN

8EGl~

LAM 1= LAM

I

2;

H 1= H

I

2;

GO TO

~ei

ENU;

IF ABSCCXJ-X2)/X2) GTR EPl AND A8S<FXl)

GTR

Ep2

A~U

ITe

LS~

MXM

THEto; uO TO

MIj;

~RI~T

.THE

kOGT

fuUND IS"

SPACECS), x3;

PRINT ,THE

fU~cTIUN

EVALUATED AT

THIS

poI~T

IS#, SPACE(S),

FXJ;

END OF

tl,ULLI;.R;

CUMPLEx PROCEDUHE FCL);

VALUE Z;

COMPLEX

l.;

HETURN

Z~(LX(ZX(lx(Z~CZxCZx(l+1)+3)+2)+3)·1)+3)·2)+lJ

COMMENT

END OF

DECLARATIONS;

INPUTcINFILE,CRD,dO);

(32)

UUTpUT(LINE,LI~,l~U)J

"TSC·,ll)J

MULLEH(kEAO~'READ~'READN,HEAO~,REAU~'HEAC~,F)J

T~~

OUTPUT

FHU~

THE

PROGHAM LUUKS

LI~E T~IS:

THl R~~l FOUN~ IS .67ge53150~6

(33)

(34)

V. STRING PROCESSING

5.1 STRING VARIABLES

5.1.1 Simple String Variables and Arrays

In GTL, a string variable contains a string of characters; just as in ALGOL a variable of type REAL coptains a number. String variables are declared with declarator STRING in the same forms as REAL, INTEGER, and BOOLEAN variables in ALGOL. The declaration of string variables which are not formal parameters of a procedure must also contain a "size part" which specifies the size of a string variable, i.e., the maximum number of

characters which a string variable can contain. The simplest form of the size part is an unsigned i~teger enclosed in parentheses. The syntax of the string variable declaration is illustrated by the following examples:

STRING STR(5)

STRING CARDl, CARD2(80), LINE(120) OWN STRING TEMP(26)

STRING ARRAY SR[0:9] (lO)

STRING ARRAY SAl, SA2 [1:100J(8)

Thus the Simple string variable STR can contain at most 5 characters, CARDI and CARD2 at most 80 characters, etc. The specification OWN in this context has the same functional meaning as other types of OWN variables in ALGOL. Similarly, each element of the string array SR can contain at most 10 characters.

(35)

5.1.2 Substring Variables

The declaration of a string variable which is not a formal parameter of a procedure may contain the declaration of a substring variable.

A

substring variable is a string variable which references only a fixed part of (a "substring" of) the string variable which is declared. The substring variable identifier appears in the size part of the string declaration. The size part of the string variable declaration may now be defined as a list of one or more string length specifications enclosed in parentheses. Each string length specification is either

1) an unsigned integer, or

2) a substring variable identifier followed by a size part. Two or more string length specifications are separated by commas. The sum of the unsigned integers in the si2:e part determines the length of the string being declared. For example,

STRING A(9, B(14), 7)

means that A is a string variable which can contain at most 30 characters, and B is a string variable which is a substring of A containing at most 14 characters. The sum of the string length specifications occurring before the substring variable identifier determines the number of character posi-tions to be skipped in the main string before reaching the starting character position of the substring. The character positions of a string variable may be illustrated graphically by a set of contiguous "boxes", each box representing a single character position. Thus, the string variable A and its substring B, may be displayed graphically as follows:

(36)

A (30 characters)

1

-'-([1

I~·I-'-I6-I'--['

fJ-

'.'.m"

12 13

ill"

"

,-b·I'·'TI"

".1_

2 _{'1"1" {'}

_f"

_1 ___ ._ ..._ ___._ . __ _ ...

J

1 .. . ... j

"1'-'-0"

.J ____ I

~I1~1

I

r

B (14 characters)

Note that the definition of the size part allows the declaration of

substring variables to be "nested"; Le., a substring variable may contain a substring variable. For example,

STRING ST(STA(14),3,STB(2, STC(6),2, STD(3),1), 4)

may be displayed graphically as

ST (35 characters)

STB

When two or more string variables are associated with a size part which contains substring variables, the main string with which a substring

identifier is to be associated in any particular instance must be given explicitly. For example, with the string declaration,

STRING A, B, C(72, SEQ(8»

(37)

SEQ IN A

SEQ IN B

SEQ IN C

This form of the substring variable may be used like any other string variable. Ambiguously defined substrings of subscripted string variables are handled in the same way. For example, with the following string array declaration,

STRING ARRAY R, S [O:99](T(I),7)

if J represents a subscript expression for elements of the string arrays Rand S, then one of the following forms must be used when referring to the substring T:

T IN R [J]

T IN S [J]

This form of the subscripted string variable may be used like any other string variable.

5.1.3 Formal String Variables

A formal string variable, i.e., a string variable which is a formal parameter of a procedure, is declared without a size part. The maximum number of characters that a formal string variable can contain will depend on the size of the corresponding actual parameter of the function designator.

(See paragraphs 5.7.1 and 5.7.2.) In a procedure declaration which contains a formal string variable, the size of the string variable may be determined by the application of the GTL standard function LENGTH to the formal string

(38)

variable identifier, For example, if STR is a simple formal string variable and STRA is a formal string array, the

LENGTH (STR) and LENGTH (STRA)

gives the sizes of these formal string variables.

5.2 STRING DESIGNATOR

In GTL, the string designator is a construct which allows the programmer to refer to a string variable or any proper substring thereof. The defini-tion of string designator inGludes the string variable, and has the three following forms:

SV SV(ael) SV(ae2,ae2)

where SV represents a string variable, either simple or subscripted, and ael and ae2 represent arithmetic expressions. The first form of the

string designator is simply the string variable itself. The second form of the string deSignator is the substring of SV obtained by skipping over the first ael characters in SV; the size of the substring is the number of remaining characters. The third form of the string designator is the

(39)

For example, given the string declaration,

STRING CARD (72, SEQ(8»

the string designator

CARD (72)

refers to the same substring of CARD as the substring variable SEQ. Given

the string declaration,

STRING A(9, B(14), 7)

the string designator,

A(9, 14)

refers to the same substring of A as the substring variable B. The string

designators A(2,4) and A(9,14) are illustrated graphically below.

A (30 characters)

A(2,4) A(9,14)

5.3 STRING EXPRESSIONS

5.3.1 String Expression Forms

In ALGOL, an arithmetic expression may be considered as a set of rules

which, when executed, generates a value which is a number; in GTL, a string

expression is a set of rules which produces a value which is a string of

characters.

(40)

A string expression is either a string primary, which has a string of characters as its value, or two or more string primaries separated by ampersands (& - the "concatenate operator"). The latter form has as its value the string produced by "joining together" the values of the con-stituent string primaries. The string primaries are described in para-graphs 5.3.2 through 5.3.19.

5.3.2 The Quoted String

The quoted string has the same syntactical form as a string in

Burroughs Extended ALGOL, i.e., a string of characters enclosed in quotes ("). The quote mark itself may be quoted: ''''''. The value of the quoted string is the string of characters appearing between the quote marks. The quoted string may not exceed 420 characters in length.

Examples:

"A"

"THIS IS A QUOTED STRING"

"""

5.3.3 String Designator

When used as a string primary, the value of the string designator is the string of characters in the string variable, or substring thereof, referenced by the string designator.

5.3.4 String Assignment Statement

(41)

assigned to the variables in the left part list. An extension of the

syntax of a string assignment statement is described in Subsection 5.4.

5.3.5 String Function Designator

A string function designator is a calIon a procedure which was

declared with the type STRING, its value being the value to which the

string procedure identifier is assigned in the string procedure declaration.

The value of a string function designator may not exceed 7 characters in

length. The formal parameters of the procedure, if any, may be of any

type, including the string formal parameters discussed in Subsection 5.7.

For example,

STRING PROCEDURE REVERSE(S); VALUE S; STRING S;

BEGIN REAL L;

REVERSE:::;;

IF (L:= LENGTH(S» = 1 THEN S ELSE

S(L-l,l)

& REVERSE(S(O,L-l»;

END OF REVERSE

defines a procedure which has as its value the string of characters in the

string S in reverse order:

REVERSE("ABC") ::;; CBA

5.3.6 SPACE function

The SPACE function is used to generate a specified number of spaces in a

string expression. The SPACE function may be used in one of the following

forms:

(42)

n SPACE

where n is an unsigned int~~er, and

SPACE(~)

where ~ represents an arithmet~c expression. The SPACE function will

generate the number of ~pace~ specified by the value of n or ae. For

example, if J is a real variable having a value of 40 then,

40 SPACE

SPACE (40)

SPACE(J)

all have the effect of generating 40 spaces.

5.3.7 The NIL Function

The NIL function is used to generate a specified number of zeros

(the character "0") in a string expression. The NIL function may be used

in one of the two following forms:

n NIL

where n is an unsigned integer, and

NIL(~)

where ~ represents an arith~etic expression. The NIL function will

generate the number of zeros ~pecitied by the value of n or ae. For

(43)

40 NIL

NIL

(40)

NIL(J)

all have the effect of generating

40

~eros.

5.3.8 The String Skip Indicator

The string skip indicator ha.s the effect of creating a gap in the string being generated by the string expression in which it appears. Its actual effect depends on the context of the string expression: If it is used in a string expression which is assigned to string variable in a string assignment statement (see Sub~ection 5.4), it causes the indicated number of character positions to be skipped over in the string variable during the execution of the assignment statement (see paragraph 5.4.4). If it appears in the string expression on the right hand side of a string relational expression (see Subsection 5.5), it causes the indicated number of characters in the string designator (on the left hand side) to be ignored in the process of de,termining the Va,11,l8 of the string relational expression

(see paragraph 5.5.4).

The string skip indicator ma.y be used in one of the two following forms:

where n is an unsigned integer, and

where ~ represents an arithmetic expression; for example, if J is a real variable having a value of

40,

then

(44)

40 -k

,,;- (40)

-k (J)

all have the effect of causing 40 characters to be skipped over.

5.3.9 The QMARK Function

The QMARK function, used in the form,

QMARK

in a string expression will generate one question mark (?) or invalid character. This function is provided since the question mark cannot be quoted in a GTL program, and there would be no other simple way of generating this character.

5.3.10 The Bit Expression

A bit expression is a string primary which generates a string of bits (not the characters "1" and "O"~ but the actual bit components of

characters). If any characters are generated in the remainder of the string expression, the first of these characters will start at a position equal to the position of the last character generated before the bit expression plus the smallest multiple of six bits containing the bit string (since a

character is six bits long). The syntax and semantics of the bit expression are explained in Subsection 5.6.

5.3.11 The Restricted Boolean Expression

(45)

a string primary itself. The value of the Boolean expression in this

context will be a string of letters, "TRUE" or "FALSE", depending on the

value of the Boolean expression.

5.3.12 The Restricted Arithmetic Expression

A restricted arithmetic expression, i.e., an arithmetic expression

which does not begin with any of the other preceding string primaries, may

be used as a string primary itself. The value of the arithmetic expression

in this context will be an unsigned string of digits up to 7 characters in

length representing the value of the arithmetic expression. If the value

of the arithmetic expression cannot be represented in this way, then the

string value of the expression is undefined. For example, if R is a real

variable with a value of 25, then

R ® 10

when used as a string primary, will generate the string "250".

5.3.13 The Restricted Symbol Expression

A restricted symbol expression (Section VI), i.e., a symbol expression

which does not begin with any of the other preceding primaries, may be used

as a string primary itself. The value of the symbol expression in this

context must be an atomic symbol, which is converted into the string which

the atomic symbol represents. For example, if S is a symbol variable

having as its value the list (THIS IS A LIST), then

CAR(S)

(46)

5.3.14 The STRING Transfer Function

The STRING transfer function, when used in the form,

STRING(.!~)

where ~ represents an arithmetic expression, will generate the equivalent alpha representation of the value of the arithmetic expression (up to 7 characters in length), left-justified. For example,if R is a real or alpha variable, the value of which is the alpha string "AB", then

STRING(R)

will generate the string "AB". If the value of R is 250, then "3," will be generated.

A string which is right-justified in a field of E characters may be produced by the following variant of the STRING transfer function:

STRING(aexp,E)

where aexp is the arithmetic expression to be converted, and E is an unsigned integer, ranging from 1 to 7, which specifies the size of the resulting

string. For example, if R is a real variable containing the ALPHA string "AB", then the value of

STRING (R,4)

would be the string "OOAB". If R has a value of 250, then

STRING(R,l)

(47)

5.3.15 The SUBST Function

The string-valued function SUBS! allows the programmer to make charac-ter-for-character substitutions in a string variable. The SUBST function may be used in two forms, the first of which is

SUBST(string designator, substitution pair list)

where string designator must be a string variable, or designated substring thereof, and substitution pair list is a list of one to 12 substitution pairs of the form

matching character substitution character

where substitution character is the quoted character which is to replace the quoted special character matching character. The matching character cannot be the "blank" character. The length of the string designator must not be greater than 126 characters, and if longer than 63 characters it must be an even number; also, the string variable may not be a formal parameter. The value of the SUBST function is the contents of the string designator after the substitutions have been made. For example, if the string CARD contains "AR[INDEX]", then

CARD:= SUBST(CARD(O,72),"[":"(","]":")")

will change this string to "AR(INDEX) " •

The second form of the SUBST function is

SUBST(string deSignator, substitution table)

where string designator has the same meaning as above, and substitution table