ISO 1538:1984

538
International Standard @I
~
~~~
INTERNATIONAL ORGANIZATION FOR STANDAROIZATIONOMEWYHAPOAHAfl OPrAHHJAUHfl no CTAHAAF’TH3AUHM«)RGANlSATlON INTERNATIONALE DE NORMALISATION
Programming languages - ALGOL 60
L
Langages de programmation ALGOL 60
First edition - 1984-10-15
UDC 681.3.06 : 800.92 Ref. No. IS0 1538-1984 (E)
~i 1
ob
Descriptors : programming languages, algol, specifications.
Price based on 18 pages

---------------------- Page: 1 ----------------------
Foreword
IS0 (the International Organization for Standardization) is a worldwide federation of
(IS0 member bodies). The work of preparing International
national standards bodies
Standards is normally carried out through IS0 technical committees. Every member
body interested in a subject for which a technical committee has been established has
the right to be represented on that committee. International organizations, govern-
mental and non-governmental, in liaison with ISO, also take part in the work.
Draft International Standards adopted by the technical committees are circulated to
the member bodies for approval before their acceptance as International Standards by
IS0 Council. They are approved in accordance with IS0 procedures requiring at
the
least 75 % approval by the member bodies voting.
International Standard IS0 1538 was prepared by Technical Committee ISO/TC 97, ln-
formation processing systems.
This International Standard replaces ISO/R 1538 (withdrawn in 1977) of which it con-
stitutes a revision.
IS0 Recommendation 1538 was a compilation of several source documents. The basic
one [developed under the auspices of the International Federation for Information Pro-
cessing (IFIP), whose contributions are acknowledged1 was the Revised Report on the
Algorithmic Language ALGOL 60.
The text presented in this International Standard is based on the Modified Report on
the Algorithmic Language ALGOL 60, which is a minor technical revision and a textual
clarification of the Revised Report, as established by IFIP. For reasons of IS0 editorial
policy the original introduction which is irrelevant to an International Standard has
been deleted and some introductory clauses have been added instead.
O International Organization for Standardization, 1984
Printed in Switzerland

---------------------- Page: 2 ----------------------
INTERNATIONAL STANDARD IS0 1538-1984 (E)
Programming Languages - ALGOL 60
requirements and rules for executing programs on an
O Introduction d)
actual data processing system.
In this International Standard consistent use is made of
ALGOL60 as the name of the language, rather than just
kc
ALGOL, in order to avoid confusion with ALGOL 68 which is a
2 Reference
completely different language. It is recommended that the
language defined in this International Standard be referred to
ISOiTR 1672, Hardware representation of ALGOL basic sym-
as STANDARD ALGOL 60.
bols in the IS0 7-bit coded character set for information pro-
cessing interchange.
Whenever the name ALGOL is used in this International Stan-
dard it is to mean ALGOL 60, not ALGOL 68, unless it is clear
from the context that no specific language is indicated.
3 Definitions
For the purpose of this International Standard the following
definitions apply:
1 Scope and field of application
3.1 valid program: A text written in the ALGOL 60
This International Standard defines the algorithmic program-
language that conforms to the rules for a program defined in
ming language ALGOL 60. Its purpose is to facilitate inter-
this International Standard.
change and promote portability of ALGOL 60 programs be-
tween data processing systems.
3.2 non-valid program: A text that does not conform, but
was intended to be a program.
60 is intended for expressing a large class of numerical
ALGOL
processes in a form sufficiently concise for direct automatic
i-
translation into the language of programmed automatic com-
3.3 processor: A compiler, translator or interpreter, in com-
puters.
bination with a data processing system, that accepts an in-
tended program, transcribed in a form that can be processed by
This International Standard specifies:
that data processing system, reports whether the intended pro-
if valid executes it, if that is being
gram is valid or not, and
requested.
the syntax and semantics of ALGOL 60;
a)
b) characteristics of programs written in ALGOL 60, and
3.4 implementation : A processor, accompanied with docu-
of implementations of that language, required for confor-
ments that describe
mance to this International Standard.
its purpose, and the environment (hardware and soft-
a)
This International Standard does not specify:
ware) in which it will work;
results of processes or other issues, that are, explicitly,
a) b) its intended properties, including
left undefined or said to be undefined;
- the particular hardware representation of the
language, as chosen;
b) questions of hardware representation (these may be the
subject of another International Standard), or of implemen-
-
the actions taken, when results or issues occur that
tation;
are undefined in this International Standard;
the way non-valid programs are to be rejected, and how - conventions for issues said to be a question of
c)
this will be reported; implementation ;
1

