1169844_A_Series_ALGOL_Part_1_3.6_Dec85 1169844 A Series ALGOL Part 1 3.6 Dec85

1169844_A_Series_ALGOL_Part_1_3.6_Dec85 1169844_A_Series_ALGOL_Part_1_3.6_Dec85

User Manual: 1169844_A_Series_ALGOL_Part_1_3.6_Dec85

Open the PDF directly: View PDF PDF.
Page Count: 480

Download1169844_A_Series_ALGOL_Part_1_3.6_Dec85 1169844 A Series ALGOL Part 1 3.6 Dec85
Open PDF In BrowserView PDF
Burroughs

Reference
Manual

Distribution Code SE

Priced IIem
Printed In U.S.A.
December 1985

1169844

Burroughs cannot accept any financial or
other
responsibilities that may be the result of your use
of this information or software material, including
direct, indirect, special or consequential damages.
There are no warranties extended or granted by this
document or software material.
You should be very careful to ensure that the use of
this software material and/or information complies
with the laws, rules, and regulations
of
the
jurisdictions with respect to which it is used.
The information contained herein is subject to change
without notice. Revisions may be issued to advise of
such changes and/or additions.

Comments or suggestions regarding this
document
should be submitted on a Field Communication Form
(FCF) with the Class specified as "2"
(System
Software). the Type specified as "1" (F.T.R.), and
the Product specified as the seven-digit form number
of the manual (for example. "1169844"). The FCF
should be sent to the following address:
Burroughs Corporation
PA&S/orange County
19 Morgan
Irvine, CA 92 7 18

CONTENTS

1

2

3

4

INTRODUCTION .. • • • •
ORGANIZATION OF THIS MANUAL. .
Using the Manual . .
Finding Information.
RELATED DOCUMENTJ . .

1
3
6

PROGRAM STRUCTURE. •
PROGRAM UNnr . . .
SCOPE. . . . . . .
Local Identifiers . .
Global Identifiers .

9
9

6

8

12
13
13

LANGUAGE COXPONENTS.
BASIC SYMBOL .
IDENTIFIER .' • .
NUMBER . . . . . .
Number Ranges . . . . . . . . . .
Compiler Number Conversion .
Exponents., . .
REMARK . . .' .
STRING LITERAL .

15
16
21

DECLARATIONS ,0 •
ARRAY DECLARATION.
. . . .
ARRAY REFERENCE DECLARATION . .
BOOLEAN DECLARATION . .
COMPLEX DECLARATION . .
DEFINE DECLARATION . .
Define Invocation . .
DIRECT ARRAY DECLARATION
DOUBLE DECLARATION . . . .
DUMP DECLARATION . • . .
EVENT AND EVENT ARRAY DECLARATIONS .
EXPORT DECLARATION . .
FILE DECLARATION . . . .
FORMAT DECLARATION . . .
Editing Phrase Letters . .
... ..
Editing Modifiers. . . . .
. .... .
FORWARD REFERENCE DECLARATION . . . . . . .
INTEGER DECLARATION . . .
INTERRUPT DECLARATION.
LABEL DECLAR~TION . . .
LIBRARY DECLARATION . .
LIST DECLARA.TION . . .
MONITOR DECLARATION . .
OUTPUTMESSAGE ARRAY DECLARATION . .
PICTURE DECLARATION . .
POINTER DECLARATION . .
PROCEDURE DECLARATION.

39
41

23

25
26
26

27
30

52
55
58

60
61
68
71
73

· .
· .
·

•

· .
· •
• .
.
•

.

78
81
85
89
98
120
121
123
126
128
129
132
136

• 141

. 147
· . 160
• . 165
iii

REAL DECLARATION . . . . .
STRING DECLARATION . . .
STRING ARRAY DECLARATION
SWITCH FILE DECLARATION . .
SWITCH FORMAT DECLARATION.
SWITCH LABEL DECLARATION . .
SWITCH LIST DECLARATION . .
TASK AND TASK ARRAY DECLARATIONS .
TRANSLATETABLE DECLARATION
TRUTHSET DECLARATION . . .
TYPE DECLARATION . . . . . . .
VALUE ARRAY DECLARATION . .
5

STATEMENTS . .

·

.

. .. .

ACCEPT STATEMENT . . .
ASSIGNMENT STATEMENT . .
Arithmetic Assignment.
Array Reference Assignment .
Boolean Assignment . . . .
Complex Assignment . . . .
Mnemonic Attribute Assignment . .
POinter Assignment . . . . .
String Assignment . . .
Task Assignment . . . . . .
ATTACH STATEMENT . . .
BREAKPOINT STATEMENT
Interaction with the Breakpoint Intrinsic . . .
CALL STATEMENT . .
. . . .
CANCEL STATEMENT . . .
CASE STATEMENT . .
CAUSE STATEMENT.
CAUSEANDRESET STATEMENT . .
CHANGEFILE STATEMENT
CHECKPOINT STATEMENT
Checkpoint/Restart Messages.
CLOSE STATEMENT . . .
CONTINUE STATEMENT .
DEALLOCATE STATEMENT .
DETACH STATEMENT .
DISABLE STATEMENT . . .
DISPLAY STATEMENT . . .
DO STATEMENT . .
ENABLE STATEMENT . .
EVENT STATEMENT . . .
EXCHANGE STATEMENT .
FILL STATEMENT .
FIX STATEMENT . .
FOR STATEMENT . .
FREE STATEMENT .
FREEZE STATEMENT . .
GO TO STATEMENT.
Bad Go To . .
I/O STATEMENT. .

iv

.

.

. 182
185
. 187
. 189
. . . 192
· . . 195
· . 197
199
202
207
· . . 212
· . . 214

·
·
·

.
.
.
·

. 219
. ~21
. 223
. 225
231
· . 234
· . . 237
· . . 239
241
· . 243
246
248
250
· . . 251
· . 259
· . 261
263
· . 266
· . . 268
. . . . 270
· . . 273
277
280
· 285
· . 287
288
· . 289
291
· 293
295
· 297
298
· 300
303
· 305
· . 311
312
. . . 313
· 313
315