---------------------- Page: 3 ----------------------
IS0 1538-1984 (E)
4.3 Extensions
c) with regard to the implemented language, all dif-
ferences from, restrictions to, or extensions to the language
defined in this International Standard; An implementation that allows for extensions in the im-
plemented language is considered to conform to this Interna-
tional Standard, notwithstanding 4.1, if
d) its logical structure;
it would conform when the extensions were omitted;
the way to put it into use. a)
e)
the extensions are clearly described with the implemen-
b)
3.5 conforming implementation : An implementation con-
tation ;
forming to this International Standard by accepting valid pro-
grams as being valid, by rejecting non-valid programs as being
c) while accepting programs that are non-valid according
non-valid and by executing valid programs in accordance with
to the rules given in clause 6 of this International Standard,
the given rules.
it provides means for indicating which part, or parts, of a
program would have led to its rejection, had no extension
been allowed.
implemented language: The version of the language
3.6
as defined by the implementation.
Valid programs using extensions shall be described as "con-
forming to IS0 1538 but for the following indicated parts".
3.7 conforming language version: A version of the
language, defined by a conforming implementation that
4.4 Subsets
does not contain any rule conflicting with those defined
a)
Conformance to a subset specified in this International Stan-
in this International Standard;
dard means conformance to the subset rules as if they were the
only rules in the language.
b) does not contain any rule not provided for in this Inter-
national Standard, except such rules as, either said to be in-
tentionally and explicitly a question of implementation, or
5 Tests
otherwise being outside the scope of this International
Standard.
Whether an implementation is a conforming implementation or
the implemented language is a conforming language version
extension : A rule in the implemented language that
3.8
may be decided by a sequence of test programs. If there is any
uncertainty or doubt regarding acceptance of these programs
is not given in this International Standard;
a)
then the conclusions drawn from the actual behaviour of the
processor will prevail over those derived from its accompanying
b) does not cause any ambiguity when added to this Inter- documents.
national Standard (but may serve to remove a restriction);
c) is within the scoDe of this International Standard.
6 Description of the reference language
-d
The detailed description of the reference language given herein
reproduces, without modification, the text taken from the
4 Conformance
Modified Report (see the foreword), the contents of which are
the following :
4.1 Requirements
1 Structure of the language
Conformance to this International Standard requires
1.1 Formalism for syntactic description
a) for a program, that it shall be a valid program;
2 Basic symbols, identifiers, numbers, and strings. Basic
concepts
for an implementation, that it shall be a conforming im-
b)
plementation ; 2.1 Letters
2.2 Digits and logical values
c) for the implemented language, that it shall be a con-
forming language version. 2.3 Delimiters
2.4 Identifiers
4.2 Quantitative restrictions
2.5 Numbers
2.6 Strings
The requirements specified in 4.1 shall allow for quantitative
restrictions to rules stated or implied as having no such restric-
2.7 Quantities, kinds and scopes
tion in this International Standard, but only if they are fully
2.8 Values and types
described in the documents with the implementation.
2