Normal I/O • .
Direct I/O .
IF STATEMENT
INTERRUPT STATEMENT . .
INVOCATION STATEMENT .
LIBERATE S~rATEMENT .
LOCK STATEMENT . . .
MERGE STATEMENT . . .
MESSAGESEARCHER STATEMENT. .
MULTIPLE ATTRIBUTE ASSIGNMENT STATEMENT. .
ON STATEMENT . . . .
OPEN STATEJIENT . . .
POINTER STATEMENT. .
PROCEDURE INVOCATION STATEMENT . .
Calling Procedures with Parameters .
PROCESS STATEMENT. . .
. . . . • .
PROCURE STATEMENT. . . .
PROGRAMDUMP STATEMENT . . .
READ STATE1J[ENT . . . . .
Data Format for Free-field Input
REMOVEFILE STATEMENT . . . .
REPLACE STATEMENT. . . . • • . .
 Combinations .
.
String Literal Source Parts . .
Arithmetic Expression Source Parts.
. ...
Pointer Expression «source» Source Parts
Source Parts with Boolean Conditions . .
Other Source Parts . . • . . .
REPLACE FAMILY-CHANGE STATEMENT.
REPLACE POINTER-VALUED ATTRIBUTE STATEMENT . . . .
RESET STATEMENT. .
RESIZE STATEMENT
REWIND STATEMENT .
RUN STATEMENT . . .
SCAN STATEMENT • .
 Combinations .
. ..•
Scan Parts Without Count Parts . .
. ...
Scan Parts with Count Parts . • .
SEEK STATEMENT . .
SET STATEMENT . .
SORT STATEMENT .
Arrays in Sort Procedures.
SPACE STATEMENT. . . . .
SWAP STATEMENT .
THRU STATEMENT .
WAIT STATEMENT . .
WAITANDRESE~r STATEMENT .
WHEN STATEMENT . .
WHILE STATE11ENT.
WRITE STATEMENT. .
ZIP STATEMENT.
6

EXPRESSIONS. .. . . .

·

·
.
·
•
·
·

·
. .
. .
. .
. •
..
. .

316
316
319
322
323
324
325

· . 327
·

.

·
.

. 329
. 332
· 334

· 340
· . . 342
·
·

.
.

. 346
• 348

350
· 353
· • 355
· 359

· . 371
· 377
.

·
.

.
.

. 379
. 386

· . 387
392
· 39q
403

407
·

.

. . .

·

• 409
· 411
· 414

· 415
· 423
425
. . 427
428

· . 429
· 430
433
· . 435
·

.

• . 436

· . 443
· . . 445
·

. 447

450
· . 452
456
·

. 458

· . 459
· . . 461
470
· 473

v

6.1

6.2

EXPRESSIONS: CONCEPTS AND TYPES .
473
ARITHMETIC EXPRESSION.
475
ArithmetiC Primaries . .
. .. .
· 477
Arithmetic Operators. .
. ... .
· 478
Precedence of Arithmetic Operators . .
· 480
Precision of ArithmetiC Expressions.
· 481
Types of Resulting Values.
. ....
482
BIT MANIPULATION EXPRESSION . .
· 484
Concatenation Expression . .
. . . 484
Partial Word Expression . . .
489
BOOLEAN EXPRESSION . . . . . .
· 491
Operators in Boolean Expressions .
· . 496
Precedence in Boolean Expressions . .
· 498
Boolean Primaries . .
· . 499
CASE EXPRESSION . . . . . . . .
504
COMPLEX EXPRESSION . . .
· 506
CONDITIONAL EXPRESSION .
· 510
DESIGNATIONAL EXPRESSION
· 512
FUNCTION EXPRESSION . . . .
· . 514
ArithmetiC Function Designator. . . . . . . . . . . . . 514
Boolean Function Designator.
. . . . . . . . . . . 515
Complex Function Designator.
· 516
Pointer Function Designator.
517
String Function Designator .
· 518
POINTER EXPRESSION .
· 519
STRING EXPRESSION.
523
INTRINSIC FUNCTIONS. . . . . . .
· . 528
INTRINSIC NAMES BY TYPE RETURNED .
· . 528
ArithmetiC Intrinsic Names .
· 528
Boolean IntrinsiC Names . . . . . .
· 531
Complex Intrinsic Names . . .
· 531
Pointer Intrinsic Names . . . . . . .
· . 531
String Intrinsic Names .
531
INTRINSIC FUNCTION DESCRIPTIONS . .
· . 532

7

COMPILING PROGRAMS .

7.1

FILES USED BY THE COMPILER
INPUT FILES.
CARD File. . .
TAPE File. . . .
INCLUDE Files.
HOST File . .
INFO File.
OUTPUT FILES .
CODE File.
NEWTAPE File .
LINE File . . .
ERRORFILE File . .
XREFFILE File.
INFO File. . . .
SOURCE RECORD FORMAT . .
COMPILER CONTROL OPTIONS
COMPILER CONTROL RECORDS . .

7.2
7.3

vi

·
·
·

·
·
·

· 587
587
. 589
· 589
. 589
. 590
590
· 590
· 591
. 591
. 591
. 591
· 592
· 593
· 593
· 594
· 595
596

OPTION DESCRIPTIONS . .
8

9

9.1
9.2
9.2.1

9.2.2
9.2.3
9.3

· . 603

INTERFACE TO 'THE LIBRARY FACILITY.
• • • • •
FUNCTIONAL DESCRIPTION OF LIBRARIES.
·
Library Programs . . . . . . . . . . . . . . . . . . . .
Calling Programs . . • . . . . . .
· .
Library Directories arid Templates.
·
Library Initiation . . . . . . . .
Linkage Provisions . .
...............
Discontinuing Linkage. .
·
Error Handling . . . . . . . . .
· .
CREATING LIBRARIES . . . .
· •
Library Sharing Specifications .
REFERENCING LIBRARIES . . . . .
·
Library Attributes . . . . .
·
Entry Point Type Matching. . . . . . . .
· •
Parameter Passing. . . . .
· .
LIBRARY EXAM:PLES . . . . . . . .
·
Library: OBJECT/FILEMANAGER/LIB. .
·
calling Program #1 . . . . . . . .
· .
Library: OBJECT/SAMPLE/LIBRARY . .
· .
Library: OBJECT/SAMPLE/DYNAMICLIB.
Calling Program #2 .
. . • . .
•

656
656
656
656
657
659
660
660
662
662
664
665
668
669
671
671
674
675
676
678

DIISII INTERFACE. . . . .
INVOKING A DA'rABASE. . .
DATABASE DECLARATION .
DATABASE EQUATION. • .
BDMSALGOL BASIC LANGUAGE CONSTRUCTS.
BDMS IDENTIFIERS AND QUALIFICATION.
BDMS IDENTIFIERS . . . . • . . . .
IDENTIFIERS OF OCCURRING ITEMS .
QUALIFICATION. . .
REFERENCING DATABASE ITEMS. .
INPUT MAPPING. . .
OUTPUT MAPPING . .
.
THE SELECTION EXPRESSION
BDMSALGOL STATEMENTS . .
ASSIGN STATEMENT . . .
BEGINTRANSACTION STATEMENT
BDMS CLOSE STATEMENT .
CREATE STATEMENT . . .
.
DELETE STATEMENT . . .
DMTERMINATE STATEMENT.
ENDTRANSACTION STATEMENT
FIND STATEMENT . . . .
BDMS FREE STATEMENT.
GENERATE STATEMENT . . . . . .
GET STATEMENT. . . . .
INSERT STATEMENT . . .
BDMS LOCK STATEMENT. .
MIDTRANSACT][ON STATEMENT . .
MODIFY STATEMENT . . . .

680
680
689
691
691
691
692
693
695
696
700
703
708
709
712
715
718
721
724
726
729
732
734
737
739
741
744
746

•

. . . . .
. . . .
. .
.
. . . ..
. . . . .
. .

. ..
. . .
.
.
. . .
. .

. . . . . . . .
. . . .
.

655

• 679

..
. .
. . . .
. .
....
. .
. . . .
. . . .
. .
. . . .
. . . .
·

· .
. . . . . . . . . . . .
. . ..
....
. ..
.......
· .
• .
·
·
·
·
. . . . .
. . . .
·

vii

9.4

9.5

9.6
9.7

BDMS OPEN STATEMENT.
PUT STATEMENT . . . .
RECREATE STATEMENT .
REMOVE STATEMENT . .
BDMS SET STATEMENT . .
STORE STATEMENT . . .
BDMSALGOL FUNCTIONS . . . .
DMTEST FUNCTION . .
STRUCTURENUMBER FUNCTION
EXCEPTION PROCESSING .
DATABASE STATUS WORD . . .
EXCEPTION HANDLING . . .
BDMSALGOL COMPILER CONTROL OPTIONS
BINDING AND SEPGOMP OF DATABASES
BINDING . . .
SEPCOMP . .

·
·
· . .
· . .
·
. . . . . . . .
. . . . .
. . . . .

. .
·
. .
. .
·
• .
. .
. .
. .
.
. .
·
·
·
·
·

747
750
752
754
757
760
763
763
766
768
768
769
772
774
774
776

10

COKPILE-TIME FACILITY.
• 777
COMPILE-TIME VARIABLE. .
· . 777
COMPILE-TIME IDENTIFIER.
· 779
COMPILE-TIME STATEMENTS.
· . . . . 780
'BEGIN Statement . . . . . .
. .. .
· . . 781
'DEFINE Statement . . . . . . . . . . . . . . . . .
· 781
'FOR Statement . . . .
· 782
'IF Statement . . .
· 783
'INVOKE Statement.
· 784
'LET Statement .
784
'THRU Statement . . . . . . . . . . .
· 785
'WHILE Statement .
. . . .
· 785
EXTENSION TO THE DEFINE DECLARATION . .
· 786
COMPILE-TIME COMPILER CONTROL OPTIONS.
· 787

11

BATCR FACILITY
BATCH SOURCE INPUT . .
IMPLEMENTATION SCHEME . .

• 789
· 791
· 796

A

RESERVED WORDS . • . . . .
RESERVED WORDS LIST . . .
RESERVED WORDS BY TYPE
Type 1 Reserved Words.
'Type 2 Reserved Words.
Type 3 Reserved Words.

• 799
· 800
803
· 803
· 803
805

B

viii

.
.

DATA REPRESENTATION • . . ~ .
FIELD NOTATION . . . . .
CHARACTER REPRESENTATION
Character Values and Graphics . .
Default Character Type . .
Signs of Numeric Fields.
ONE-WORD OPERAND .
....
Real Operand . . .
Integer Operand . .
Boolean Operand.

·
. · . ·

·

• 807
· . 807
· . 808
· . 811
· 817
· 819
· 820
· 820
· . . . . 821
. . . . . . 823

c

TWO-WORD OPE~~ND .
Double-Precision Operand .
Complex Operand. . . . .
DATA DESCRIPTORS AND POINTER

•
•

•
•
•
•

RUN-TIME FORllAT·-ERROR MESSAGES

·

. 831

UNDERSTANDING RAILROAD DIAGRAMS . .
GLOSSARY.

824
824
826
827

· 837
·

. 847

INDEX . .

ix

1

1.

INTRODUCTION

Purpose of this Manual

reference manual is intended for use by the programmer who is
familiar with ALGOL. Both the org~nization and the presentation of the
material are designed to supply answers to well-conceived questions
regarding the syntax. semantiCS, and pragmatics of ALGOL as implemented
on A Series systems. This manual is not a tutorial text.
~rhis

lBurroughs Extended ALGOL

Burroughs Extended ALGOL is a high-level. structured
programming
language designed for A Series and B 5000/B 6000/B 7000 Series systems.
In addition to implementing virtually all of ALGOL 60, Burroughs
Extended ALGOL has provisions for communication between programs and
input/output (I/O) devices. the editing of data. and the implementation
of diagnostic facilities for program debugging.

'The Structure of ALGOL

The fundamental constituents of ALGOL are the language components.
These are the building blocks of the language and include, among other
things,
letters, digits. and
special
characters
such
as
the
semicolon (:).

At a level of complexity higher than
language
components
are
declarations.
statements. and expressions.
These are the building
blocks of ALGOL programs. A declaration associates identifiers with
specific properties. For example. an identifier can be associated with
the properties of a rE!al number. A statement indicates an operation to
be performed. such as the assignment of a numerical value to an array
element or the tranSfE!r of program flow to a location in the program out
of the normal sequence.
An expression describes operations that are
performed on specified quantities and return a value. For example.
the
,expression "SQRT( 100) returns 10.0, the square root of 100.
III

Note: Burroughs Extended ALGOL is .based on the "Revised Report on the
Algorithmic Language ALGOL 60" (Communications of the ACM. Vol. 6.
No.1; January, 1963).

2

ALGOL REFERENCE MANUAL
At the highest level are program units. A program unit is any group of
ALGOL constructs that can be compiled as a whole by the ALGOL compiler.
An ALGOL program is, by definition. a program unit.
This manual describes the language components. declarations, statements,
expressions. and program units of Burroughs Extended ALGOL. Unless
otherwise stated. the word ALGOL refers to Burroughs Extended ALGOL.

3

Introduction
ORGANIZATION OF THIS MANUAL

The earlier chapters dE~scribethe fundamentals of ALGOL: the structure
of programs and the basic components of the language. The middle
chapters describe thE? major constructs of
ALGOL:
declarations,
statements, and expressions. The later chapters describe topics related
to compiling ALGOL programs, and interfaces between ALGOL and other
facilities such as libraries and Data Managem~nt System II (DMSII). The
appendixes contain refl?rence information about reserved words and about
the format used internally to store data.
The manual contains the following chapters and appendixes.

Chapters

2

PROGRAM STRUCTURE
This chapter defin,es the basic structure of an ALGOL program and the
scope of variables.

3

LANGUAGE COMPONENTS
This chapter defines the most
language.

41

elemental

constructs

in

the

ALGOL

DECLARATIONS
This chapter defines the constructs that establish data structures
in an ALGOL program and associate identifiers with those data
structures.
These constructs are
ordered
alphabetically
by
declaration name.
STATEMENTS
This chapter defines the constructs that describe operations to be
performed in an ALGOL program.
These constructs are ordered
alphabetically by statement name.