---------------------- Page: 4 ----------------------
IS0 1538-1984 (E)
3 Expressions
I. Structure of the language
The algorithmic language has two different kinds of representation-
3.1 Variables
reference and hardwars-and the development described in the
3.2 Function designators
sequel is in terms of the reference representation. This means that all
objects defined within the language are represented by a given set of
3.3 Arithmetic expressions
symbols-and it is only in the choice of symbols that other repre-
3.4 Boolean expressions
sentations may differ. Structure and content must be the same for all
representations.
3.5 Designational expressions
Reference language
4 Statements
1. It is the defining language.
4.1 Compound statements and blocks
2. The characters are determined by ease of mutual understanding
and not by any computer limitations, coder's notation, or pure
4.2 Assignment statements
mathematical notation.
4.3 GO to statements
3. It is the basic reference and guide for compiler builders.
4. It is the guide for all hardware representations.
4.4 Dummy statements
4.5 Conditional statements
Hardwure represenfntions
Each one of these:
4.6 For statements
1. is a condensation of the reference language enforced by the
4.7 Procedure statements limited number of characters on standard input equipment;
2. uses the character set of a particular computer and is the language
L
accepted by a translator for that computer;
5 Declarations
3. must be accompanied by a special set of rules for transliterating to
5.1 Type declarations
or from reference language.
It should be particularly noted that throughout the reference
5.2 Array declarations
language underlining in typescript or manuscript, or boldface type in
5.3 Switch declarations
printed copy, is used to represent certain basic symbo!s (see Sections
2.2.2 and 2.3). These are understood to have no relation to the
5.4 Procedure declarations
individual letters of which they are composed. In the reference
language underlining or boldface is used for no other purpose.
Appendix 1 - Subsets
The purpose of the algorithmic language is to describe compu-
Appendix 2 - The environmental block
tational processes. The basic concept used for the description of
calculating rules is the well-known arithmetic expression containing
Bibliography
as constituents numbers, variables, and functions. From such
expressions are compounded, by applying rules of arithmetic
Alphabetic index of definitions of concepts and syntactic units composition, self-contained units of the language-explicit formulae
-called assignment statements.
To show the flow of computational processes, certain non-arith-
metic statements and statement clauses are added which may
describe, e.g. alternatives, or iterative repetitions of computing
statements. Since it is sometimes necessary for the function of these
statements that one statement refers to another, statements may be
A sequence of statements may be enclosed
provided with labels.
between the statement brackets begin and end to form a compound
statement.
Statements are supported by declarations which are not themselves
computing instructions, but inform the translator of the existence
and certain properties of objects appearing in statements, such as the
class of numbers taken on as values by a variable, the dimension of
an array of numbers, or even the set of rules defining a function. A
sequence of declarations followed by a sequence of statements and
enclosed between begin and end constitutes a block. Every decla-
ration appears in a block in this way and is valid only for that block.
A program is a block or a compound statement that is contained
only within a fictitious block (always assumed to be present and
called the environmental block), and that makes no use of statements
or declarations not contained within itself, except that it may invoke
such procedure identifiers and function designators as may be
assumed to be declared in the environmental block.
The environmental block contains . procedure declarations of
standard functions, input and output operations, and possibly other
3