/.

4

ALGOL REFERENCE MANUAL
6

EXPRESSIONS
This chapter defines the constructs used to describe operations that
are performed on specified quantities and return a value. The first
part of the chapter describes the types of expressions. These types
are ordered alphabetically by expression name. The second part of
the chapter describes functions that are intrinsic to ALGOL.
These
functions are ordered alphabetically by their names.

7

COMPILING PROGRAMS
This chapter describes the various input and output files used by
the ALGOL compiler and the compiler control options that control the
compiler's processing of ALGOL source input.

8

INTERFACE TO THE LIBRARY FACILITY
This chapter
initiation.

9

describes

creation,

ALGOL

interface

sharing,

and

with

Data

Management

COMPILE-TIME FACILITY
This chapter describes how ALGOL
conditionally and iteratively.

11

use,

DMSII INTERFACE
This chapter describes the
System II (DMSII).

10

library

source

data

can

be

compiled

BATCH FACILITY
This chapter describes how the cost of system overhead
reduced by grouping programs together in a single run.

may

be

5

Introduction
Appendixes

A

RESERVED WORDS
This appendix lists the identifiers that need not be declared in an
ALGOL program before they are used, if they appear in recognized
contexts.

B

DATA REPRESENTATION
This appendix describes the internal form of the various operands,
the descriptor, the pointer, and the various character sets.

C

RUN-TIME FORMAT-ERROR MESSAGES
This appendix interprets the error numbers given at run time when an
error occurs in a READ or WRITE statement.

An explanation of railroad diagrams, a glossary, and an index appear
the end of this manual.

at

ALGOL REFERENCE MANUAL
Using the Manual

The chapters that describe declarations, statements, and expressions are
each divided into sections describing constructs appropriate to the
chapter. In the table of contents, sections are indicated by the major
unnumbered subheadings under the chapter titles. Within the chapters
that describe declarations and statements. and within the first half of
the chapter on express~ons, the sections are ordered alphabetically and
follow the same general format:
The syntax for the construct is presented in a railroad diagram.
This is a diagrammatic description of the acceptable ways of
using the construct in a program.
For those unfamiliar with
railroad diagrams, a description of how they are read can be
found in "Understanding Railroad Diagrams."
Under the heading "Semantics" appears a description of the
function of the construct. If further explanation of the syntax
is required, it occurs here.
Under the heading "Pragmatics" appears information
implementation of the construct on A Series systems.

about

the

Examples of use of the construct usually appear at the end of the
section.
The chapter on expressions is divided into two sub-chapters. The first
sub-chapter describes the types of expressions. The second sub-chapter
describes functions that are intrinsic to ALGOL. The two sub-chapters
are ordered alphabetically by expression name and function name,
respectively. In the sub-chapter on functions. the syntax for each
function is presented, and the action of the function and data type
returned by the function are given.
Finding Information

Because of the alphabetical ordering of the chapters on declarations,
statements, and expressions, the reader can quickly find the description
of any of those language constructs.
While using the manual, the reader will find "See also" references.
These point to information related to the subject under discussion.
"See also" references do not include references to whole chapters or to
alphabetically ordered sections.
These can easily be found using the
chapter tabs and the section headings that appear at the top of each
page in the alphabetized chapters. Neither do "See also" references
include the fundamental language constructs that appear in the "Language
Components" chapter.
It is assumed that a reader will have an

7

Introduction
understanding of the contents of that chapter before trying to
rest of the manual.

use

the

"See also" references do include met~tokens (language constructs) below
the level of declarations, statements, and expressions that appear in a
section but that are not defined in ~hat section. "See also" references
also point the reader to other. less easily found, related information.
For example, the folloViring is the syntax for the CHANGEFILE statement, a
statement used to change the names of directories and files without
opening the files:

CHANGEFILE -- ( ---- , ---)
>- ) ---------------------------~----------------------------------1


--------I
I

1

I-----------I
I

1

I------I
St?e also
 . . . . . . . . . . . . . . . . . . . . . . . . . .

43

It is
A cross reference to other syntax appears only for  .
assumed the reader is familiar with the syntax for 
because it is a basic construct. The syntax for 
ca.n be found quickly by using the index tab for the "Expressions"
chapter. and then by paging through the alphabetical listing of
expressions to the "Poi,nter Expression" section.

8

ALGOL REFERENCE MANUAL
RELATED DOCUJlENTS

Document

Form No.

ALGOL Test and Debug System (TADS) User's Guide

1169539

Binder Reference Manual

5014582'

CANDE Reference Manual

1169869

DMSII DASDL Reference Manual

1163805

DMSII Transaction Processing System (TPS)
Programmer's Manual

1164043

DMSII User Language Interface
Softwar~ Operation Guide

1180536

Editor User's Guide

1169976

I/O Subsystem Reference Manual

1169984

Message Translation Utility User's Guide

1169554

Operator Display Terminal (ODT) Reference Manual

1169612

System Software Utilities Reference Manual

1170024

Work Flow Language (WFL) Reference Manual

1169802

J"

9

2.

PROGRAM STRUCTURE

A program unit is a group of ALGOL constructs that can be compiled as
whole.
Syntax


--------------------

!

.

--------~---------------I

1

1

I--!

1

1
I~--I

1
1

1
1

1<--------- ;

I

1

-----~---I

1

1

1

I------------------------ . -I
1

1

1

I--I

1-

1

-I


-- BEGIN ----

---- END --I



1<------ ; -----1
1

1

~-------I



1<----- ; ----I
I

1

--------j

-- BEGIN ---- END --I

a

10

ALGOL REFERENCE MANUAL

----I

-- [ ---- ] --I

----I

Semantics

Program units can be blocks, compound statements, level 2 procedures. or
separate procedures that have a lexical (lex) level of three or greater
and that can have global declarations.
A block is a statement that groups one or more declarations and
statements into a logical unit by using a BEGIN-END pair. A compound
statement is a statement that groups one or more statements into a
logical unit by using a BEGIN-END pair. A compound statement is a block
without any declarations.
The definitions of a compound statement and a block are recursive: both
compound statements and blocks are made. in part. of statements. A
statement can itself be a compound statement or a block.
The structures of compound statements and blocks are illustrated below.
Compound Statements

BEGIN
;
:

:
END

BEGIN
;
(statement>;
BEGIN
;
BEGIN
;
;
END;
END;
;
END

11

Program Structure
Block.s

BEGIN
 ;
;

:
;
;

;
END

BEGIN
:
(declaration>:
:
BEGIN
:
;
END;
BEGIN
:
;
;
END:
END

A program unit that is a separate procedure is typically bound to a host
program to produce a more complete program.
The  construct allows global identifiers to be referenced
within a separate procedure. Any program unit that has a global part is
valid only for binding to a host.
A program unit can be preceded. but not followed, by a remark.
Pragmatics

A compound statement is executed in-line and does not require a
procedure entrance and exit.
A block, however, is executed like a
procedure and requires a procedure ~ntrance and exit. Entering a block
costs extra processor resources; entering a compound statement does not.

12
ALGOL REFERENCE MANUAL
Examples

Compound Statement

Block.

BEGIN
DISPLAY("HI THERE");
DISPLAY("THAT'S ALL FOLKS");
END.

BEGIN
REAL X;
X .- 100;
END.

Level 2 Procedure

Separate Procedure witb
Global Part

PROCEDURE S;
BEGIN
REAL X:
X .- SQRT(4956):
END.

[REAL S;
ARRAY B[0:255);
FILE LINE;)
REAL ~ROCEDURE Q;
BEGIN
Q := S*B[4];
WRITE(LINE,/,"DONE~};

END.
Note that, according to the syntax, the last statement of a block or
compound statement is not followed by a semicolon (;). However, in the
above examples (and throughout this manual), the last statement is
always followed by a semicolon. This is valid because the statement
before the END is the "null statement."

The scope of an identifier is defined to be the portion of an ALGOL
program in which the identifier can successfully be used to denote its
corresponding values and characteristics.
In one part of an ALGOL program. an identifier can be used to denote one
set of values and characteristics, while in another part of the program,
the same identifier can be used to denote a different set of values and
characteristics.
For example, in one block the identifier EXAMPLE_IDENT can be declared
as a REAL variable.
That is, the identifier can be used to store
single-precision, floating-poi~t arithmetiC values. Such an identifier
could be assigned the value "3.14159". In another block of the same
program. EXAMPLE_IDENT can be declared as a STRING variable.
In this
block, EXAMPLE_I DENT could be assigned the value "BURROUGHS ALGOL IS A
HIGH-LEVEL. BLOCK-STRUCTURED LANGUAGE".

'. 13

'Program Structure
Although EXAMPLE_INDENT can be of type real and of type string in the
same program, w1thina specific block. EXAMPLE_IDENT has only one type
associated with it. In general, the scope of an identifier is always
such that within a given block, the identifier has associated with it at
most one set of values and characteristics.

The scope of an identifier is described by rules that define which parts
of the program are included by the scope, which parts of the program are
excluded by the scope, and the requirements for uniqueness placed on the
choice of identifiers.
These general rules are described in the
following paragraphs.

Local Identifiers

An identifier that is declared within a block is referred to as "local"
to that block.
The value or values associated with that identifier
inside the block are not aSSOCiated, with that identifier outside the
block.
In other words, on entry to a block, the values of local
identifiers are undefined; on exit from the block, the values of local
identifiers are lost.
An identifier that is local to a block is
"global" to blocks occurring within the block. When a block is exited,
identifiers that are global to that block do not lose the the values
associated with them.
The properties of global identifiers
are
described more completely below.

~;lobal

Identifiers

An identifier that appears within a block and that is not declared
within the block. but is declared in an outer block, is referred to as
"global" to that block. A global identifier retains its values and
characteristics as the blocks to which .it is global are entered and
E?xi ted.

14
ALGOL REFERENCE MANUAL
As the following program illustrates, an identifier can be local to
block but global to another block.

one

BEGIN
FILE PRTR(KIND = PRINTER);
REAL A;
A := 4.2 @ -1: % FIRST STATEMENT OF OUTER BLOCK
BEGIN
LIST Ll (A);
L~

.r.cG:t:R A..

LIST L2 (A):
A := 3; % FIRST STATEMENT OF INNER BLOCK
WRITE (PRTR. */, LI);
WRITE (PRTR. */, L2);
END; % OF INNER BLOCK
A := A*A;
WRITE (PRTR. */, A):
END. % OF PROGRAM
In the preceding example, the identifier A that is declared REAL is
global to the inner block. The A declared as type INTEGER in the inner
block is local to the inner block, so when the inner block is exited,
the integer A and its value. 3, are lost. Within the scope of integer
A, a reference to A is a reference to the integer A, not to the global,
real A.
At the time the declaration for list LI is compiled. the
declaration for local A has not been seen, so list Ll contains the
global. real A.
However, the list L2 contains the local. integer A.
The A referenced in the outer block is the A that was declared REAL and
assigned the value 4.2 @ -1. The result of the first WRITE statement is
"A=O.42". The result of the second WRITE statement is "A=3".
The
result of the third WRITE statement is "A=O.1764". which equals
4.2 @ -1 * 4.2 @ -1.
Global identifiers are used in inner blocks for the following reasons:
1.

To carry values that have been calculated
into the inner block

in

2.

To carry a value calculated inside the block to an outer block

3.

To preserve a value calculated within a
later entry to the same block

4.

To transmit a value from one block to another block
not contain and is not contained by the first block

block

an

for

outer

use
that

block

in

a

does

15

J

LANGUAGE COMPONENTS

Language components are the building blocks of ALGOL. They consist of
basic symbols, such as digits and letters, and symbol constructs, which
are those groups of basic symbols that are recognized by the ALGOL
compiler.
Syntax


------------I
I
I
I--!

--------I
!
I
I---------I
I
!
I-------------I
I
I
I-------------I
I
I
I------I
I
I
I-----I
Semantics

Basic symbols, identifiers, numbers~ remarks, and string
described under separate headings in this chapter.
Because the define invocation is closely
the
declaration,
define
invocation
is
Declaration" in the chapter "Declarations."
Reserved words are
Words."

described

and

listed

in

literals

linked to
the
explained under

the

appendix

are

DEFINE
"DEFINE

"Reserved

16

ALGOL REFERENCE MANUAL
BASIC SnmQL
Syntax


-----------I
I
I
I------I
I
I
I--I

Anyone of the uppercase (capital) letters A through Z.

Anyone of the Arabic numerals 0 through 9.

---------I
I
I
I--I
I
I
I-----I

17

Language Components


--I
I
II
II
1- ]
1

1- "
/

1- BEGIN 1

/- END --I
1- # ----1

/- LB
1

1- RB


-- )""( --I

Any character string not containing a quotation mark (").

---------------I
I
---------------I
I
------------I
1

--I
I
-

-

-

----------------------------1
I
:=: ---------------------------1
I
& -----------------------------1
:=

18

ALGOL REFERENCE MANUAL


+

--------1

1

1

1- - -----1
1

1

1- * -----1
1

1

1- TIMES -I
1

1

1- MUX ---I
1

1

1- / -----1
1

1

1- DIV ---I
1

1

1- MOD ---I
1

I

1- ** ----I


NOT ----I
1

1

1- AND -I
1

1

1- OR --I
1

I

1- 1 ---I
1

1

1- EQV -I
I

1

1- IMP -I

--------I
1

1-

I

IS

-------------------------1

1

1-

1

ISNT

-----------------------1

Language Components

LEQ ----I
I
1
1- <= --I
I
I
1- LSS -I
1
1
1- < ---I
I
1
1- EQL -I
I
/
1- = --I
1- NEQ /

/- "=

--

/

1- GTR I
1- >

---

1

/- GEQ -

1
1- >=

--


CAT ----I
1

1

/- II --I


/<---------------1
/

1

--------I

One blank character.

20

ALGOL REFERENCE MANUAL
Semantics .

Only uppercase letters
are
permitted.
Lowercase
letters
are
specifically disallowed.
Individual letters do not have particular
meanings except as used in pictures and formats.
Digits are used to form numbers, identifiers, and string literals.
Delimiters include operators. spaces, and brackets.
An important
function of these elements is to delimit the various entities that make
up a program. Each delimiter has a fixed meaning, which, if not
obvious, is explained elsewhere in this manual in the syntax of
appropriate constructs. Basic symbols that are words, such as some
delimiters and operators, are reserved for specific use in the language.
A complete list of these words, called reserved words. and details of
the applicable restrictions are given in the appendix "Reserved Words."
In ALGOL ,60, spaces have no significance, because such
language
components as BEGIN are construed as one basic symbol. However. in a
machine implementation of such a language. this approach is not
convenient for programmers. In ALGOL, for example, BEGIN is composed of
five letters, TRUE of four letters, and PROCEDURE of nine letters.
No
space can appear between the letters of a reserved word; otherWise, the
reserved word is interpreted as two or more elements.
Reserved words and basic symbols are used, together with variables and
numbers, to form expressions. statements. and declarations. Because
some of these constructs place programmer-defined identifiers next to
delimiters composed of letters, these identifiers and delimiters must be
separated. Therefore. a space must separate any two language components
of the following forms:
1.

Delimiter composed of letters

2.

Ident if ier

3.

Boolean value

4.

Unsigned number

Aside from these requirements. the use of a space between any two
language components is optional.
The meanings of the two language
components are not affected by the presence or absence of the space.

21

Language Components
IDENTIFIER
Syntax


------------------------------I
i
I
1

I <------------------ I

1 I

I

I
I

1---/62\--------1
I
I
I-
---------------I
I

I

I--I

+
I

----I
1

1- - -I

--------------------------I
I

1

1

I--i

I

1

I---------------------I

------------~-----~----------I

I

I

I

I--I

I

I

I
I

1- . ----------------/
I

I-----------------------I

I <-------- !
I
I

--------I

----I

24

ALGOL REFERENCE MANUAL

-- @ -----------i
I

1

1- @ -I

---------------!
!
1
I--I

Semantics

No space can appear within a decimal number. All numbers that do not
contain the double-precision exponent delimiter "@@" are considered to
be single-precision numbers.

Examples

Unsigned Integers

Decimal Fractions

5

.5

69

.69
.013

Integers
1776
-6225b
+548

Valid Numbers

o
+545627657893
1.75@-46
-4.31468
-@2
.375

Exponent Parts
@8
@-06
@+54
@@lb

Decimal Numbers
69 .
.546
3.98
25

Unsigned Numbers
99.44
@-11
1354.543@48
.1864@4

25
Language Components
Invalid Numbers

50 00.5@8 8
1,505,278
@63.4
1.667E-Ol

Reason

Blanks spaces are not allowed.
Commas are not allowed.
Exponent part must be an integer.
"E" is not allowed for exponent part.

Number Ranges

The sets of numbers that can be represented in ALGOL are symmetrical
with respect to zero; that is, the negative number corresponding to any
valid positive number can also be expressed in the language and the
object program.

The largest and smallest integers and numb.ers that
are as follows (decimal versions are approximate):

can

be

represented

1.

Any integer between plus and minus 549755813887 = 8**13 - 1 =
4"007FFFFFFFFF", inclusive, can be represented in integer form.

2.

For single-precision numbers:
a.

The largest, positive, normalized, single-precision number
that can be represented is 4.31359146674@68 = (8**13 - 1)
* 8**63 = 4"lFFFFFFFFFFF".

b.

The smallest, positive,
normalized,
single-precision
number that can be represented is 8.75811540204@-47 =
8**(-51) = 4"3F9000000000".

Zero and numbE~rs wi th absolute values between the largest
smallest
values
given
above
can
be
represented
single-precisj.on real numbers.
3.

and
as

For double-precision numbers:
a.

The largE~st, positive, normalized, double-precision number
that
can
be
represented
is
1.94882838205028079124467@@29603 = (8**13
8**(-13»
*
8**32767 = 4"lFFFFFFFFFFFFFFFFFFFFFFF".

b.

The smallest, positive,
normalized,
double-precision
number
that
can
be
represented
is
1.9385458571375858335564@@-2958l
8**(-32755)
4"3F9000000000FF8000000000".

Zero and numbers with absolute values between the largest
smallest
values
given
above
can
be
represented
double-precision numbers.

and
as

26

ALGOL REFERENCE MANUAL
Compiler Number Conversion

The ALGOL compiler can convert into internal format a maximum of 24
significant decimal digits of mantissa in double precIsIon.
The
"effective exponent," which is the explicit exponent value following the
"@@" sign minus the number of digits to the right of the decimal paint.
must be less than 29604 in absolute value.
For example. the final
fractional
zero
cannot be specified in the smallest, positive,
normalized, double-precision number shown above:
-29581
(23
fractional
digits)
-29604.
Leading zeros are not counted in
determining the number of significant digits. For example, 0.0002 has
one significant digit, but 1.0002 has five significant digits.
The compiler accepts any value that can be represented in double
precision (not more than 24 significant decimal digits) as an unsigned
number. If this unsigned number does not contain an exponent part with
"@@" (specifying a double-precision value). then the single-precision
representation of that value is used. If the value represented by the
significant digits of such an unsigned number, when disregarding the
placement of the decimal point. is greater than 549755813887, then some
precision is lost if the unsigned number is converted to single
precision.
Exponents

The exponent part is a scale factor expressed as an integer power of 10.
The exponent part u@@ " signifies that the entire number is a
double-precision value.
If the form of the unsigned number used includes only an exponent part,
a deCimal number of 1 is assumed. For example, @-ll is interpreted as
l@-ll.

27

Language Components
REIIARK

Syntax

------------I
I
I
I--/
I
/
I---I

Any sequence of letters, digits, and
reserved words END, ELSE, or UNTIL.

spaces

not

containing

the


-- COMMENT ----

--I


Any sequence of EBCDIC characters not containing a semicolon (;).

-- % ----I


Any sequence of EBCDIC characters.
Semantics
Remarks are provided as methods
throughout an ALGOL source file.

of

inserting

program

documentation

The end remark can follow the language component END.
The compiler
recognizes the termination of the end remark when it encounters one of
the reserved words ENrD. ELSE, or UNTIL. or any nonalphabetic, nonnumeric
EBCDIC character. Defines are not expanded within an end remark.

28

ALGOL REFERENCE MANUAL
The comment remark is delimited by the word "COMMENT" at the beginning
and a semicolon (;) at the end. The comment remark can appear between
any two language components except within editing specifications.
Because remarks, string literals, and define invocations are language
components, a comment remark is not recognized within a string literal,
a define invocation, or another remark. Comment remarks can contain the
dollar sign ($). but the comment remark must not contain a dollar sign
as the first nonblank character on a source record. If a dollar sign is
the first nonblank character on a source record, the compiler interprets
the source record as a compiler control record.
The percent sign (%) preceding escape text in an escape remark can
follow
any language component that is not. contained in editing
specifications. The escape remark begins with the percent sign and
extends to the beginning of the sequence number field of the record.
The compiler does not examine the escape remark. When the percent sign
that precedes an escape remark is encountered, the compiler skips
immediately to the next record of the source file before continuing the
compilation.
Examples
The following program illustrates some syntactically correct uses of the
remark.
BEGIN
FILE F(KIND=PRINTER COMMENT;);
FORMAT COMMENT; FMT COMMENT; (A4,I6);
PROCEDURE P(X,COMMENT;Y,Z);
REAL X,Y COMMENT; ,Z;
% PERCENT SIGN CAN BE USED HERE
X := Y + COMMENT: Z;
% HERE TOe
IF COMMENT; 7 > 5 THEN
WRITE(F.<"OK"»:
IF 4 COMMENT; > 2 THEN
WRITE(F.<"OK"»;
IF 8 > 5 THEN
WRITE COMMENT; (F. <"OK"»;
END OF PROGRAM.

29

Language Components
The following program illustrates some invalid uses of the remark.
BEGIN
FILE F(KIND=PRINTER);
FORMAT FMT(13,FlO.3 COMMENT; ,A4);
ARRAY A[O:99];
REAL X;
FORMAT ("ABC", % CANNOT BE USED. "DEE");
WRITE(F.<"INVALID USE" COMMENT;»;
REPLACE POINTER(A) BY "ABCD COMMENT;EFGHIJ";
X := "AB,COMMENT;C";
COMMENT CANNOT BE USED HERE COMMENT; EITHER;
END.

30

ALGOL REFERENCE MANUAL

STRING LITERAL
Syntax



1<------------------------1
1

I

--------I

--------I
1
I----I


------ " ---- " --------------1
I
I
I--- " ---- " ---I
1

I--- " ---- "

1

-------------1

1

I--- " ---- " -I

31

Language Components

1

I

------1
I

1- 10 --I

I

\

1- 12 --I

I

j

1- 120 -I

I

I

1- 13 --I
\
I
1- 130 -I

I

I

1- 14 --I
I
I
1- 140 -I

I

1

1- 16 --I

I

I

1- 160 -I

I

I

1- 17 --I
1

I

1- 170 -I

I

I

1- 18 --I

I
I
1- 180 -\

I <-------- I
I
i
------ 0 ------1
I
I
1- 1 -j

32

ALGOL REFERENCE MANUAL

2

------1

1
1- 20 --I
I
1
1- 24 --I
I
1
- 240 -

- 26 -- 260 -

- 27 -- 270 - 28 -- 280 -



1<--------1
I
------ 0

1

------1

1

1

1- 1 -I
1

I

1- 2 -I
1

1

1- 3 -I


------1
I
30 --I

3

I
11

I

1- 36 --I

1- 36C -I


1<------------------1
I
I
--------I

33

Language Components

0 ----I

I

I

1- 1 -I
I

I

1- 2 -I
I

I

1- 3 -\
I
I
1- 4 -I
I

I

1\

5

-I
I

I- e -I
1
I
1- 7 -I


4 ------1
I
\- 40 --I
I
I
1- 47 --I
I
I
1- 470 -I
1
I
\- 48 --I
I
I
1- 480 -I
I



1<------------------------1
I
--------I

34

ALGOL REFERENCE MANUAL


o ----I
1

1

1- 1 -I
1

1

1- 2 -I
/

1

1- 3 -I
1
-

1

4 -

- 5 - 6 - 7 -

- 8 -

9 -

- A - B -

C -

-

D -

- E - F -


-------------------- " ---- " ----I
I
I--/
1
/
I
1-------------- " ---- " -------1
I
I
I
I--/
I
I
I
I--- " ---- " ----I

35

Language Components

8

1

-----1
1

1- 80 -I


1<-----------------------------------------------1
1

1

------------ any  except quotation mark ------1
1

1

1

1- " -I

I

1

1

1- " ------------------------------------------------------1

Anyone of the 256 possible EBCDIC characters.

6

-----1

1

1

1- 60 -I

----I

7 -----1
1

1

1- 70 -I


1<----------------------------------------------1
1

1

------------ any  except quotation mark ------1
1

1

1

1- " -I

1

1

1

1- " -----------------------------------------------------1

36

ALGOL REFERENCE MANUAL

Anyone of the 128 possible ASCII characters.

Semantics
Character Size
Strings can be composed of binary (I-bit) characters, quaternary (2-bit)
characters, octal (3-bit) characters, hexadecimal (4-bit) characters,
BCL (6-bit) characters, ASCII (7-bit in 8-bit format) characters, or
EBCDIC (8-bit) characters. The word formats of various character types
are described under "Character Representation" in the appendix "Data
Representation."

See also
Character Representation . . . . . . . . . . . . . . . . . . . . 808

String Code
The string code determines the interpretation of the characters between
the quotation marks (") of a string literal. The string code specifies
the character set and,
for strings of less than 48 bits,
the
justification.
The first digit of the string code specifies the
character set in which the source string is written. The next nonzero
digit (if any) specifies the internal character size of the string to be
created by the compiler.
If no nonzero digit is specified, the internal
size is the same as the source size.
If the internal size is different
from the source size. the length of the string must be an integral
number
of internal characters.
For example, the string literal
48"CIC2C3C4" is an EBCDIC string expressed in terms of hexadecimal
characters.

If the string literal contains fewer than 48 bits. a trailing zero in
the
string
code
specifies
that the string literal is to be
left-justified within the word and that trailing zeros are to fill out
the remainder of the word.

If the string literal contains fewer than 48 bits,
the absence of a
trailing zero in the string code specifies that the string literal is to
be right-justified within the word and that leading zeros are to fill
out the remainder of the word.

37
Language components
If the string literal contains 48 or more bits, the presence or
of a trailing zero in the string code has no effect.

absence

If the string code is not specified, the source string and the internal
representation of the string are of the default character type. For
more information, refer to "Default Character Type" in the appendix
"Data Representation."
See also
Default Character Type . . . . . . . . . . . . . . . . . . . . . 817
String Length

maximum length permitted for a simple string literal is 256
characters; the maximum length permitted for a string literal is 4095
characters. However, when a string literal is used as an arithmetic
primary, it must not €'xceed 48 bits in length.

~rhe

Internally. a string literal of 48 bits or less is represented in the
object code as an 8-bit, 16-bit, or 48-bit literal. A string literal
more than 48 bits long is stored in a "pool array" created by the
compiler. An internal pointer carries the character size and address of
the string within the pool array.
BeL Strings

BCL strings can contain any EBCDIC character.
However. any EBCDIC
character that does not have a BCL equivalent is translated by the
compiler into a BCL question mark (36"14").
NOTE
The BCL data type is not supported on all
A Series and B 5000/B bOOOiB 7000 Series
systems.
The appearance
of
a
BCL
construct that may cause the creation of
a BCL descriptor, sUCh as a BCL string
literal more than 96 bits long, will
cause the program to get a compi~e-time
warning message.

38

ALGOL REFERENCE MANUAL
ASCI I Str'lngs

The ASCII string code can be used only with ASCII strings composed
entirely of characters that have corresponding EBCDIC graphics. This is
because the compiler recognizes only ASCII characters that
have
corresponding EBCDIC graphics.
The compiler translates each ASCII character into an 8-bit character.
The rightmost seven bits are the ASCII representation of that character;
the leftmost bit is o.
ASCII characters that are not in the EBCDIC character set must be
written as a hexadecimal string in which each pair of hexadecimal
characters represents the internal code of one ASCII
character,
right-justified with a leading 0 bit.
Quotation Mark

The quotation mark (") can appear only as the first character of a
simple string literal.
Strings with internal quotation marks must be
broken into separate simple strings by using three quotation marks in
succession.
For example, the string literal ""ABC" represents the
string "ABC, and the string literal "A"""BC" represents the string A"BC.
Dollar Sign

String literals can contain the dollar sign ($). The dollar sign must
not be the first nonblank character on a source record. If a dollar
sign is the first nonblank character on a source record, the compiler
interprets the source record as a compiler control record.

39

.4

DECLARATIONS

A declaration associateS's certain characteristics and structures wi th an
identifier.
In an ALGOL program, every identifier must be declared
before it is used. The compiler ensures that subsequent usage of an
identifier in a program is consistent with its declaration.
Syntax


Each of the following metatokens represents a valid ALGOL declaration.
Source Exif Data: 
File Type                       : PDF
File Type Extension             : pdf
MIME Type                       : application/pdf
PDF Version                     : 1.3
Linearized                      : No
XMP Toolkit                     : Adobe XMP Core 4.2.1-c043 52.372728, 2009/01/18-15:56:37
Create Date                     : 2003:03:05 15:10:23Z
Creator Tool                    : g4pdf
Modify Date                     : 2014:11:18 13:37:29-08:00
Metadata Date                   : 2014:11:18 13:37:29-08:00
Producer                        : Adobe Acrobat 9.55 Paper Capture Plug-in
Format                          : application/pdf
Document ID                     : uuid:abec5138-f9ff-aa45-bf11-cb1f331dcaee
Instance ID                     : uuid:82b17233-e6d0-7a47-bfa3-1e06d40eb1cd
Page Layout                     : SinglePage
Page Mode                       : UseOutlines
Page Count                      : 480
Creator                         : g4pdf
EXIF Metadata provided by EXIF.tools

Navigation menu