---------------------- Page: 5 ----------------------
IS0 1538-1984 (E)
operations to be made u:.ailable without declaration within the The logical values have a fixed obvious meaning.
program. It also contains the fictitious declaration, and initialisation,
of own variables (see Section 5).
2.3. Delimiters
In the sequel the syntax and semantics of the language will be
(delimiter) : : = (operator) I( separator) ((bracket)l( declarator) 1
given.
(specificator)
Whenever the precision of arithmetic is stated as being in general
(operator) : : = (arithmetic operator)l(reiationai operator)/
not specified, or the outcome of a certain process is left undefined or
(logical operator)((sequentiai operator)
said to be undefined, this is to be interpreted in the sense that a
(arithmetic operator) : : = + I - 1 x 1/1+ It
program only fully defines a computational process if the accom-
(relational operator) : : = < I < 1 = I > I > I #
panying information specifies the precision assumed, the kind of
(logical operator) : : = = I
I I\ 1 v 1-1
arithmetic assumed, and the course of action to be taken in all such
(sequential operator) :: = go toliflthenlelselforldo
cases as may occur during the execution of the computation.
(separator) ::= ,I.\IO~:\;~: = Istep)untillwhilelcomment
(bracket) :: = (l)\[I]IrI’lùeginlend
1.1. Formalism for syntactic description
(declarator) : : = ownlBooleanlinteger /reallarrayIswitchIprocedure
The syntax will be described with the aid of metalinguistic formulae
(specificator) : : = stringliabeilvniue
1959). Their interpretation is best explained by an example:
(Backus,
Delimiters have a fixed meaning which for the most part is obvious
or else will be given at the appropriate place in the sequel.
Typographical features such as blank space or change to a new line
Sequences of characters enclosed in the brackets (> represent
have no significance in the referencekmguage. They may, however,
metalinguistic variables whose values are sequences of symbols. The
be used freely for facilitating reading.
marks :: = and 1 (the latter with the meaning of ‘or’) are metalin-
For the purpose of including text among the symbols of a program
guistic connectives. Any mark in a formula, which is not a variable
the following ‘comment’ conventions hold:
or a connective, denotes itself (or the class of marks which are
The sequence is equivalent to
similar to it). Juxtaposition of marks and/or variables in a formula
;comment (any sequence of zero or more
signifies juxtaposition of the sequences denoted. Thus the formula
characters not containing ;); ?
above gives a recursive rule for the formation of values of the vari-
begin comment (any sequence of zero
able (ab). It indicates that (ab) may have the value ( or [ or that
or more characters not containing ;);
begin-
given some legitimate value of (ab), another may be formed by
end (any sequence of zero or more basic
following it with the character ( or by following it with some value
symbols not containing end or else or ;) end
of the variable (d). If the values of (d) are the decimal digits, some
By equivalence is here meant that any of the three structures shown
values of (ab) are:
in the left hand column may be replaced, in any occurrence outside of
[(((1(37(
strings, by the symbol shown on the same line in the right hand
(12345(
column without any effect on the action of the program. It is further
(((
understood that the comment structure encountered first in the text
186
when reading from left to right has precedence in being replaced
In order to facilitate the study, the symbols used for distinguishing
over later structures contained in the sequence.
the metalinguistic variables (i.e. the sequences of characters appear-
ing within the brackets () as ab in the above example) have been
2.4. Identifers
chosen to be words describing approximately the nature of the
2.4.1. Syntax
corresponding variable. Where words which have appeared in this
(identifier) : : = (letter) I( identifier)(letter) I( identifier)( digit)
manner are used elsewhere in the text they will refer to the corres-
ponding syntactic definition. In addition some formulae have been
given in more than one place. 2.4.2. Examples
4
Definition:
soup
(empty) : : =
VI 7a
(i.e. the null string of symbols).
a34kTMNs
MA RIL YN
2. Basic symbols, identifiers, numbers, and strings. Basic concepts
-/
The reference language is built up from the following basic symbols:
2.4.3. Semantics
(basic symbol) : : = (letter)l(digit)l(logical value)l(delimiter)
Identifiers have no inherent meaning, but serve for the identification
of simple variables, arrays, labels, switches, and procedures. They
2.1. Letters
may be chosen freely. Identifiers also act as formai parameters of
(letter) :: = ajb(cld(elflglh(i)jlklllmln/olp)qlrls(tlulv~~~x~~~z
procedures, in which capacity they may represent any of the above
I~I~I~l~I~I~I~I~I~lJl~lLlMlNfolPl QlRlslTl UI VI WI
entities, or a string.
XI YIZ
The same identifier cannot be used to denote two different
quantities except when these quantities have disjoint scopes as
This alphabet may arbitrarily be restricted, or extended with any
2.7 Quantities,
defined by the declarations of the program (see Section
other distinctive character (i.e. character not coinciding with any
or delimiter). kinds and scopes and Section 5 Declarations). This rule applies also
digit, logical value
to the formal parameters of procedures, whether representing a
Letters do not have individual meaning. Ttey are used for forming
quantity or a string.
identifiers and strings (see Sections 2.4 Identifiers, 2.6 Strings).
Within this report the letters (from an extended alphabet) r, 8,
and fi are sometimes used and are understood as not being available
2.5. Numbers
to the programmer. If an extended alphabet is in use, that does
2.5.1. Syntax
include any of these letters, then their uses within this report must be
(unsigned integer) : : = (digit)l(unsigned integer)(digit)
systematically changed to other letters that the extended alphabet
(integer) : : = (unsigned integer)) +(unsigned integer)
does not include.
1 -(unsigned integer)
(decimal fraction) : : = .(unsigned integer)
2.2. Digits and logical values :: = io(integer)
2.2.1. Digits (decimal number) : : = (unsigned integer)((decimal fraction)
1 (unsigned integer)( decimal fraction)
(digit) :: = 011/2)3(415(6/7(819
Digits are used for forming numbers, identifiers, and strings. (unsigned number) : : = (decimal number)l(exponent part)
\(decimal number)( exponent part)
2.2.2. Logical values (number) : : = (unsigned number) I + (unsigned number)
4

---------------------- Page: 6 ----------------------
IS0 1538-1984 (E)
expressions. Constituents of these expressions, except for certain
2.5.2. Examples
O - 200.084 delimiters, are logical values, numbers, variables, function desig-
- .O8310 - 02
nators, labels, switch designators, and elementary arithmetic,
177 + 07.43108 - io7
relational, logical, and sequential operators. Since the syntactic
,5384 9.34io-t 10 10-4
definition of both variables and function designators contains
+ 0.7300 210-4 -tiof5
expressions, the definition of expressions, and their constituents, is
necessarily recursive.
2.5.3. Semantics
(expression) : : = (arithmetic expression)l(Boolean expression)
Decimal numbers have their conventional meaning. The exponent
j(designationa1 expression)
part is a scale factor expressed as an integral power of 10.
3.1. Variables
2.5.4. Types
3.1.1. Syntax
Integers are of integer type. All other numbers are of real type (see
(variable identifier) : : = (identifier)
Section 5.1 Type declarations).
(simple variable) : : = (variable identifier)
2.6. Strings (subscript expression) : : = (arithmetic expression)
2.6.1. Syntax (subscript list) : : = (subscript expression)j(subscript list),
(subscript expression)
(proper string) : : = (any sequence of characters not containing
(array identifier) : : = (identifier)
‘ or ’>I(empty>
: : = (proper string) (subscripted variable) : : = (array identifier>[ (subscript list)]
(open string)
(variable) : : = (simple variable)l(subscripted variable)
j(proper string)(closed string)(open string)
(closed string) :: = ‘(open string)’
(string) : : = (closed string)l(closed string)(string)
3.1.2. Examples
epsilon
2.6.2. Examples detA
‘5k,, - ‘[[[‘A =/:’Tt’’ a17
‘ . . This-is-a- ‘string’’
L. ‘This-isliall’
‘-oneustring’
3.1.3. Semantics
2.6.3. Semantics A variable is a designation given to a single value. This value may be
In order to enable the language to handle sequences of characters used in expressions for forming other values and may be changed at
the string quotes ‘ and ’ are introduced. will by means of assignment statements (see Section 4.2). The type
The characters available within a string are a question of hardware of the value of a particular variable is defined in the declaration for
representation, and further rules are not given in the reference the variable itself (see Section 5.1 Type declarations) or for the
language. However, it is recommended that visible characters, other corresponding array identifier (see Section 5.2 Array declarations).
than U and ”, should represent themselves, while invisible characters
other than space should not occur within a string. To conform with 3.1.4. Subscripts
3.1.4.1. Subscripted variables designate values which are com-
ISO/TR 1672, a space may stand for itself, although in this
ponents of multidimensional arrays (see Section 5.2 Array Uecla-
document the character U is used to represent a space.
rations). Each arithmetic expression of the subscript list occupies
To allow invisible, or other exceptional characters to be used, they
are represented within either matching string quotes or a matched one subscript position of the subscripted variable and is called a
of the “ symbol. The rules within such an inner string are subscript. The complete list of subscripts is enclosed in the subscript
pair
unspecified, so if such an escape mechanism is used a comment is brackets [ 1. The array component referred to by a subscripted
necessary to explain the meaning of the escape sequence. variable is specified by the actual numerical value of its subscripts
A string of the form (closed string)(string) behaves as if it were (see Section 3.3 Arithmetic expressions).
the string formed by deleting the closing string quote of the closed
string and the opening string quote of the following string (together 3.1.4.2. Each subscript position acts like a variable of integer type
with any layout characters between them). and the evaluation of the subscript is understood to be equivalent to
ings are used as actual parameters of procedures (see Sections an assignment to this fictitious variable (see Section 4.2.4). The value
3’2- Function designators and 4.7 Procedure statements). of the subscripted variable is defined only if the value of the subscript
expression is within the subscript bounds of the array (see Section
2.7. Quantities, kinds and scopes 5.2 Array declarations).
The following kinds of quantities are distinguished : simple variables,
3.1.5. Initial values of variables
arrays, labels, switches, and procedures.
The scope of a quantity is the set of statements and expressions in The value of a variable, not declared own, is undefined from entry
which the declaration of the identifier associated with that quantity into the block in which it is declared until an assignment is made to
is valid. For labels see Section 4.1.3. it. The value of a variable declared own is zero (if arithmetic) or false
(if Boolean) on first entry to the block in which it is declared. On
2.8. Values and types subsequent entries it has the same value as at the preceding exit from
A value is an ordered set of numbers (special case: a single number), the block.
an ordered set of logical vàlues (special case: a single logical value),
3.2. Function designators
or a label.
Certain of the syntactic units are said to possess values. These 3.2.1. Syntax
values will in general change during the execution of the program. (procedure identifier) :: = (identifier)
: : = (string)j(expression)
The values of expressions and their constituents are defined in (actual parameter)
1 (array identifier)]( switch identifier)
Section 3. The value of an array identifier is the ordered set of values
of the corresponding array of subscripted variables (see Section 1 (procedure identifier)
3.1.4. I). (letter string) : : = (letter)l(letter string)(letter)
The various types (integer, real, Boolean) basically denote pro- (parameter delimiter) : : = ,I)(letter string):(
perties of values. The types associated with syntactic units refer to (actual parameter list) : : = (actual parameter)
the values of these units. I(actua1 parameter list)
(parameter delimiter)(actual parameter)
3. Expressions (actual parameter part) : : = (empty)l((actuai parameter list))
In the language the primary constituents of the programs describing (function designator) : : = (procedure identifier)
(actual parameter part)
algorithmic processes are arithmetic, Boolean, and designational

---------------------- Page: 7 ----------------------
IS0 1538-1984 (E)
3.2.2. Examples
In the case ofsimple arithmetic expressions this value is obtained by
sin(a - 6)
executing the indicated arithmetic operations on the actual numerical
J(v + s, n)
values of the primaries of the expression, as explained in detail in
R
Section 3.3.4 below. The actual numerical value of a primary is
S(s - S)Temperature:(T)Pressure:(P)
obvious in the case of numbers. For variables it is the current value
Compile ( : = ’)Stack :( Q)
(assigned last in the dynamic senst), and for function designators it
is the value arising from the computing rules defining the procedure
(see Section 5.4.4 Values of function designators) when applied to
3.2.3. Semantics
the current values of the procedure parameters given in the expres-
Function designators define single numerical or logical values which
sion. Finally, for arithmetic expressions enclosed in parentheses the
result through the application of given sets of rules defined by a
value must through a recursive analysis be expressed in terms of the
procedure deçlaration (see Section 5.4 Procedure declarations) to
values of primaries of the other three kinds.
fixed sets of actual parameters. The rules governing specification of
4.7 Procedure statements. In the more general arithmetic expressions, which include if clauses,
actual parameters are given in Section
one out of several simple arithmetic expressions is selected on the
Not every procedure declaration defines rules for determining the
value of a function designator. basis of the actual values of the Boolean expressions (see Section
3.4 Boolean expressions). This selection is made as follows: The
Boolean expressions of the if clauses are evaluated one by one in
3.2.4. Standard functions and procedures
sequence from left to right until one having the value true is found.
Certain standard functions and procedures are declared in the
The value of the arithmetic expression is then the value of the first
environmental block with the foilowing procedure identifiers :
arithmetic expression following this Boolean (the longest arithmetic
abs, iabs, sign, entier, sqrt, sin, cos, arctan, In, exp, inchar, outchar,
If none of the
expression found in this position is understood).
length, outstrirrg, outterminator, stop, fault, ininteger, outinteger,
Boolean expressions has the value true, then the value of the
inreal, oirtreal, maxreal, minreal, maxint and epsilon.
arithmetic expression is the value of the expression following the
For details of these functions and procedures, see the specification
final else.
of the environmental block given as Appendix 2.
The order of evaluation of primaries within an expression is not
defined. If different orders of evaluation would produce differe-
3.3. Arithmetic expressions
results, due to the action of side effects of function designators, th-,
3.3.1. Syntax
the program is undefined.
(adding operator) : : = + I -
In evaluating an arithmetic expression, it is understood that ail the
(multiplying operator) : : = x I/\
primaries within that expression are evaluated, except those within
(primary) : : = (unsigned number)((variable)
a
...