Beruflich Dokumente
Kultur Dokumente
18
Jensen, Kathleen, 1949PASCAL: user manual and report. (Lecture notes in computer science, v. 18) Bibliography: p. 1. PASCAL (Computer program language). I. Wirth, Niklaus, joint author. II. Title. IIIo Series. QA76.73 .P35J46 001.6'424 74-16327
AMS Subject Classifications (1970): 68-02, 68 A 0 5 CR Subject Classifications (1974): 4.2, 4.22
ISBN 3-540-06950-X Springer-Verlag Berlin Heidelberg New York ISBN 0-387-06950-X Springer-Verlag New York Heidelberg Berlin This work is subject to copyright. All rights are reserved, whether the whole or part of the material is concerned, specifically those of translation, reprinting, re-use of illustrations, broadcasting, reproduction by photocopying machine or similar means, and storage in data banks. Under 54 of the German Copyright Law where copies are made for other than private use, a fee is payable to the publisher, the amount of the fee to be determined by agreement with the publisher. by Springer-Verlag Berlin Heidelberg 1974. Printed in Germany.
PREFACE
This manual is directed t o t h o s e who h a v e p r e v i o u s l y acquired some programming s k i l l . The i n t e n t i o n is to p r o v i d e a m e a n s of learning Pascal without outside guidance. It is based on The ~rparammino Lanauaae Eascal (~evised ~eaort) Ill--the basic definition of Pascal and concise reference manual for t h e experienced Pascal programmer.
The linear structure of a book is by no means ideal for introducing a language, whether it be a formal or natural one. Nevertheless, it is recommended to follow the given organization, paying particular attention to the example programs, and then t o reread those sections causing dlfficultes. O n e m a y w i s h , h o w e v e r , t o r e f e r e n c e c h a p t e r 12 if t r o u b l e s a r i s e concerning the input and output conventions of the programs.
The manual was prepared as e file on a c o m p u t e r , that is . as a sequence of characters of a single type font. This is very convenient for the p u r p o s e s of u p d a t i n g : u n f o r t u n a t e l Y ~ it is sometimes a bit awkward to read. T h e r e a d e r is a s k e d to be indulgent with the absence of s u b - and s u p e r s c r i p t s (e.g. m r a i s e d t o t h e p o w e r n is d e n o t e d by m * * n ) . Chapters 0--12 define the language Pascal and serve a sa standard for both the implementor and the programmer. The implementer must regard the task of recognizing Standard Pascal as the minmum requirement of his system, while the programmer who intends his programs to be transferable from one installation to another s h o u l d u s e o n l y f e a t u r e s d e s c r i b e d as Standard P a s c a l . On the o t h e r h a n d , any i m p l e m e n t a t i o n may (and u s u a l l y d o e s ) go b e y o n d t h e m i n i m u m . C h a p t e r s 13 a n d 14 d o c u m e n t t h e i m p l e m e n t a t i o n of P a s c a l on t h e CDC 6 0 0 0 m a c h i n e . C h a p t e r 13 describes the a d d i t i o n a l f e a t u r e s of t h e l a n g u a g e P A S C A L 6 0 0 0 , w h e r e a s c h a p t e r 14 is d e v o t e d to t h e u s e of t h e c o m p i l e r and t h e system under the operating system SCOPE.
The efforts o f m a n y go i n t o this manual, e n d we e s p e c i a l l y thank the members of the Institut fuer Informatik, ETH Z u r i c h . end John Larmouth, Rudy Schild, Olivier Lecerme, and Pierre Desjardins for their criticism, suggestions, and encouragement. Our implementation of Pascsl--which made this manual both possible and necessary--is the work of Urs A m m a n n , a i d e d by Helmut Sandmayr. Kathleen densen Niklaus Wirth ETH Zurich Switzerland
June
1974
Table
of Contents
I. N o t a t i o n 2. T h e A. B. C. D. 3. T h e A. B. C. D. E. F.
Program Heading and the Declaration Part . . . . . . . . The program heading . . . . . . . . . . . . . . . . . . . The label declaration part . . . . . . . . . . . . . . . . The constant definition part . . . . . . . . . . . . . . . The type definition part . . . . . . . . . . . . . . . . . The variable declaration part . . . . . . . . . . . . . . The procedure and function declaration part . . . . . . .
4. T h e C o n c e p t of A c t i o n . . . . . . . . . . . . . . . . . . . . . A. T h e a s s i g n m e n t statement . . . . . . . . . . . . . . . . . B. T h e c o m p o u n d s t a t e m e n t . . . . . . . . . . . . . . . . . . . C. R e p e t i t i v e statements . . . . . . . . . . . . . . . . . . C.I T h e w h i l e s t a t e m e n t . . . . . . . . . . . . . . . . . C.2 The repeat statement . . . . . . . . . . . . . . . . . C.3 The for statement . . . . . . . . . . . . . . . . . . D. C o n d i t i o n a l statements . . . . . . . . . . . . . . . . . . D.I T h e if s t a t e m e n t . . . . . . . . . . . . . . . . . . . D.2 The case statement . . . . . . . . . . . . . . . . . . E. T h e g o t o s t a t e m e n t . . . . . . . . . . . . . . . . . . . . 5. S c a l a r a n d S u b r a n g e T y p e s . . . . . . . . . . . . . . . . . . A. S c a l a r t y p e s . . . . . . . . . . . . . . . . . . . . . . . B. S u b r a n g e t y p e s . . . . . . . . . . . . . . . . . . . . . . 6. Structured Types in G e n e r a l -- T h e Array in Particular .
7. R e c o r d A. T h e 8. Set
Types . . . . . . . . . . . . . . . . . . . . . . . . . .
Procedures and A. P r o c e d u r e s . B. F u n c t i o n s . C. R e m a r k s . .
12.
. . . . . . . . . . . . . . . . . . . . . . read . . . . . . . . . . . . . . . . . . . . write . . . . . . . . . . . . . . . . . . .
13.
VI
A.2 External procedures . . . . . . . . . . . . . . . . . Specifications left undefined in the preceding chapters B.I T h e p r o g r a m h e a d i n g a n d e x t e r n a l f i l e s . . . . . . . . B.2 Representation of files . . . . . . . . . . . . . . . B.3 The standard types . . . . . . . . . . . . . . . . . . B.4 The standard procedure write . . . . . . . . . . . . . C. R e s t r i c t i o n s . . . . . . . . . . . . . . . . . . . . . . . D. A d d i t i o n a l predefined types, procedures, and functions. D.I A d d i t i o n a l predefined types . . . . . . . . . . . . . D.2 Additional predefined procedures and functions.. B. 14. How to Use the PASCAL 6000-3.4 System . . . . . A. C o n t r o l s t a t e m e n t s . . . . . . . . . . . . . . B. C o m p i l e r o p t i o n s . . . . . . . . . . . . . . . C. E r r o r m e s s a g e s . . . . . . . . . . . . . . . . C.I C o m p i l e r . . . . . . . . . . . . . . . . . C.2 Run-time . . . . . . . . . . . . . . . . . References Appendix Appendix Appendix Appendix Appendix Appendix A B C D E F . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9O 91 91 92 93 96 97 97 97 98 I00 100 100 I O2 102 I02 I04 I05 I O8 I09 110 119 122 126
. . . . . . . . . . . . . .. . . . . . . Standard Procedures S u m m a r y of O p e r a t o r s Tables . . . . . . . . Syntax . . . . . . . . Error Number Summary Programming Examples and . . . . . . . . . . Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . .
Index . . . . . . . . . . . . . . . . . . . . . . . . . . . .
by N. Wirth
Preface to the Revised Report . . . . . . . . . . . . . . . . . 133 136 137 140 140 141 142 142 143 145 146 147 147 148 148 149 151 151 152 153 158 160 162 163
1. I n t r o d u c t i o n 2. Summary
of the
3. N o t a t i o n , 4. 5.
terminology, Numbers
Identifiers, Constant
Strings
definitions
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Expressions . . . . . . . . . . . . . . . . . . . . . . . . . 8.1. O p e r a t o r s . . . . . . . . . . . . . . . . . . . . . . . 8.2. F u n c t i o n d e s i g n a t o r s . . . . . . . . . . . . . . . . . . Statements . . . . . . . . . . . . . . . . . . . . . . . . . 9.1. S i m p l e s t a t e m e n t s . . . . . . . . . . . . . . . . . . . 9.2. S t r u c t u r e d s t a t e m e n t s . . . . . . . . . . . . . . . . . Procedure declarations . . . . . . . . . . . . . . . . . . . . 10.1.Standard procedures . . . . . . . . . . . . . . . . . . Function declarations . . . . . . . . . . . . . . . . . . . . 11.1.Standard functions . . . . . . . . . . . . . . . . . . .
9.
10. 11.
VII
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . interchange.
15. I n d e x . . . . . . . . . . . . . . . . . . . . . . . . . . .
0 ~NTRODUCTION
Much
of
the
following
text
assumes
the
reader has
a minimal
grasp of e
for is
intuition.
0.1 annual inflation rates o f 9 , 8 , a n d 10 p e r c e n t . factor by which the frank, dollar, pound m a r k , or g u i l d e r will have been devalued in n years.}
inflation(output);
: real; w 2 := 1.0;
w3
:=
1.0;
w2 w3
1 2 3 4 5 6
7
9 10
An &3ooritbj~ or computer program consists of t w o e s s e n t i a l parts, a description of ~ctions which ere to be performed, and a description o f t h e ~@_~&o w h i c h is m a n i p u l a t e d by t h e s e a c t i o n s .
Actions described
The
end
data
is
program
a body,
called
b3ock. The heading gives the program s name a n d l i s t s parameters. (These ere (file) variables and represent arguments and results of the computation. See chapter 13.) file "output" is e compulsory parameter. The b l o c k consists six sections, where any except t h e l e s t may be e m p t y . In required order they ere:
<label declaration part> <constant definition part> <type d e f i n i t i o n p a r t > <variable declaration part> <procedure and f u n c t i o n d e c l a r a t i o n p a r t > <statement p a r t >
The first section l i s t s a l l l a b e l s d e f i n e d in t h i s b l o c k . The second section defines synonyms for constants: i.e. it introduces i d e n t i f i e r s t h a t m a y l a t e r be u s e d in p l a c e of t h o s e constants. The third contains type definitions: end the fourth. variable definitions. The fifth section defines subordinate program parts (i.e. procedures and functions). The s t a t e m e n t part specifies t h e a c t i o n s to be t a k e n . The above program outline is more precisely e x p r e s s e d in a syntax ~ a p r a m . S t a r t i n g a t t h e diagram named p r o g r a m , a p a t h through the diagram defines a syntactically correct proqram. Each box r e f e r e n c e s a d i a g r a m by t h a t n a m e . w h i c h is t h e n u s e d to define its meaning. Terminal symbols (those actually written in a P a s c a l p r o g r a m ) a r e in r o u n d e d e n c l o s u r e s . (See a p p e n d i x D for t h e f u l l s y n t a x d i a g r a m of P a s c a l . )
program
block
~1 .... i~.di,l,~o~ I-
j~
I ~~G-o ~
p..... ter list I "i
~-~PROCEDUII~~--I
Figure O.a
An alternative formulation of a syntax is the traditional Backus-Naur ~orm. where syntactic constructs are denoted by English words enclosed between the angular brackets < a n d >. These words are suggestive of the n a t u r e or m e a n i n g of t h e construct. A sequence of constructs (I or more elements) enclosed by the mete-brackets { and } imply their repetition zero or m o r e t i m e s . (For t h e B N F of P a s c a l . see appendix D . ) As an example, the construct <program> of f i g u r e O.a is d e f i n e d by the following formulas, called "productions": <program> <program <file ::= < p r o g r a m heading> <block> . heading> ::~ ~ r o m r a ~ <identifier> ( <file identifier> { . <file identifier>} ) ; identifier> ::= < i d e n t i f i e r >
Each procedure (function) has a structure similar to a program; i.e. each consists of a heading and a block. Hence. procedures may be declared (nested) within other procedures. Labels, constant synonyms, type, variable, and procedure declarations are local to the procedure in w h i c h t h e y a r e d e c l a r e d , That i s , their identifiers have significance only within the program text which constitutes the procedure declaration a n d w h i c h is c a l l e d the ~eooe of these identifiers. S i n c e p r o c e d u r e s m a y be n e s t e d , so may scopes. Objects which are declared in t h e m a i n p r o g r a m , i.e. not local to some procedrue, are called ~Iobal and have significance throughout the entire program. Since b l o c k s m a y be n e s t e d within o t h e r b l o c k s by p r o c e d u r e and function declarations, o n e is a b l e to a s s i g n a l e v e l of n e s t i n g to each. If the outermost program-defined block (e.g. the main program) is called level O, t h e n a b l o c k d e f i n e d within this block w o u l d be of l e v e l I; in g e n e r a l , a b l o c k d e f i n e d in l e v e l i would be of level (i+I). Figure O.b i l l u s t r a t e s a block structure,
where
0 I 2 3
: = : :
M P, A, B
Q R,
QF--q
Figure
O.b
Block
structure
In t e r m s of t h i s f o r m u l a t i o n , t h e s c o p e or r a n g e of v a l i d i t y of an identifier x is the entire b l o c k in w h i c h x is d e f i n e d , including t h o s e b l o c k s d e f i n e d in t h e s a m e b l o c k as x. (For t h i s example, note that all identifiers m u s t be d i s t i n c t . S e c t i o n 3.e discusses the case where identifiers are not necessarily distinct,) objects defined in b l o c k are accessible in blocks
M
P A B
M ,P ,A .B ,Q .R ,S
P ,A ,B A.B B
Q
R S
Q ,R ,S
R S
For programmers acquainted prove helpful to glance languages. For this characteristics of P a s c a l : 1. 2.
with ALGOL, PL/I, or FORTRAN, it may at Pascal in t e r m s of t h e s e o t h e r purpose, we list the following
3. 4.
5. 6.
7.
8. 9.
Declaration of variables is mandatory, Certain key words (e.g. ~eain, ~nd, ~eoeat) ere "reserved" and cannot be used as identifiers. In this manual they are underlined. The semicolon (;) is c o n s i d e r e d as a s t a t e m e n t separator, not a s t a t e m e n t t e r m i n a t o r (as e . g . in PL /I). The standard data types are those of whole and real numbers, the logical values, and the (printable) characters. The b a s i c d a t a s t r u c t u r i n g facilities include the array, the record (corresponding to COBOL's and PL / I ' s "structure"). the set, and the (sequential) file. These structures can be combined end nested to form arrays of sets, files of records, etc. D a t a may b e allocated dynamically and accessed via pointers. These pointers allow the full generality of l l s t p r o c e s s i n g . T h e m e is a f a c i l i t y to d e c l a r e n e w , b a s i c d a t a t y p e s w i t h symbolic constants. The let data s t r u c t u r e offers facilities s i m i l a r to t h e P L / I "bit s t r i n g " . Arrays may be of arbitrary dimension with arbitrary bounds; the array bounds are constant. (i.e. There are no dynamic arrays.) As in FORTRAN. ALGOL, and PL/I, there is a go to statement. Labels are unsigned integers and m u s t be declared. The compound statement is that of ALGOL, and corresponds t o t h e DO g r o u p in PL/I. The facilities o f t h e ALGOL s w i t c h and the computed go to o f FORTRAN a r e r e p r e s e n t e d by the case statement.
10.
The
for
statement,
corresponding
to
the
DO
loop of
F O R T R A N . may o n l y have steps is executed only as long variable lles within the controlled s t a t e m e n t m a y not
16.
There are no conditional expressions a n d no m u l t i p l e assignments. Procedures e n d f u n c t i o n s m a y be c a l l e d r e c u r s i v e l y . T h e r e is no " o w n " a t t r i b u t e for v a r i a b l e s (as in A L G O L ) . Parameters are called either by value or by reference: there i s no c a l l by name. The "block structure" differs from that o f ALGOL a n d P L / I insofar as there are no anonymous blocks, i.e. each block is given a name, and thereby i s made i n t o a procedure. All objects--constants, variables, etc.--must be declared ~eo~_~ they are referenced. The following two exceptions ere however allowed: I) the type identifier in a pointer type definition (chaptem 10) 2) procedure and function calls when there is a forward reference (chapter 11).
Upon f i r s t c o n t a c t w i t h P a s c a l , m a n y t e n d to b e m o a n the a b s e n c e of certain "favorite features", Examples include an exponentiation operator, concatenation of strings, dynamic arrays, arithmetic o p e r a t i o n s on B o o l e a n v a l u e s , a u t o m a t i c t y p e conversions, and default declarations. These were not oversights, but deliberate omissions. In some cases their presence would be primarily an invitation to inefficient programming s o l u t i o n s ; in o t h e r s , it w a s felt t h a t t h e y w o u l d be Contrary to the aim of clarity and reliability a n d "good programming style". Finally, a rigorous selection among the immense variety of programming facilities available had to be made in order to keep the compiler relatively compact and efficient--efficient and economical for both the user who writes o n l y s m a l l p r o g r a m s u s i n g f e w c o n s t r u c t s of t h e l a n g u a g e a n d t h e u s e r w h o w r i t e s l a r g e p r o g r a m s a n d t e n d s to m a k e u s e of the full language.
__N TAT~.~.~.!~T.J~A N D
VOCABULARY
The basic wocabularv consists letters, digits, and special operators and delimiters: + : " ( ) and Drrav
of b a s i c symbols.
and _f..il~
ail aot
~hen
] } % ..
~9~d-delim~ (or reserved words) ere normally u n d e r l i n e d in the hand-wrltten program to e m p h a s i z e t h e i r i n t e r p r e t a t i o n as single symbols with fixed meaning. The orogrammer m a y not u s e these words in a context other than that e x p l i c i t in t h e d e f i n i t i o n of P a s c a l : in p a r t i c u l a r , t h e s e w o r d s m a y not be u s e d as identifiers. They are written as a s e q u e n c e of l e t t e r s (without surrounding escape characters). The construct: {<any sequence of s y m b o l s not containing "} ">}
m a y be i n s e r t e d b e t w e e n a n y t w o i d e n t i f i e r s , n u m b e r s , or s p e c i a l symbols. It is called a ~ o m m e n a n d m a y be r e m o v e d from t h e program text w i t h o u t a l t e r i n g its m e a n i n g . T h e s y m b o l s { a n d } do not occur o t h e r w i s e in t h e l a n g u a g e , a n d w h e n a p p e a r i n g in syntactic descriptions, they denote meta-symbols l i k e I and ::=. (On systems where the curly brackets are unavailable, the c h a r a c t e r p a i r s (* and *) a r e u s e d in t h e i r p l a c e . ) ~de~if~ers are names denoting constants, types, variables. Procedures. and functions. They must begin with a letter, which may be followed by any combination and number of letters and d i g i t s . A l t h o u g h an i d e n t i f i e r m a y be v e r y l o n g . i m p l e m e n t a t i o n s may impose a limit as to how m a n y of t h e s e c h a r a c t e r s a r e significant. Implementations of Standard Pascal will always recognise the first ~ characters of an identifier as significant. That is. identifiers denoting distinct objects s h o u l d d i f f e r in t h e i r f i r s t U c h a r a c t e r s .
10
Figure
1.a
Identifier
examples of legal identifiers: sum root3 pi h4g x thisisaverylongbutneverthelesslegalidentifier thisissverylongbutprobablythesameidentifierasabove illegal 3rd identifiers: array
level.4
root-3
Certain i d e n t i f i e r s , called ~ e n d a r d i d e n t i f i e r s , ere predefined (e.g. sin, cos). In contrast to the w o r d - d e l i m l t e r s (e.g. QrraM), one is not r e s t r i c t e d to this d e f i n i t i o n and may elect to redefine any standard identifier, as they are assumed to be declared in a hypothetical block s u r r o u n d i n g the entire program block. Decimal n o t a t i o n is used for ~ u m b e r s . The letter E preceding the scale factor is pronounced as "times 10 to the power of". The syntax of u n s i g n e d numbers is s u m m a r i z e d in figure 1.b.
Figure
1.b
Unsigned
number
Note that if the number c o n t a i n s digit must precede and succeed occur in a number.
unsigned 3
numbers : 03 6272844
0.6
5E-8
49.22E +08
IE 10
El0
5.E-16
Blanks. ends of lines, and comments ere considered as semara~rs. An a r b i t r a r y n u m b e r of s e p a r a t o r s may occur between any two consecutive Pascal symbols with the following exception: no separators may o c c u r w i t h i n identifiers, n u m b e r s , or s p e c i a l symbols. H o w e v e r , at l e a s t o n e s e p a r a t o r m u s t o c c u r b e t w e e n a n y p a i r of c o n s e c u t i v e identifiers, n u m b e r s , or w o r d s y m b o l s .
by mark
2 --THE _C~.~,CF,,.P_-TBE_ D A T A
Data is the general expression d e s c r i b i n g a l l t h a t is o p e r a t e d on by t h e c o m p u t e r . At t h e h a r d w a r e a n d m a c h i n e c o d e l e v e l s , a l l data are represented as sequences of binary digits (bits). Higher level languages allow one to u s e a b s t r a c t i o n s a n d to ignore t h e d e t a i l s of r e p r e s e n t a t i o n - - l a r g e l y by d e v e l o p i n g t h e C o n c e p t of d a t a ~ v o e . A data type defines t h e s e t of v a l u e s a v a r i a b l e m a y a s s u m e . Every variable occurring in a p r o g r a m m u s t be a s s o c i a t e d w i t h One and only one type. A l t h o u g h data t y p e s in P a s c a l can be quite sophisticated, each must be ultimately built from unstructured types. An unstructured t y p e is e i t h e r d e f i n e d by the programmer, a n d t h e n c a l l e d a d e c l a r e d s c a l a r t y p e . or o n e of the four standard scalar types--integer, r e a l , B o o l e a n . or char. A scalar type is characterized by the s e t of its d i s t i n c t values, u p o n w h i c h a l i n e a r o r d e r i n g is d e f i n e d . The v a l u e s a r e denoted by identifiers in the definition of t h e t y p e (see chapter 5).
A. T h e
type
Boolean
A Boolean value is one of t h e the predefined identifiers false The following applied to Operators.) logical Boolean operators operands:
values
denoted
by
when all
and
or no__t
Each of the relational operators (=, <>. <=, <, >, >=, ~) yields a Boolean value. Furthermore. the type Boolean is defined such that false < true. Hence, it is possible to define each of the 16 B o o l e a n operations using the above logical and relational operators. For example, if p and q are Boolean values, one can express implication equivalence e x c l u s i v e OR as as as p p p <= q = q <> q
13
Standard Boolean functions--i.e, standard functions which yield a Boolean result--ere: (Appendix A summarizes all s t a n d a r d functions.)
odd(x)
e o l n (f) eof(f)
t r u e if t h e i n t e g e r x is odd, f a l s e o t h e r w i s e e n d of a l i n e , e x p l a i n e d in c h a p t e r 9 e n d of f i l e . e x p l a i n e d in c h a p t e r 9
B.
The
type i n t e g e r
an element numbers. an integer of the
yield
value
when
rag_ d_ +
-
(i.e. v a l u e b)*b)
is
not
rounded)
<>. <, <=. >=. > y i e l d a B o o l e a n o p e r s n d s . <> d e n o t e s inequality. yielding integer results are:
functions
round(x)
t h e r e s u l t is t h e a b s o l u t e v a l u e of x . t h e r e s u l t is x s q u a r e d . x is a r e a l v a l u e : t h e r e s u l t is its w h o l e p a r t . (The fractional part is discarded. Hence trunc(J.7)=3 and trunc(-J.7)=-3) x is a real value; the result is t h e r o u n d e d integer, r o u n d ( x ) m e a n s for x > = 0 t r u n c ( x + 0 . 5 ) , and for x < 0 t r u n c ( x - 0 . 5 ) sqr yield of type an integer result only when their i n t e g e r . If i is a v a r i a b l e of t y p e
Notes: abs and argument is also integer, then succ(1) yields pred(i) yields This is, h o w e v e r , i+1 and
the
expressions
is g u a r a n t e e d
when:
14
, , and
C . The
type
real
A v a l u e of t y p e r e a l implementation-defined
is
an e l e m e n t of s u b s e t of r e a l
the numbers.
As l o n g as at l e a s t o n e of t h e real (the other possibly being operators yield a real value: * / + multiply divide (both operands the result is add subtrcct
following
may be always
integers, real)
but
Standard result:
functions
when
accepting
a reel
argument
yield
a real
functions
with
real
or
integer
argument
and
meal
sin (x) cos (x) amctan (x) ln(x) e x p (x) sqrt (x)
trigonometric
functions
Warninq: although r e a l is i n c l u d e d as a s c a l a r t y p e , it c a n n o t a l w a y s be u s e d in t h e s a m e c o n t e x t as t h e o t h e r s c a l a r types. In Particular. the functions pred and succ cannot take real arguments, a n d v a l u e s of t y p e m e a l c a n n o t be u s e d w h e n i n d e x i n g arrays, n o r in c o n t r o l l i n g for statements, nor for defining the base type of a set.
D.
The
type
char
A value of t y p e c h a r is an e l e m e n t of a f i n i t e a n d o r d e r e d s e t of characters. Every computer system defines s u c h a s e t for t h e purpose of c o m m u n i c a t i o n . These characters a r e t h e n a v a i l a b l e on the input and output equipment. Unfortunately. there does not
15
exist one standard character set; the elements and their ordering dependent.
the
type
char,
The c h a r a c t e r set includes 1. t h e alphabetically ordered A...Z 2. the numerically ordered and digits 0...9 3. t h e b l a n k c h a r a c t e r .
set
of
capital set
Latin of the
letters decimal
contiguous
A character enclosed c o n s t a n t of t h i s t y p e .
in a p o s t r o p h e s
(single
quotes)
denotes
'G"
'3
X it twice.)
an apostrophe,
The two standard f u n c t i o n s ~r.~[ a n d ~ h r a l l o w t h e m a p p i n g o f g i v e n c h a r a c t e r s e t o n t o a s u b s e t of n a t u r a l n u m b e r s - - c a l l e d ordinal numbers of the character set--and vice verse; ord chr e r e c a l l e d ~ r a n s f e r ~ u n c t i o n s . ord(c)
chr(i)
is the ordinal number of the character c in t h e underlying ordered c h a r a c t e r s e t . (also s e e s e c t i o n 5.A) is the character value with the ordinal number i.
that -and-
ord
and
chr
are
inverse = i
functions.
ord(chr(i))
Furthermore, ci < e 2
the
ordering iff
set
is
defined
by
This definition can be extended to each of t h e r e l a t i o n a l operators: =. <>. <, <=, >=. >. If R d e n o t e s o n e of t h e s e operators, then ci R e2 iff ord(cl) R ord(c2)
When type
pred
and
succ
is
of
pred(c) succ(c)
TH~ PR0~RAM H E A ~ N G
Every program consists of a heading and a block. The block contains a declaration part, in which all objects local to the program are defined, and a statement part. which specifies the actions to be executed upon these objects. <program> ::= < p r o g r a m heading> <block> <block> ::: < l a b e l d e c l a r a t i o n part> <constant definition part> <type definition part> <variable declaration part> <procedure and function declaration <statement part>
part>
A.
Program
heading
The heading gives the program a n a m e (not o t h e r w i s e significant inside the program) a n d l i s t s its p a r a m e t e r s , through which the program communicates with the environment (see c h a p t e r 13.B.I). <program heading> ::= & ~ l i g ~ i m < i d e n t i f i e r > { , <file identifier> ( <file } ) ; identifier>
B.
Label
declaration
part
Any statement in a program may be m a r k e d by p r e f i x i n g the statement with a label followed by a c o l o n (making possible a reference by a goto statement). However, t h e l a b e l m u s t be defined in t h e j a b e l ~ c l a r ~ & i ~ A & ~ i ~ b e f o r e its u s e . T h e s y m b o l label heads this part, which has the general form: label <label> {, <label>}; to be an unsigned integer, end consists of at
~,1~;
C.
Constant
definition
part
~efinition i n t r o d u c e s an i d e n t i f i e r as a s y n o n y m for The symbol ~ introduces the constant definition has t h e g e n e r a l form: = <constant>; {<identifier> = <constant>;}
<identifier>
17
where a (possibly
constant signed),
is either" or a s t r i n g .
number,
a constant
identifier
The use of c o n s t a n t i d e n t i f i e r s g e n e r a l l y m a k e s a p r o g r a m m o r e readable and acts as a c o n v e n i e n t d o c u m e n t a t i o n a i d . It a l s o allows the programmer to group machine or example dependent quantities at the beginning of the p r o g r a m w h e r e t h e y can be easily noted and/or changed. (Thereby aiding the portability and m o d u l a r i t y of t h e p r o g r a m . ) As an example, consider the following program:
program example
definition
pert
~roaram
#onst
(output);
mulby = 1.8; low = O; high = 39;
addin
= 32;
sesarator = * ; var degree : low..high; J~eain writeln (separator): f o r d e g r e e := low J&o h i g h d o beQi~ write(degree'c',round(degree*mulby if odd(degree) then writeln end : writeln ; writeln (separator) and.
+ addin),'f')"
0c 2c 4c 6c 8c I0c 12c 14c 16c IBC 20C 22c 24c 26c 28c 30c 32c 34c 36c 38c
32f 36f 39f 43f 46f 50f 54f 57f 61f 64f 68f 72f 75f 79f 82f 86f 90f 93f 97f 100f
Ic 3c 5c 7c 9c 11c 13c 15c 17e 19c 21c 23c 25c 27c 29c 31c 33c 35c 37c 39c
34f 37f 41f 45f 48f 52f 55f 59f 63f 66f 70f 73f 77f 81f 84f 88f 91f 95f 99f I02f
18
D.
Type
definition
part
A data type in P a s c a l m a y be e i t h e r directly d e s c r i b e d in t h e variable declaration or referenced by a ~ypQ ~dentifier. Provided are not only several standard type identifiers, but also e mechanism, t h e ~Z#,~ ~ e f i n i t i o o , for creating new types. The symbol ~.@ introduces a program part containing type definitions, The definition itself determines a set of values and associates an i d e n t i f i e r with the set. The g e n e r a l form is: t~oe Examples chapters. <identifier> of type = <type>: definitions [<identifier> ere = <type>:} the subsequent
f o u n d in
E.
Variable
declaration
part
A variable declaration a s s o c i a t e s en i d e n t i f i e r and a data type with a new variable by s i m p l y listing the identifier f o l l o w e d by its type. The symbol ~&~ heads the variable declaration part. The general f o r m is: <identifier> {<identifier> {, < i d e n t i f i e r > } { , <identifier>} : <type>: : <type>i}
reali
This identifier/type association is v a l i d t h r o u g h o u t the entire block containing the declaration, unless the i d e n t i f i e r is redefined in a subordinate block. S u p p o s e a b l o c k B is n e s t e d within block A . (i.e. declared w i t h i n t h e s c o p e of a n d h e n c e subordinate t o A . as in f i g u r e 0 . b ) It is p o s s i b l e t o d e c l a r e an identifier in B that is already declared in A . T h i s has t h e effect of associating that identifier with a variable local to B--not available to A--which may be o f a n y t y p e . T h e l a t t e r definition is then valid throughout the scope o fBo u n l e s s redeclared in a block subordinate to B . It is n e t a l l o w e d to declare a single identifier more than once within the same level and scope. Hence the following is a l w a y s incorrect. ~J~ a : integer; a : real;
19
F.
Procedure
and
function
declaration
part
Every procedure or function must be defined (or a n n o u n c e d ) before its use. Procedure end function declarations are treated in chapter 11. P r o c e d u r e s are subroutines end are activated by procedure statements. Functions are subroutines that yield a result value, and therefore can be u s e d as c o n s t i t u e n t s of
expressions.
4 THE ~QNCEPT OE A C T I O N
Essential to a computer program is action. That is, a program must do something with its data--even if that action is the choice of doing nothing! ~ ~ describe these actions. Statements are either &imole (e.g. the assignement statement) or structured.
A.
The
assignment
statement
The most fundamental of s t a t e m e n t s is t h e ~ s s i ~ d 3 ~ wtatement. It specifies that a newly computed value be assigned to a Variable. T h e f o r m o f an a s s i g n m e n t is: <variable> := < e x p r e s s i o n > not t o be c o n f u s e d w i t h t h e "a := 5" is pronounced "the the value 5", or simply, "a
w h e r e := is t h e & s s i c n m e n t ~perator. relational operator =. The statement current value of a is replaced with ~ecomes 5".
The n e w v a l u e is o b t a i n e d by e v a l u a t i n g an ~ x m r e s s i o n consisting of constant or variable operands, operators, and function designators, (A f u n c t i o n designator specifies the activation of a function. Standard functions are listed in Appendix A; user defined functions are explained in chapter 1 1 . ) An e x p r e s s i o n is e rule for calculating e value where the conventional rules of left to right evaluation and ~Eerator erecedence are observed. The operator ~ot (applied to a Boolean operand) has the highest precedence, followed by the multiplying operators (*. /, ~iv, ~_#J~, ~U~), then the adding operators (+, -, ~), and of lowest precedence, the relational operators (=, <>, <, <=. >=, >. &~). Any expression enclosed within parentheses is evaluated independent of preceding or succeeding operators. examp les : 2 * 3-4 * 5 15 ~ 4 * 4 B0/5/3 4/2 *3 sqrt (sqr(3)+11*5) The syntax The reader of is
= = = =
(4*5) 4)*4
exact rules of precedence. it whenever in doubt. thst been their v a l u e may b e evaluated. Assume
Boolean expressions have the property known before the entire expression has for example, that x=O. Then (x>O) is ~ (x<lO) known to be false after
already
computation
of
the
first
21
factor, and the second need not be e v a l u a t e d . T h e r u l e s of Pascal neither require nor forbid the evaluation of t h e s e c o n d part in such cases. This means that the programmer must assure that the second f a c t o r is w e l l - d e f i n e d , independent of t h e v a l u e of the first factor. H e n c e . if o n e a s s u m e s that the array a has an index ranging f r o m I t o 10. t h e n t h e f o l l o w i n g e x a m p l e is in error~
x := O:
~eoeat
:=
x+1
~ntil =
(x>lO) O, the
a[11] .)
(Note
that
if
no a[i]
program
Direct assignment is p o s s i b l e to variables of any type, except files. However. the variable (or the function) and the expression m u s t be of i d e n t i c a l type. with the exception t h a t if t h e t y p e o f t h e v a r i a b l e is r e a l , the type of the expression may be integer. (If a subrange t y p e is i n v o l v e d , its associated scalar type determines the validity of the assignment; see section 5 . B .)
+ y)
B.
The
compound
statement
The ~pmpound ~tatement s p e c i f i e s t h a t its c o m p o n e n t statements be executed in the same sequence as they are written. The symbols ~egin a n d ~ n d a c t as s t a t e m e n t brackets. Note that the "body" of a Program has t h e f o r m o f a c o m p o u n d statement.
statement
beginend(output);
e_o~.
B -8
22
Pascal uses the semicolon to ~eoarete statements, not to terminate statements; i.e. the semicolon is N O T p a r t of t h e statement. The explicit rules regarding semicolons are reflected in the syntax of Appendix D . If one h a d w r i t t e n a s e m i c o l o n after the second statement, t h e n an ~ m o t y ~ t a t e m e n t ( i m p l y i n g no action) would have been assumed between the semicolon and the symbol ~nd. This does no harm, for an e m p t y s t a t e m e n t is allowable at this point. Misplaced s e m i c o l o n s can. h o w e v e r , cause troubles--note t h e e x a m p l e in s e c t i o n 4.D .
C. R e p e t i t i v e statements
Reoetltive ~tatmments specify that certain statements be repeatedly executed. If the number of repetitions is k n o w n beforehand (before the repetitions are b e g u n ) , t h e for s t a t e m e n t is usually the appropriate c o n s t r u c t to e x p r e s s t h e s i t u a t i o n ; o t h e r w i s e , t h e r e p e a t or w h i l e s t a t e m e n t s h o u l d be u s e d .
C .1 T h e The
while
while while
statement <expression>
I + 1/2 +
I/3
o..
+ I/n
egwhile(input,
output):
: integer; h : real; read(n); write(n); h :: O; while n>O ~ ~p.~ h := h + I/n; nnd; writeln(h) end.
:= n-1
10
2.928968253968e+00
23
statement
is
not
executed
at
all.
C.2
The
repeat
statement <statement> of at
{ ; <statement>}
statements between the symbols ~eat and until least once. Repeated e x e c u t i o n is c o n t r o l l e d by expression, w h i c h is evaluated after every
4.3 h(n)
I + I/2
I/3
...
I/n
egrepeat(input,
output);
:= n - 1
n=O;
writeln (h)
am~.
10 2.928968253968e+00
program performs correctly for n>O, Consider what n<=O. The while-verslon of the s a m e p r o g r a m is a l l n. i n c l u d i n g n=O. statements that pair ~e~!~...~nd the repeat w o u l d be
C.3
The
for
statement
The for statement indicates that a statement be r e p e a t e d l y executed while a progression of values is assigned to t h e &pn~ z a r i a b l e of t h e f o r s t a t e m e n t . It h a s t h e g e n e r a l form: for <control variable> := < i n i t i a l value> do < s t a t e m e n t > := < i n i t i a l value> do < s t a t e m e n t > to <final value>
(or)
<control variable> downto <final value>
24
program compute
4.4 h(n)
1 + 1/2
1/3
...
1/n
o r o o r ~ eGfor(input, output);
yam i,n : integer; h : real; beain r e a d (n) ; w r i t e (n) ; h := O; i := n d Q ~ n t o I d ~ h := writeln(h) end.
+ 1/i;
10
2.928968253968e+00
{ program 4.5 compute the cosine using cos(x) = 1 -x*'2/(2"I) ~rQoram const vat cosine (input,
...
output);
eps = Ie-14; x , s x , s , t :real; i .k ,n :integer ; b#ain read(n); for i := I t o n ~L~ beoin read(x); t := I; k :-- O; s := I; s x ~DJ~ abs(t) > eps*abs(s) do ~e~D k :~ k + 2; t := -t*sx/(k*(k-1));
S
:~ s q r ( x ) ;
:= ;
s+t
end
(x ,s ,k d i v
2)
5 6 ? 9 14
The control variable, the initial value, and the final value must be of t h e s a m e s c a l a r type (excluding type real), and must not be altered by the for statement. The initial and final values are evaluated o n l y o n c e . If in t h e c a s e of ~ (~nw~to) the initial value is g r e a t e r (less) than the final value, the for statement is not e x e c u t e d . The final value of the control variable is left undefined upon normal exit from the for statement.
25
for for
statement v
of t h e e2 ~g the
form: S of statements:
:= el & g to
is
equivalent
sequence
S; is
:=
succ(v);
S:
...;
:=
e2;
undefined}
and
a ~or
for v
statement := el
of t h e e2 ~ g
form: S
#ownto to the
is
equivalent
statement:
S; v is
:=
pred(v);
S;
...;
:= e2;
undefined}
As
a final
example
consider
the
following
program.
s 1.s 2p ,s 2n ,s 3,s4p ,s 4n .lrp .lrn ,rlp ,rln : real; i : integer ; _be.qin s 1 := 0; s2p := O; s 2 n := O; s 3 := O; s 4 p := O; s 4 n fgj& i := I J2o 5 0 0 0 ~L~ begin l r p := I / ( 2 - i - I ) ; { pos terms, left to right } l r n := I / ( 2 - i ) ; { n e g t e r m s , l e f t t o r i g h t } r l p := I / ( I 0 0 0 1 - 2 - i ) ; { p o s t e r m s , r i g h t to l e f t } r l n := I / ( I 0 0 0 2 - 2 - i ) ; { n e g t e r m s , r i g h t to l e f t } sl := s l + lrp - l r n : s 2 p := s 2 p + I r p ; s 2 n := s 2 n + I r n : s 3 := s 3 + r l p - r l n ; s 4 p := s 4 p + r l p ; s 4 n := s 4 n + r l n gnU; w r i t e l n (s I ,s 2p ~s 2n ) ; writeln(s3,s4p-s4n) end.
:=
O;
~.930991830595e-01 6.930971830599e-01
6.930971830612e-01 6.930991830601e-01
26
Why
do t h e
four
"identical"
sums
differ?
D. Conditional
statements
A ~qgo~L~tonal ~tatement an if or case statement, selects a single statement of its component statements for execution. The if ~Lt~tement specifies that a statement be executed only if a certain condition (Boolean expression) is true. If it is false, then either no statement or the statement following the symbol e l s ~ is e x e c u t e d .
D .I The The t w o
if
if s t a t e m e n t forms for an if s t a t e m e n t
<statement> <statement> else <statement>
are:
<expression> <expression>
~hen ~hen
(or)
if
The expression b e t w e e n t h e s y m b o l s if a n d ~ h e n must be of t y p e Boolean. Note that the first f o r m may be regarded as an abbreviation of the second when the alternative statement is the empty statement. Caution: there is never a semicolon before an else1 Hence, the text:
if p J&heI3 . ~ e a i n $1; S2; $3 end; else $4
is i n c o r r e c t .
if p then;
Perhaps
~#ain
even
S2;
more
deceptive
is t h e
text:
$1;
$3 ~nd
The s y n t a c t i c a m b i g u i t y a r i s i n g f r o m the c o n s t r u c t : if < e x p r e s s i o n - l > J~Q2.J3 i f < e x p r e s s i o n - 2 > ~ h e n < s t a t e m e n t - l > rise <statement-2> is r e s o l v e d by i n t e r p r e t i n g t h e c o n s t r u c t as e q u i v a l e n t iL <expression-l> ~hen ~eain if <expression-2> ~hen <statement-l> else <statement-2> to
The r e a d e r is f u r t h e r c a u t i o n e d t h a t e c a r e l e s s l y statement can be very c o s t l y . Take t h e e x a m p l e n-mutually exclusive conditions, c1.,.Cno each
27
distinct action, si. Let P ( c i ) be t h e true, and say that P(ci)>=P(cj) for i < j . s e q u e n c e o f if c l a u s e s is : if ci t h e n sl e l s e i f c2 S b e n s 2 else ... else if c(n-1) ~hen
s(n-1)
e!se
sn
its the
frequent
abuse
simpler := a = b
statement
found
28
~ar x oy : integer ; bgqio y := I; ~j~p~&t_ x := y: write(x," w_hile x > = 1 0 0 0 do bw_qin write(m): if x>=500 then bea~j3 w r i t e ( ' d ") ;
w_h_Ale x>=lO0 d o
if
b~gin write('c): x > = 5 0 t, hen beEi_.on w r i t e ( ' l ' ) :
:= x - l O 0 := x - 5 0 := x - t 0 := x - 5
:= x - 1
w_hi!e x>=10 d~
be_~i~n write('x'): x x
x
if x > : 5 ~hsn
~h_~le
until y>5000
and.
i ii iiii viii xvi xxxii lxiiii cxxviii cclvi dxii mxxiiii mmxxxxviii mmmmlxxxxvi
The next program r a i s e s a r e e l v a l u e x t o t h e p o w e r y. w h e r e y is a non-negative integer. A simpler, and evidently correct version is obtained by o m i t t i n g the inner while statement: the result z is t h e n o b t a i n e d through y multiplications by x. N o t e the loop invariant: z*(u**e)=x**y. The inner while statement leaves z and u**e invariant, and obviously improves the efficiency of t h e a l g o r i t h m .
29
with
natural
exponent output);
exponentiatiom(input,
b ~
{z*u**e
while ~_~ b~_~in
= x**y,
e>O}
2: u := s q r ( u )
odd(e) do e :-- e d i v
e a~; writeln(z)
en~. ; := e - l ; {z
:= u * z
= x*~y}
2.000000000000e+O0
I .2UOOOOOOOOOOe+02
The following program plots a reel-valued f u n c t i o n f ( x ) by letting the X~xis run vertically a n d t h e n p r i n t i n g an a s t e r i s k in positions corresponding to t h e c o o r d i n a t e s . T h e p o s i t i o n of the asterisk is o b t a i n e d by c o m p u t i n g y=f(x), multiplying by a scale factor s, rounding t h e p r o d u c t to t h e n e x t i n t e g e r , a n d then adding a constant h end letting the asterisk be p r e c e d e d by that many blank spaces.
30
function }
&re,ram const
d = 0.0625: {3/16o 16 l i n e s for i n t e r v a l [x,x+1]} s = 31: {31 c h a r a c t e r w i d t h s for i n t e r v a l [y,y+1]} h = 34: { c h a r a c t e r position of x-axis} c = 6.28318: {2*pi} lim = 32: var XoY : reel: i,n : integer: beain x := O; f_.gor_ i := I J2~ l i m d o b~eqin y := e x p ( - x ) * s i n ( c * x ) ; n := r o u n d ( s ' y ) + h: r_epe_a~ w r i t e ( "); n := n - 1 until n=O: writeln('**) :
X := x+d
end_ en_dd.
95
31
O.2
T he
case
statement
The case statement c o n s i s t s of an e x p r e s s i o n (the s e l e c t o r ) a n d a llst of s t a t e m e n t s , e a c h b e i n g l a b e l l e d by a c o n s t a n t of t h e type of t h e s e l e c t o r . T h e s e l e c t o r t y p e m u s t b9 a s c a l a r t y p e , excluding the type real. The case statement selects for execution that statement whose l a b e l is e q u a l t o t h e c u r r e n t v a l u e of t h e s e l e c t o r ; if no s u c h l a b e l is l i s t e d , t h e e f f e c t is undefined. Upon completion of t h e s e l e c t e d s t a t e m e n t , control goes t o t h e e n d of t h e c a s e s t a t e m e n t . T h e f o r m is: cas~ <expression> ~Z <case label list> <case end label'list>
: <statement>; : <statement>
i:
i n t e g e r ; ch: c h a r ; ) c a s e ch of ' a ' , ' g ' . ' d ' : ch := s u c c ( e h ) ; "z,*e: ch := p r e d ( c h ) ; "f" S: {null case} end
Notes: "Case labels" are ~ o r d i n a r y l a b e l (see s e c t i o n 4 . E ) and c a n n o t be r e f e r e n c e d by a g o t o s t a t e m e n t . T h e i r o r d e r i n g is arbitrary; however, labels m u s t be u n i q u e w i t h i n a g i v e n c c s e statement. Although the efficiency of the case statement d e p e n d s on t h e implementation, the general rule is to u s e it w h e n o n e has several mutually exclusive statements with similar probability of s e l e c t i o n .
E.
The
goto
statement
<label>
Each label (an u n s i g n e d i n t e g e r t h a t is at m o s t 4 d i g i t s ) m u s t appear in a label declaration p r i o r to its o c c u r r e n c e in t h e program body. The s c o p e of a l a b e l L d e c l a r e d in a b l o c k A is the entire text of block A. That is, ~ i ~ s t a t e m e n t in t h e statement oart of A may be p r e f i x e d w i t h L : . T h e n any o t h e r statement w i t h i n t h e ~ b o l e of b l o c k A m a y r e f e r e n c e L in a g o t o statement.
32
example label
(program I:
* o ,
fragment): A}
{block
got o 3
B}
in b l o c k
A}
Warning: The effect of jumps from outside of a s t r u c t u r e d statement into that statement is not defined . Hence. the following examples are i n c o r r e c t . (Note t h a t c o m p i l e r s do not n e c e s s a r i l y i n d i c a t e an e r r o r . ) examples : a) for i:= I ~ 10 do _beoin S I; 3:S2 and ;
b)
if P then woto
o
3;
if c)
a'~bed~ 3: S P
oroc@dure
beoin ...
A goto statement should be r e s e r v e d for u n u s u a l or u n c o m m o n s i t u a t i o n s w h e r e the n a t u r a l s t r u c t u r e of an a l g o r i t h m has to be broken. A good rule is to a v o i d the u s e of j u m p s to e x p r e s s regular i t e r a t i o n s and c o n d i t i o n a l e x e c u t i o n of s t a t e m e n t s , for such jumps destroy the reflection of the structure of computation in the t e x t u a l ( s t a t i c ) s t r u c t u r e of t h e p r o g r a m . Moreover, the lack of correspondence between textual and computational (static and dynamic) structure is extremely detrimental to the c l a r i t y of t h e p r o g r a m and m a k e s the task of
33
verification much more difficult. The Pascal program is o f t e n an i n d i c e t i o n not yet learned "to think" in P a s c a l
o g o t o s in a programmer has is a n e c e s s a r y
construct
in
other
programming
lenguages).
SCALAR
AND
5 SUBRANG~
TYPE~
A.
Scalar
types
data types in Pascal indicates an o r d e r e d set which denote the values. identifier> =
of
Their the
( <identifier>
{.
<identifier>}
) ;
color
sex = day = (mon,tues.wed,thur,fri,sat,sun); operators = (plus.minus,times,divide): illegal ~voe (for example: workday = (mon,tues,wed,thur,fri.sat): free = (sat,sun): the type of sat is ambiguous)
is
already
acquainted
with
the
standard
type
Boolean
Boolean
(false,
The relational operators on all scalar types types. The order is constants are listed. Standard functions e.g. with
=, <>, <, <=. >=, and >. are applicable provided both comparands are of the same determined by t h e s e q u e n c e in which the
arguments
of
types
are:
succ()
pred (x)
ord ( x )
The ordinal ord(pred(x)) +
number I.
constant
35
for
:= b l a c k
#ownto
red ~
sl
while
if
(cl<>c)
and b do
c
sl
c>white
then
:= p r e d ( c )
B.
Subrange
types
A t y p e may b e d e f i n e d as a a~bran~e of any other already defined scalar type--called its ~ss#_~iated ~calar ~voa. The definition o a subrange simply indicates the least and the largest constant value in the subrange, w h e r e t h e l o w e r b o u n d m u s t be less then the upper bound. A subrange of t h e t y p e r e a l in ~#_~ allowed.
i&t#_~ < t y p e identifier> = <constant> ., < c o n s t a n t > ;
Semantically, a subrange type is an appropriate substitution for the associated scclar type in all definitions. Furthermore. it is the associated scalar type which determines the validity of all operations involving values of subrange types. For example, given the declaration; vat a: 1..10; b: scalar 0..30; type c:20..30; for a. b, and e is integer. Hence the
:= b;
b:=
c;
are all valid statements, although their execution may sometimes be infeasible. The phrase "or s u b r a n g e thereof" is t h e r e f o r e assumed to be implied throughout t h i s t e x t a n d is not a l w a y s mentioned (as it is in t h e R e v i s e d Report.)
example : type days = (mon,tues ,wed,thur,fri,sat.sun): workd = mon..fri: {subrange of days} index = 0..63; {subrange of inteqer} letter = a .. z ; { s u b r a n g e of c h a r }
{scalar
type}
Subrange types provide the means for a more explanatory statement of the problem. To the implementor they also suggest an opportunity to conserve memory space and to introduce validity checks upon assignment at run-time. (For an example with subrange types, see program 6.3.)
STRUCTURED TYPES
IN
6 GN~NJ~_~AL--THE
Scaler and subrange types are unstructured types, The other types in Pascal are &~Wcture~ ~ v e e s . As s t r u c t u r e d statements were compositions of other statements, structured types are compositions of o t h e r t y p e s . It is t h e t y p e ( s ) of the ~ommo~nt& and--most importantly--the structuring method that characterize a structured type, An option available to e a c h of t h e s t r u c t u r i n g m e t h o d s is an indication of t h e p r e f e r r e d internal data representation. A type definition prefixed with the symbol ~_~ed signals the compiler to economize storage requirements, e v e n at the e x p e n s e of additional execution time and a possible expansion of t h e c o d e . due to the necessary packing and unpacking operations. It is t h e user's responsibility to realize if he wants t h i s t r a d e of efficiency for space, (The a c t u a l effects upon efficiency and savings in s t o r a g e space are implementation dependent, and may. in f a c t , be n i l . )
The array
type
An array t y p e c o n s i s t s of e f i x e d n u m b e r of c o m p o n e n t s (defined when the array is i n t r o d u c e d ) w h e r e a l l a r e of t h e s a m e t y p e , called the ~mooneOJ2 or ~se ~voe. Each component can be explicitly denoted and directly accessed by t h e n a m e of t h e array variable followed by the so-called io_~ex in square brackets. Indices are computable; t h e i r t y p e is c a l l e d t h e & B ~ . ~ , Furthermore, the time required to select (access) a component does not depend upon the value of the selector (index); hence the array is termed a _Qndom-~cces& &~uctur~. The the definition of an a r r a y specifies i n d e x t y p e . The g e n e r a l f o r m is: ~&e A = array[T1] o_f T2; is t h e i n d e x t y p e a n d is a and real are not allowable both the component type and
examples
of
variable
-and-
sample
assignments
37
smallest output);
number
in a g i v e n
list
minmax(input,
const n = 20; vat i.u .v.min.max : integer; a : arrav[1..n] of integer; beoin [ a s s u m e t h a t at t h i s p o i n t in t h e p r o g r a m , contains t h e v a l u e s : 35 6 8 94 7 88 -5 -3 - 6 3 0 -2 74 88 52 4 3 5 4} I] ; m a x := rain; i := 2; n do := a]~i] ; v := a [ i + 1 ] ; then beqin ~ u > m a x J.hen max := u ; i f v < m i n t h e n rain := v en_ d e l s e be_~i__nn ~ v>max then m a x : = v: if u < m i n t h e n rain := u en~ : i := i + 2 e_O~: if i = n t h e n i f a [ n ] >max ~Lh~o m a x :: a [ n ] _ei~_~ i ~ e [ n ] <~nin t h e n rain := a [ n ] ; writeIn(max,min) erld . rain := a[ while i < beoiQ u _if u > v
array a 12 3 5 9
94
-6
38
4.9
to
x-axls
d = 0.0625: { 1 / 1 6 , 16 l i n e s for interval s = 31; |31 character widths for interval maxl = 67; {max length of line} hl = 34; {character position of x-axls} c = 6.2U318; |2*pi} lim = 32; vat x.y : real, i.n : integer: a : ~rr~l~[O..maxl] of char" b@ain x := 0 ; f o r i := 0 t o m a x l d o a [ i ] := " ", j~ i := I t o l l m ~-G
beef in a[h] := : :
:= r o u n d ( s ' y )
+ hl;
+ d
39
(Consider how one would extend program 6.2 to print more one function--both w i t h a n d w i t h o u t t h e u s e of an a r r a y . )
than
Since T2 may be of a n y t y p e , structured. In particular, if original array A is said to declamation of a multidimentional vat and M [ i ] [j] then of M. denotes t h e jth component M : grrav[a..b]
of a r r e v [ c . . d ]
(of t y p e
T)
of
the
ith
component
it
is
customary
to
make
the
T;
as jth
a matrix column) of
and the
say ith
t h a t M [ i . j ] is t h e j t h component of M (of t h e
T h i s is not l i m i t e d to t w o d i m e n s i o n s , f o r T c a n a g a i n be structured t y p e . In g e n e r a l the (abbreviated) f o r m is: ~vo~ <type identifier> = &r_~2~&~[<index t y p e > [ , < i n d e x If O index o~dimensional, expressions . types and are a
type>}]
gL
<component
type>
specified, component
t o be index
40
{ program 6.3 matrix multiplication EroRr~j~ const vat i s a b c beain fan ~ matrixmul(input,
1 output):
m = 4; p : 3; n : 2; : 1.,m; j : 1..n; k : 1..p; : integer ; : arr_@~t[1..m/1..p] of integer; : ~r_~[1..p 1..n] o f i n t e g e r ; : ~rrav[1..m,1.,n] of integer; {assign ~nitial values t o a a n d b} i "= I t o m d o fan k := I t o p d o beoio read(s); write(s); e l i , k ] := s end : writeln end : writeln ; ~ k := 1 ~j& p ~ ~eoin f~L~ J := I o n d o bf,~ read(s): write(s); b [ k j ] := s end : writeln end : writ eln ; {multiply e * b} ? o r i := 1 k s m d a O~t~l f a n J := I t a n do b~_qUia s := O: f o r k := I t o p d o s := s + a [ i , k ] * b [ k j ] c[i~,O] := s ; w r i t e ( s ) and : writeln n___dd ; e writeln #_O_~
I -2 1 -I -I -2 2 I 6 I -9
2 0 0 2 3 2 I 10 -4 4 -2
3 2 I -3
~trinc&
were
defined
earlier
as
sequences
of
characters
enclosed
41
in single quote marks (chapter I). S t r i n g s c o n s i s t i n g of e single character are the c o n s t a n t s of t h e s t a n d a r d t y p e c h a r (chapter 2); those of n characters (n>l), are d e f i n e d as c o n s t a n t s of t h e t y p e d e f i n e d by: oacked ~r~[ 1..n] ~
char
Assignment
types. The
(:=)
is p o s s i b l e
between
operands
=, <>,
of ~ d e n t i c a l
<, <=,
array
relational
operators
and >= a r e
applicable on operends of identical packed character arrays, where the underlying character set determines the ordering,
Access to individual components of packed arrays is o f t e n c o s t l y , a n d t h e p r o g r a m m e r is a d v i s e d to p a c k or u n p a c k e p e e k e d array in e single operation. This is possible through the
standard procedures pack end unpack. Letting A be an a r r a y
variable
of t y p e o~ T of t y p e
~j~rey[m..n] and
Z be a v a r i a b l e Eacked
~rrav[u..v]
>=
~L T
where
(n-m)
(v-u), t h e n means ~ j := u ~ v do Z[J] := A[j--u+i] j := u ~ v ~ A[j--u+i] := Z[j] variable not occurring elsewhere in
p a e k (A ,i .Z ) and
u n p a c k ( Z ,A ,i )
where J denotes the p r o g r a m .
means
~or
an a u x i l i a r y
7 RE&gAE TYPES
The record types are perhaps the most flexible of data constructs. Conceptually, a record type is a template for a structure whose p a r t s may h a v e q u i t e distinct characteristics. For example, assume one wishes to record information about a person. Known are the name, the social security number, sex. date of birth, number of dependents, and marital status. Furthermore, if the person is married or widowed, the date of the (last) marriaqe is given; if divorced, one knows the date of the (most recent) divorce and whether this is the first divorce or not; and if single, given is whether an independent residency is established. All of this information can be expressed in a single "record". More formally, a record is a s t r u c t u r e consisting of a f i x e d number of components, celled field&. Unlike the array. components are not constrained to be of identical type and c a n n o t be d i r e c t l y indexed. A type definition specifies for e a c h component its t y p e a n d an i d e n t i f i e r , t h e 2ijild i # @ n t i f i e r , to denote it. The scope of a field identifier is t h e s m a l l e s t record in which it is defined. In o r d e r t h a t t h e t y p e o f a selected component be evident from the program text (without executing the program), the record selector consists of constant field identifiers rather than a computable value. To take a simple example, assume one wishes to compute with complex numbers of the form a+bi. where a and b are real numbers and i is the square root of - 1 . T h e m e i s no s t a n d a r d type "complex", However, the programmer can easily define a record type to represent complex numbers. This record would need two fields, both of type real. for the real and imaginary parts. The syntax necessary to express this is: <record type> ::= ~ e c o r ~ <field list> ~nd < f i e l d l i s t > ::= < f i x e d p a r t > I <fixed part> ; <variant part> <variant part> <fixed part> ::= < r e c o r d s e c t i o n > {; < r e c o r d s e c t i o n > } <record section> ::= < f i e l d identifier> { , <field identifier>} <type> I <empty>
rules,
one
can
state
the
following
definition
and
re.im
: real
of is
43
Likewise, date :
a variable ~ecord
representing
a date
can
be
defined
as:
mo:(jan.feb,mar,apr,may,june. july ,aug ,sept ,oct ,nov ,dec ) ; day: 1..31; year : integer
a toy toy
as : = ~ecord kind : (ball ,too ,boat ,doll ,blocks game , m o d e l , b o o k ) ; cost : real; received: date; enjoyed: (alot,some,alittle.none); b r o k e n ,lost : B o o l e a n
or
a homework assignment
assignment = ~eeord
as: subject
end
To reference a record component, the followed by a point, and the respective example, the following assigns 5+3i to x: x,re :: 5; x.im :: 3
is For
If the record is itself nested within another structure, the naming of the record variable reflects this structure. For example, assume one wishes to record the most recent small pox vaccination for each member in t h e f a m i l y . A p o s s i b i l i t y is t o define the m e m b e r s as a s c a l a r , a n d t h e n t h e d a t e s in an a r r a y of r e c o r d s : family= ~L~d~ v a c c i n e : (father,mother.childl,child2,child3); g~[family] L date:
An u p d a t e
might
then
be recorded
as:
.mo := a p r ; .day := 23; .year := 1 9 7 3 also i~icludes, for instance, e 31st April.
"date"
44
program operations
7.1 on
complex
numbers
&re,ram
complex
(output);
const fac = 4; tree complex = record re.im vat x,y : complex; n : integer ; be~in x.re := 2; x .Ira := 7; y.re := 6 ; y.im : = 3; for n := 1 &o 4 d~
integer
end;
writeln("
",x.re:3,x.im:3,
= ",x.re x .im
'
".y.re:3,y.im:3);
{x
+ y}
sum + y.re:3, + y.im:3);
writeln(
{x
* y}
(" p r o d u c t = ",x . r e * y . r e x.re*y.im x .im := x . i m - x . i m * y .ira:3, + x.im*y.re:3); - fac;
writeln
+ fac;
y 36
= 24
x = 14 - 5 y = sum = 20 -2 product = 9 9 12
The syntax for a record type also makes provisions for a ~arisnt ~art. implying that a record type may be specified as consisting of several ~#j~_~. This means that different variables. although said to be of the same type. may assume structures which differ in a certain manner. The differences may consist of a different number and different types of components. Each variant is charaeterised by a list. in parentheses, of declarations of its pertinent comoonents. Each l i s t is l a b e l l e d by one or more l a b e l s ~ , a n d t h e s e t o f l i s t s is p r e c e d e d by a case clause specifying the data type of these labels (i.e. the
45
to w h i c h t h e the existence =
variants of a
are
discriminated).
As
an
(married. by
widowed, data
divorced,
sinRle)
persons
of t h e
t~De
person = ~ecord <attributes or fields common to all persons> #ase maritalstatus ~ married: ( < f i e l d s of m a r r i e d p e r s o n s o n l y > ) ; single: ( < f i e l d s of s i n g l e p e r s o n s o n l y > ) ;
end
Usually, currently r e c o r d is ms
This frequent situation can be abbreviated by declaration of the discriminating component--the f i e l d - - i n t h e c a s e c l a u s e i t s e l f , i.e. by w r i t i n g case ms: maritalstatus aL
The s y n t a x <variant
defining
the
variant
part
is: DJE
: := c a s e < t a g f i e l d > < t y p e i d e n t i f i e r > <variant> { ; <variant>} <variant> ::= <case l a b e l l l s t > : ( < f i e l d l i s t > ) I <emp t y > <case l a b e l l i s t > : : = <case l a b e l > { , <case l a b e l > } <ease l a b e l > : : = <unsigned c o n s t a n t > <tag f i e l d > ::= <identifier> : I <empty>
Dart>
It is before
helpful defining
to "outline" it as a v a r i a n t
a person.
I , Person A. n a m e (last, f i r s t ) B, s o c i a l s e c u r i t y n u m b e r ( i n t e g e r ) C . s e x (male, f e m a l e ) D. d a t e of b i r t h ( m o n t h , day. y e a r ) E . n u m b e r of d e p e n d e n t s (integer) F. marital status if m a r r i e d , w i d o w e d a. d a t e of m a r r i a g e (month. day, year) if d i v o r c e d a. d a t e of d i v o r c e (month. day, year) b. f i r s t d i v o r c e (false, true) if s i n g I e a. i n d e p e n d e n t r e s i d e n c y (false,true)
46
is
a corresponding attributes.
picture
of
two
"sample"
people
woodyard edward
i i lliH
A) B)
iiiiii i
845680539
male
c)
~ug i
t
30
1
i1941
H,,,,, ,,
D)
E) F)
single
true Figure 7.a
Two
sample
people
A record ~ype
defining
"person"
can
now
be
formulated
as:
alfa = ~acked ~r_~,~[1..lO] ~L char; status = (married,widowed,divorced,single); date = ~eeord mo : ( J a n . f e b . m a r , a p r , m a y , j u n , july.aug.sept.oet,nov,dec); day : I..31;
person
first.last:
alfa
ss : i n t e g e r ; sex : (male ,female): birth : date; depdts : integer; c a s e ms : s t a t u s ~ married~widowed : (mdete: date); divorced : (ddate: date; firstd: Boolean); single : (indepdt : Boolean)
end;
{person}
I. A l l field names must be distlnct--even if t h e y o c c u r in different variants. 2. If t h e f i e l d l i s t f o r a l a b e l L is e m p t y , t h e f o r m is: L : () 3. A field list can have only one variant p e r t a n d it m u s t succeed the fixed pert(s). (However, a variant part may itself contain variants. H e n c e , it is p o s s i b l e to h a v e n e s t e d variants.)
47
Referencing a record component is e s s e n t i a l l y a simple linear reconstruction of the outline. As e x a m p l e , assume a variable p of t y p e p e r s o n a n d " c r e a t e " t h e f i r s t of t h e m o d e l p e o p l e . p.name.last := " w o o d y a r d p.name.first := " e d w a r d p.ss := 8 4 5 6 8 0 5 3 9 ; p .sex := m a l e : p.birth.mo := a u g : p.birth.day := 30; p .birth.year := 1941;
p.depdts : = 1; p .ms := s i n g l e ;
p.indepdt
:= t r u e
A.
The
with
statement
The above n o t a t i o n can be a b i t t e d i o u s , and the user may wish to abbreviate it using the ~ith ~tatement. The with clause effectively opens the scope containing the field identifiers of the specified record variable, so that the field identifiers may o c c u r as v a r i a b l e identifiers. ( T h e r e b y p r o v i d i n g an o p p o r t u n i t y for the compiler to optimize the qualified statement.) The general f o r m is: ~tik__h < r e c o r d variable> {. <record variable>} do <statement>
Within the component s t a t e m e n t of t h e w i t h s t a t e m e n t one denotes a field of a record variable by d e s i g n a t i n g o n l y its f i e l d identifier (without preceding it w i t h t h e n o t a t i o n of t h e e n t i r e record variable). The with statement of a s s i g n m e n t s : below is equivalent to the preceding series
~ith p.name.birth ~L~ ~J~l l a s t := " w o o d y a r d "; first := " e d w a r d "; ss := 8 4 5 6 8 0 5 3 9 ; s e x := m a l e ; mo := a u g ; d a y := 30; year := 1941; depdts := I; ms := s i n g l e ; indepdt := t r u e end {with}
48
: date:
_with c u r r e n t d a t e do i ~ too=dec t h e n b e u i n mo := j a n :
year
:= y e a r + 1
en~ ~ I s e mo
is equivalent var to
:= s u c c ( m o )
currentdate if
: date;
grid
else And the earlier : currentdate.mo following := s u c c ( c u r r e n t d a t e . m o ) the vaccine update exampled
accomplishes
with vaccine[child3] b e Q i ~ mo := a p t :
d~ day
:= 23:
year
:=
1973
grid
to
any
contain
any
variables
subject
to
change
by
S;
for
with a[i] dn b_eoin ... i := i+1 end is _nw~ a l l o w e d . The form : w_ith r I, r 2 . . . . . . is equivalent k i t h r I do ~ith r 2 w~h rn do S to r n do S
49
Whereas :
yam a a : array[2..8] : 2..8; for the of integer:
is
NOT y_~
allowed, a b
definition
of
a is
ambiguous,
b : Boolean
IS
allowed,
notation
for
the
integer
is
easily
distinguishable
variable b Furthermore,
from
the
real
"'b.a '.
Likewise.
the S of
the
Boolean
record
"b.b*
wi~h b ~ g S
both "b" and "b.b" reference the Boolean "b.b",
A s e t t y p e d e f i n e s t h e s e t of v a l u e s t h a t is t h e p o w e r s e t of its base type, i.e. t h e s e t of a l l s u b s e t s of values of t h e b a s e type. including t h e e m p t y s e t . T h e b a s e t y p e m u s t be s s c a l a r or subrange type. ~y_#_~ < i d e n t i f i e r > = &~,JL ~L~ < b a s e type>;
The base type of a set must be e implementations of Pascal may define sets, which can be quite small (e.g. the
Sets are built up from their elements by s e t c o n s t r u c t o r s (denoted by <set> in the syntax). They consist of the enumeration of the set elements, i . e . of e x p r e s s i o n s of t h e b a s e type. which are separated by c o m m a s a n d e n c l o s e d by s e t b r a c k e t s [ and ] . Accordingly. [] d e n o t e s the empty set, <set> ::= [ < e l e m e n t llst> ] <element l i s t > ::= < e l e m e n t > {, < e l e m e n t > } <element> ::= < e x p r e s s i o n > I <expression> The form m..n denotes the set of all elements s u c h t h a t m < = i < = n . If m > n , [ m . . n ] d e n o t e s the Examples
of
set
constructors
"0"..'9"]
operators are applicable on all objects with set
of
all
elements
Relational
= <>
operators
applicable
to
set
operands
are:
t e s t on ( i n ) e q u a l i t y t e s t on s e t i n c l u s i o n set membership. The first operand is a s c a l a r t y p e , the s e c o n d is of its a s s o c i a t e d set type; the result is true w h e n t h e f i r s t is an e l e m e n t of the second. otherwise false.
51
of
declarations
~8_~ ~ Z
"a'..'z';
:= := :=
Set more
operations are relatively fast and can complicated tests. A simpler test for:
be u s e d
to
eliminate
~d~ ( c h = ' a ' ) o n ( e h = b ' ) o ~ ( e h = ' c ' ) o ~ ( c h = ' d ) g ~ ( c h = ' z is : i_f ch i n [ "a..'d ,'z "] &hen s
")
~hen
8.1 of set
operations )
setop(output
d a y s = (m , t ,w , t h . f r , s a , s u ) ; w e e k = se__t_t o f d a y s ; varr wk,work,free : week; d : days ; ~roce~w~ check(s : week): {procedures introduced ~ d : days; ~eoin write(" "); f o ~ d := m & ~ su ~ i ~ d i ~ s & h e n w r i t e ( x ") ~ I s e w r i t e ( ' o ' ) ; writeln end; { c h e c k } beoin w o r k := [] ; f r e e := [] ; wk := [ m . . s u ] : d := sa; f r e e := [d] + f r e e +[su] ; check (free) ; w o r k := w k - f r e e ; check(work); /j[ f r e e <= w k t h e n w r i t e ( ' o ) 7 ~/[ w k >= w o r k t h e n w r i t e ( ' k ' ) ; i f D o t (work >= f r e e ) the[l w r i t e ( " j a c k ): i ~ [sa] <= w o r k ~ h e n w r i t e ( ' forget it'); writeln end. in chapter 11}
O0000XX xxxxxoe ok j a c k
52
On
program
development
Prooramming--in the sense of designing and formulating algorithms--is in general a complicated process requiring the mastery of numerous details and specific techniques. O n l y in exceptional c a s e s w i l l t h e r e be a s i n g l e good solution. Usually, so many solutions e x i s t t h a t t h e c h o i c e of an o p t i m a l p r o g r a m requires a thorough analysis not only of the available algorithms and computers but also of the w a y in w h i c h t h e program w i l l m o s t f r e q u e n t l y be u s e d . Consequently, the construction of an a l g o r i t h m should c o n s i s t of a sequence of deliberations, investigations, and design decisions. In the early stages, attention is b e s t c o n c e n t r a t e d on the global problems, and the first draft of a solution may pay little attention to details. As the design process progresses, the problem can be split into subproblems, and gradually more consideration given to the details of p r o b l e m smecification a n d to t h e c h a r a c t e r i s t i c s of the availmb~e tools. The terms ~ i s e ~efin_~ment [2] a n d ~ f ~ ~ m m i n ~ [4] are associated with this approach. The remainder of t h i s c h a p t e r illustrates the development of an algorithm by rewording (to be c o n s i s t e n t with Pascal notation) an example C .A.R. Hoare presents in ~ r u ~ ~rog_r_~in~ [4."Notes on O a t a S t r u c t u r i n g " ] . The assignment is to g e n e r a t e the prime numbers range 2..n, where n>=2. After a comparison algorithms, t h a t of E r a t o a t h e n e s " s i e v e is c h o s e n simplicity (no m u l t i p l i c a t i o n s or d i v i s i o n s ) . The first I. 2. 3. 4. 5. formulation is verbal. between 2 and the smallest in t h e sieve, empty, n into number t h e "'s~eve" r e m a i n i n o in f a l l i n g in t h e of t h e v a r i o u s b e c a u s e of i t s
Put a l l t h e n u m b e r s Select and remove sieve. Include this number Step through the number. I f t h e s i e v e is not
the
all steps
multiples 2--5.
of
this
Although initialization of variables is t h e f i r s t s t e m in t h e execution of a p r o g r a m , it is o f t e n t h e l a s t in t h e d e v e l o p m e n t process. Full comprehension of t h e a l g o r i t h m is a p r e r e q u i s i t e for making the proper initializations; updating of these initializations with each program modification is n e c e s s a r y t o keep the program runnino. (Unfortunately. u p d a t i n g is not a l w a y s sufficient!) Hoare chooses a set t y p e w i t h e l e m e n t s 2 , . n to r e p r e s e n t both the sieve and the primes. The following is a s l i g h t variation of the program s k e t c h he p r e s e n t s .
53
of
2..n;
{ initialize} sieve := [2..n] : p r i m e s := [] : n e x t := 2; ~eoeat {find next prime} while Dot(next i n s i e v e ) do n e x t := s u c c ( n e x t ) : primes := p r i m e s + [next] : j := n e x t ; ~hile j < = n d~l { e l i m i n a t e } b e o i n s i e v e := s i e v e - [j] ; j := J + n e x t
and
until sieve=[]
As an exercise Hoare makes the assignment to rewrite the program, so that the sets only represent the odd numbers. The following is one proposal. Note the close correlation with the first solution.
cons~
n di~A 2} o~ 2..n; ;
DJ&W~LJ3 { i n i t i a l i z e } sieve := [2..n] : p r i m e s := [] ; n e x t r_em~at { f i n d n e x t p r i m e } ~ h i l e DD_t(next in s i e v e ) do next primes := p r i m e s + [next] ; c := 2 * n e x t - I; {c = n e w p r i m e } j := n e x t ; mile j < = n ~LQ { e l i m i n a t e } ~eoin s i e v e := s i e v e - [J] ; j
:= 2: := s u c c ( n e x t ) ;
:=
j+c
and
unt$~
end .
sieve=[]
It is desirable that all basic set operations ere relatively fast. Many implementations restrict the maximum size of s e t s according to their " w o r d l e n g t h ~. so t h a t e a c h e l e m e n t of t h e b a s e s e t is r e p r e s e n t e d b y o n e b i t (0 m e a n i n g absence, I meaning presence). Most implementations would therefore not accept a set with 1Oo000 elements. These considerations lead to an adjustment in t h e d a t a r e p r e s e n t a t i o n , as s h o w n in p r o g r a m U.2.
A large set can be represented as an array of smaller sets such that each "fits" into one word (implementation dependent). The following program uses the second sketch as an abstract model of the algorithm. The sieve and the primes are redefined as arrays
is
defined
as
record.
The
output
is
left
54
{ program 8.2 generate the primes between 3..I0000 using a sieve containing o d d i n t e g e r s in t h i s r a n g e . } oroQram const primes (output);
wdlenoth = 59; { i m p l e m e n t a t i o n dependent} m a x b i t = 58; w = 634; {w : n div w d l e n g t h div 2} sieve ,primes : ~rrav[O..w] ~J~ : e t ~ f O . . m a x b i t ; next : rec0rd word,bit :inteoer end ; j , k . t ,e : i n t e g e r ; empty : boolean; beoin {initialize}
ZDJZ t :-- 0 ~j~ w do
s i e v e [ t ] := [ O . o m a x b i t ] ; p r i m e s [ t ] := := s i e v e [ O ] - [0] ; n e x t . w o r d := O; := I; e m p t y := f a l s e ;
[] e n d ;
~ h next do r_~3J~ { find next prime } ~h~ n o t ( b i t in s i e v e [ w o r d ] ) d o bit := s u c e ( b i t ) ; primes[word] := p r i m e s [ w o r d ] + [bit] ; c := 2 * b i t + 1; j := b i t ; k := w o r d ; ~b.ile k < = w do { e l i m i n a t e } b~liil s i e v e [ k ] := s i e v e [ k ] - [j] ; k := k + w o r d * 2 ; j := j + c: while j>maxbit do begin k := k + 1 ; j := J - w d l e n g t h end end ; if sieve[word]=[] then be__qin e m p t y := t r u e ; bit := 0 --end ; while empty ~ (word<w) d~ _b-e.q~ w o r d := w o r d + l ; e m p t y := s i e v e [ w o r d ] = [ ]
and
up~il and. empty ; {ends with}
EZLE T~_EE~
In m a n y w a y s t h e s i m p l e s t s t r u c t u r i n g m e t h o d is t h e s e q u e n c e , In the data processing profession the generally a c c e p t e d t e r m to d e s c r i b e a s e q u e n c e is a ~_~ouential ~ i l e . P a s c a l u s e s s i m p l y t h e word LJ,~J: to specify a structure c o n s i s t i n g of a s e q u e n c e of components--all of w h i c h a r e of t h e s a m e t y p e . A natural ordering of the components is d e f i n e d t h r o u g h t h e sequence, and at any i n s t a n c e o n l y one c o m p o n e n t is d i r e c t l y accessible. The other components are a c c e s s i b l e by p r o g r e s s i n g sequentially t h r o u g h t h e f i l e . T h e n u m b e r of c o m p o n e n t s , called the I en at~h of the file, is not fixed by the file type definition, T h i s is a c h a r a c t e r i s t i c which clearly distinguishes t h e f i l e f r o m t h e a r r a y . A f i l e w i t h no c o m p o n e n t s is s a i d to be _em_~. type <identifier> : ~i1~ ~ <type>;
The declaration of every file variable f automatically introduces a buffer wariablg, d e n o t e d by ft, of t h e c o m p o n e n t type. It can be considered as a ~ i n d o w t h r o u g h w h i c h o n e c a n either inspect (read) e x i s t i n g c o m p o n e n t s or a p p e n d (write) n e w components, and which is automatically m o v e d by c e r t a i n f i l e operators. The s e q u e n t i a l p r o c e s s i n g a n d t h e e x i s t e n c e of a b u f f e r v a r i a b l e suggest t h a t f i l e s may be a s s o c i a t e d with ~condarv ~to=a~e and ~erioheral~. Exactly how the components are allocated is implementation dependent, but w e a s s u m e t h a t o n l y s o m e of t h e components are present in p r i m a r y s t o r e at a n y o n e t i m e , a n d only the component i n d i c a t e d by ft is d i r e c t l y a c c e s s i b l e . When the standard otherwise window ft is moved beyond the gnd gf Boolean function eof(f) returns the f a l s e . The b a s i c f i l e - h a n d l i n g operators a ~ile value are: f, t h e true,
r e s e t (f)
resets the f i l e w i n d o w to t h e b e g i n n i n g for t h e purpose of r e a d i n G , i.e. a s s i g n s to ft t h e v a l u e of the f i r s t e l e m e n t of f. e o f ( f ) b e c o m e s f a l s e if f is not e m p t y ; o t h e r w i s e , ft is not d e f i n e d , and eof(f) remains true. precedes the rewriting of t h e f i l e f. The c u r r e n t value of f is replaced with the empty file. eof(f) becomes true, and a new file may be written. advances the file window to the next component; i.e. assigns t h e v a l u e of t h i s c o m p o n e n t to t h e buffer variable ft . If no n e x t c o m p o n e n t e x i s t s , then eof(f) becomes true. and the resulting value of ft is not d e f i n e d . T h e e f f e c t of g e t ( f ) is
r e w r i t e (f)
get(f)
56
defined execution.
only
if
eof(f)
is
false
prior
t o its
put(f)
appends the value of the buffer v a r i a b l e ft t o the file f. T h e e f f e c t is d e f i n e d o n l y if p r i o r to execution the predicate e o f ( f ) is t r u e . e o f ( f ) remains t r u e , a n d ft b e c o m e s undefined,
examples
of
declarations
-and-
statements
with );
files
Program
I. R e e d
parts
a file
en_g
2, The following program fragment operates ordered sequences of i n t e g e r s fl,f2 ..... fm end g l g2 . . . . . gn on two files of
s u c h t h a t f ( i + 1 ) >= fi and g ( i + 1 ) >= gi, f o r a l l a n d _merges t h e m i n t o o n e o r d e r e d file h such that h(k+1) >= h ( k ) f o r k = 1,2 . . . . . (re+n-l). It uses the following variables: endfg : Boolean; fog,h : ~ile ~ integer
i.j
57
bea~3 reset(f): reset(g); rewrite(h); endfg := s o l ( f ) or eof(g); ~hile D o t e n d f g do b w ~ i n i f ft <gt t h e n benin ht := ft ; g e t ( f ) ; endfg := e o f ( f ) #J3~ e l s e b e n i n ht := gt ; g e t (g); e n d f g := e o f ( g ) end ; out(h) -eng ;
while basin get end : while beqin get not ht (g)
eof(g) do := g t ; p u t ( h ) ;
not ht (f)
eof(f) do := f t ; p u t ( h ) ;
_end
--end
Files may be local to a p r o g r a m (or l o c a l t o a p r o c e d u r e ) or they may already exist outside the program. The latter are called e~ternal ~les. External files e r e p a s s e d as p a r a m e t e r s in the program heading (see chapter 13) i n t o the program.
A.
Textfiles
Texts are usually subdivided into l ~ . A straight-forward method of indicating the separation of two consecutive lines is by using control characters. For instance, in the ASCII character set the two characters ~ (carriage return) and l~ (line feed) are used to mark the end of a line. H o w e v e r . many computer installations use a character set devoid of such control characters; this implies that other methods for indicating t h e end o f a l i n e m u s t be e m p l o y e d .
We may consider the t y p e t e x t as b e i n g defined over the base type char (containing printable characters only) e x t e n d e d by a (hypothetical) line separator character. This control character cannot be assigned to v a r i a b l e s of t y p e c h a r , b u t c a n be b o t h
58
recognized operators:
and
generated
by
the
following
special
textfile
writeln(x) readln(x)
terminate
the
current
l i n e of
the
x of of the the
skip to the beginning of the textfile x (xt b e c o m e s the first next line)
eoln(x)
a Boolean function indicating w h e t h e r t h e e n d of the current line in the textfile x has b e e n reached. (If t r u e . xt c o r r e s p o n d s to the position of a line separator, b u t xt is a b l a n k . )
If f is abbreviated operators
a textfile notation
abbreviated
form
expanded
form
write read
(f .eh ) (f .ch )
ft ch
:= ch; :=
p u t (f)
ft : g e t (f)
schemata operations
to
Writing a text y. Assume that P(c) computes a (next) character and assigns it t o p a r a m e t e r c. I f t h e c u r r e n t line is to be terminated, a Boolean variable p is s e t to t r u e ; a n d if t h e t e x t is t o be t e r m i n a t e d , q is s e t t o t r u e .
rewrite(y);
~eeeat eo eat P(c); wntil p ; wr it e l n (y) until q w r i t e (y~.'h)
2.
Reading a text x. Assume that Q(c) denotes the processing of a (next) character c. R denotes an action to be executed upon encountering the end of a line. r e s e t (x) ; while opt eof(x) do be~in wb_~ ~ eoln(x) do b#_q/J3 r e a d (x .'c ) ; Q ( c ) end ; R ; readln(x) ~nd
59
3.
Copying a text s t r u c t u r e of x.
to
a text
y, w h i l e
preserving
the
line
reset(x); rewrite(y); w h i l e #3&J2 e o f ( x ) d o b e q i n {copy a line} while not eoln(x) do beain read(x,c); write(y,c) end ; readln(x); writeln(y) end
B . The s t a n d a r d
files
"input"
and
"output"
The textfiles "input" and "output" usually represent the standard I/O media of a computer installation (such as the card reader and the line printer). Hence, they are the principal communication line between the computer and its human user.
Because these two files are used very frequently, considered as "default v a l u e s " in t e x t f i l e o p e r a t i o n s t e x t f i l e f is not e x p l i c i t e l y i n d i c a t e d . That is is e q u i v a l e n t to
they when
are the
write(ch) read(ch)
write
(output
,eh)
read (input,ch)
~se&
(rewrite)
must
not
be a p p l i e d
Accordingly, for the case where x the first two of the program follows: (assume ~ar sh: char) Writing a text on file "output";
is "input" schemata
and y can be
is "output" expressed as
60
Reading
a text
from
file
"input":
wh~ no#- e o f d o b~,q~& { p r o c e s s a line} w h i l no#_ e o l n d o beain read(ch); Q (oh) ond ; R ; readln end
write and
the are
The next two examples of programs show the use of the textfiles input and output, (Consider what changes would be necessary if only get and put not read and write are to be used.)
9.1 fcount
--
frequency
count
of
letters
in
input
file
(input .output);
ch: char ; count : ~r_~av[ "a'..'z "] of integer: letter : set of "a'..z'; beRin letter : = [ a . . ' z ' ] ; f o e c h : = "a J& "z d o c o u n t [ c h ] := wh~ not eof do D#qia ~hile no& eoln do b~g~3 read (ch) : write(ch) ; if ch &n letter J2h.J3 c o u n t [ c h ] end ; wrtteln; readln
O;
:=
count[ch]+l
e~
end.
In some installations when a textfile is s e n t t o a o r i n t e r , the first character of each line is used as a p r i n t e r control character; i.e. this first character is n o t o r i n t e o , but i n s t e a d interpreted as controlling the paper feed m e c h a n i s m of t h e printer. The following conventions a r e in w i d e u s e : blank
r I "
: : :
feed one llne space before printing feed double space before printing s k i p to t o p of n e x t p a g e b e f o r e printing no l i n e f e e d ( o v e r p r i n t )
61
of
each
{ program oroeram
9.2
--insert
leading
blank }
vat ch: char; begin @D~i~J& D o t e o f d o beoin write(" '); ~h~le n o t e o l n do be~in r e a d (ch) : w r i t e ( c h ) eoj~ ; wrlteln ; readln end .
If read and write are used without indication of a file parameter, the default convention specifies that the files input and output are assumed: in w h i c h e a s e , t h e y m u s ~ be m e n t i o n e d in the Paramenter l i s t of t h e p r o g r a m heading.
10
POINTER ~YPES
A ~ _ ~ ~#riable (staticly allocated) is o n e t h a t is d e c l a r e d in a program and subsequently d e n o t e d by its i d e n t i f i e r . It is called static, for it e x i s t s ( i . e . m e m o r y is a l l o c a t e d for it) during the entire execution of the block to which it is l o c a l . A variable may, on the other hand, be generated dynamically (without any correlation to the static structure of the program) by the procedure new. Such a variable is c o n s e q u e n t l y called a
Dynamic variables do not occur in an explicit variable declaration and cannot be r e f e r e n c e d d i r e c t l y by i d e n t i f i e r s . Instead, generation of a dynamic variable introduces a ~oi~_E~ Value (which is nothing other than the storage a d d r e s s of t h e newly allocated variable). Hence, a pointer t y m e P c o n s i s t s of an unbounded s e t of v a l u e s pointing to elements of a given type T. P is t h e n s a i d to be b o u n d to T . T h e v a l u e n i l is a l w a y s an element o f P a n d p o i n t s t o no e l e m e n t at a l l , tvo~
If p is reference
<identifier>
a to pointer variable
= ~
<type
identifier>;
bound T, and to a type denotes T. then p is a that variable.
variable of type
pf
Pointers are a simple tool for the construction of complicated and flexible data structures. If the type T is a record structure that contains one or more fields of type fT. then structures equivalent to arbitrary finite graphs m a y be b u i l t . where the T's represent the nodes, and the pointers are the edges. As an example, consider the construction of a "data bank""for a given ~roup of people. Assume the persons are represented by records as defined in chapter 7. One may then form a chain or linked list of such records by adding a field of a pointer type as shown below.
link person
= fperson; = ~ecord
. . ,
next ~nd:
: link:
linked
list
of
n persons
can
be
represented
as
in
figure
10.a.
63
A variable element of
first
If we assume that the file numbers, then the following construct the above chain.
Va~, f i r s t ,
security used to
p : link; := n i l :
i:
integer;
first
for_ i
:=
I ~o
n do
For purposes of access, ene intreduces anether variable, say pt. of type l i n k a n d a l l o w s it t o m o v e f r e e l y through t h e l i s t . To demenstrate selection, assume t h e r e is a person with social security number equal to n and access this person. Th e s t r a t e g y is te advance pt via link until the desired member is located: pt := ~j~le first; ptt.ss
<>
n do
pt
:= p t t . n e x t
In words this s a y s , "'Let pt p o i n t t o t h e f i r s t element. While the social security number of the member pointed to (referenced) by pt d o e s n e t e q u a l n, a d v a n c e pt to t h e v a r i a b l e i n d i c a t e d by the link (also a pointer variable) of the record w h i c h pt currently references." N o t e in p a s s i n g that f i r s t t .nextt .next accesses the third person. Note that this simple search statement works o n l y ,if o n e is s u r e t h a t t h e r e is at l e a s t o n e p e r s o n with security n u m b e r n on the list. But is this realistic? A check against failing te recognize t h e e n d of t h e l l s t is t h e r e f o r e mandatory. One might first try the following solution: pt := f i r s t ; wh~l& (pt <> But recall referenced
nil)
and
(ptt .ss
<>
n) d O
pt
:= p t t .next
section in the
4.A. second
If pt factor
64
does which
are
two
possible
solutions
(1)
~hile
and
b ~
:= f a l s e else pt := p t t .next
= n &h#~3 b
(2)
goto
13;
end
To p o s e a n o t h e r problem, say one wishes to add the sample to the bank. First a s p a c e i n memory m u s t be a l l o c a t e d , reference created by m e a n s o f t h e s t a n d a r d procedure Dew. new ( p ) person and a
allocates a new variable v and assigns the pointer reference of v to the pointer v a r i a b l e p. If t h e t y p e of v is e record type with variants, then new(p) allocates enough storage to accommodate all variants. The form tn) can be used to a l l o c a t e a variable of the appropriate size for the variant with tag field values e q u a l to the constants t 1...tn. The tag field values must be listed contiguously a n d in t h e order of their declaration. Any trailing t a g f i e l d s m a y be o m i t t e d . T h i s ~W~,~& ~ o t imply assignment to the tag fields.
n e w ( p ot 1 . . . . .
if a record variable pt is c r e a t e d by t h e s e c o n d f o r m then this variable m u s t not c h a n g e its v a r i a n t during execution. Assignment to the e n t i r e v a r i a b l e is n o t however one can assign to the components of pf.
I f n e w p is a v a r i a b l e o f t y p e l i n k (as d e f i n e d above), new(newp) creates a new variable of t y p e p e r s o n e n d a s s i g n s the reference to newp. The value of the new variable is u n d e f i n e d upon allocation. A c c e s s is v i a t h e p o i n t e r . examples: newp~ . s s newpf := := paul 845680539 assignes assigns a social the record security paul to number newpf
~isoose
is
the
"inverse"
of
i1~
and
may h a v e
65
d l s p o s e ( p ,t I .... in) relative pointed by p. to which form of new was u s e d to c r e a t e the v a r i a b l e to by p. D i s p o s e t h e n " e r a s e s " t h e v a r i a b l e r e f e r e n c e d
newp
Figure
10.b
Before
Insertion
is a s i m p l e
matter
of
changing
the
pointers:
newpt .next
pt~ .next ::
:= p i t . n e x t :
newp
Figure
10.e
illustrates
the
result.
newp ~ I p n e e w #
Figure
I0.c
After
66
the member in t h e s i n g l e
auxiliary
pointer
pt
is
:= p t t . n e x t t . n e x t
p It ,next
: = p2t . n e x t
manner (free) w i l l . in store. A
p l t . n e x t := p 2 t . n e x t ; d i s p o s e (p 2 )
This provides the implementor with the opportunity to m a r k t h e store defining the variable referenced by p 2 as f r e e . What a c t u a l l y is done may g r e a t l y v a r y a m o n g i n s t a l l a t i o n s ; elaborate "garbage collections" may be implemented, or the dispose
instruction
may s i m p l y
be i g n o r e d .
Li_~ ~liQcation is the most efficient representation for inserting and deleting e l e m e n t s . A r r a y s r e q u i r e s h i f t i n g down (up) of e v e r y e l e m e n t b e l o w t h e i n d e x in t h e c a s e of i n s e r t i o n (deletion). and files require complete rewriting. For an example involving a tree l i s t . r e f e r to c h a p t e r 11 ( p r o g r a m structure 11.5). instead of a linear
A word
to
the
wise
Pascal provides a w i d e v a r i e t y of date s t r u c t u r e s . It is left to the programmer to e v a l u a t e his p r o b l e m in d e t a i l s u f f i c i e n t to d e t e r m i n e t h e s t r u c t u r e b e s t s u i t e d to e x p r e s s t h e s i t u a t i o n and to evaluate the algorithm. As indicated by t h e "data b a n k " example, linked allocation is e s p e c i a l l y n i c e for i n s e r t i o n a n d d e l e t i o n . If. h o w e v e r , t h e s e o p e r a t i o n s h a p p e n i n f r e q u e n t l y , but instead efficient a c c e s s is m a n d a t o r y , t h e n t h e r e p r e s e n t a t i o n of t h e data as an a r r a y of r e c o r d s is u s u a l l y m o r e a p p r o p r i a t e .
PROCE~RUS
11 AND f U N C T I O N S
As one grows in the art of computer programming, one constructs programs in a sequence of refinement ~tes&o At each step the Programmer breaks his task into a number of subtaskso thereby defining a number of partial programs. Although it is possible to camouflage this structure, this is undesirable. The concegt of the ~K~_~edure (or &wbroutine) allows the display o the subtasks as explicit subprograms.
A,
Procedures
The &roce~ur~ ~eclaration s e r v e s to d e f i n e a p r o g r a m p a r t a n d to associate it w i t h an i d e n t i f i e r , s o t h a t it c a n b e a c t i v a t e d by a orocedu~A statement. T h e d e c l a r a t i o n h a s t h e s a m e f o r m as a program, e x c e p t it is i n t r o d u c e d by a & r _ ~ z e d u r e b e a d i D _ q i n s t e a d of a p r o g r a m heading. Recall the program part that found the minimum and maximum values in a list of integers. As an extension, say that increments of j 1 . . j n a r e a d d e d t o a[ I] . . . a [ n ] , t h e n m i n a n d m a x are again computed. The resulting program, which employs a Procedure to d e t e r m i n e min and max, follows.
68
6.1
minmax2(input.output);
c o n s t n = 20; vat a : ~rrav[1..n] ~j[ i n t e g e r ; i,j : i n t e g e r ; ~rocedure minmax; va~ i :1..n; u,v,min.max :integer; ~e~in rain := a[ I] : m a x := rain; i := 2; wh i ] . ~ i<n d o bagin u := a[i] : v := a l l + l ] ; if u>v ~h~n b~aio i f u > m a x th~d3 m a x := u ; i f v < m i n t h e n rain := v e~l~ @ l s e h ~ ~ v > m a X t/3F,/1 m a x := v; ~C[ u < m i n tll@Xl rain := u and : i :: i + 2 and ; i f i=n theo i f a [ n ] >max t h e n m a x := a [ n ] e l s e i f a[n] <rain /2hen rain := a [ n ] ; w r i t e l n (min ,max) ; w r i t e l n end: {minmax} begin
for
{read
i :=
array}
I ~a n do
be~i__~n r e a d ( a [ i ] )" w r i t e ( a [ i ] :3) e~u3 : writeln ; minmax , f o r i := I t o n do bw_~in r e a d ( j ) ; a [ i ] := a[i] +j" write(a[i] eo_~ : wrlteln ; minmax an~.
:3)
-1
-3
4 -6
8 54 23 - 5 79 9 88 15 - 4 88
9 -6
45
79
79
44 40
7 15 -7
7 43
12
17 - 7
48
59
39
7 12
Although I.
simple, The
this
program
illustrates PROCEDURE
many
points: namely:
simplest ~rocedure
form of the
HEADING,
<identifier>:
69
2.
to procedure minmax are the a n d m a x . T h e s e m a y be r e f e r e n c e d of minmax; assignments to these on t h e p r o g r a m outside the scope
3.
GLOBAL VARIABLES. Global variables are a, i. and j: They may b e r e f e r e n c e d throughout the program. (e.g. The first assignment in m i n m a x is m i n := a [ i ] .)
NAME PRECEDENCE. Note that i is the name for both a global and a local variable. These a r e not t h e s a m e variable! A procedure may reference any variable global to it, or it may choose to redefine t h e n a m e . If a variable n a m e is r e d e f i n e d , the new name/tyoe association is then valid f o r t h e s c o p e of t h e d e f i n i n g procedure, and the global variable of t h a t n a m e ( u n l e s s p a s s e d as a parameter) is no longer available within the procedure scope. Assignment to t h e l o c a l i ( e . g . i := i + 2 ) h a s no effect upon t h e g l o b a l i; a n d s i n c e i d e n o t e s the local variable', the global variable i is effectively inaccessible. It is a good programming practice to declare every identifier w h i c h is n o t r e f e r e n c e d outside the procedure. as s t r i c l y l o c a l to t h a t p r o c e d u r e . N o t o n l y is t h i s g o o d documentation, but it a l s o p r o v i d e s added security. For example, i c o u l d h a v e b e e n l e f t as a g l o b a l variable; but then a later extension to the program which called procedure mlnmax within a loop controlled by i w o u l d cause incorrect computation.
4.
5.
Examining the last example in m o r e d e t a i l , o n e n o t e s t h a t m i n m a x is called twice. By formulating the program p a r t as a procedure--i.e, by not explicitly writing this program part twice--the programmer conserves not o n l y his t y p i n g time, but also space in m e m o r y . T h e s t a t i c c o d e is s t o r e d only once, and space defining local variables is activated only during the execution of the procedure.
One should not hesitate, however, from formulating an action as a procedure--even when called only once--if doing so enhances the readability. Defining development s t e p s as p r o c e d u r e s makes a more communicable and verifiable program.
Often necessary with the decomposition of a problem into subroutines is the introduction of n e w v a r i a b l e s to represent the arguments a n d t h e r e s u l t s of t h e s u b r o u t i n e s . T h e p u r p o s e of such variables s h o u l d be c l e a r f r o m t h e p r o g r a m text. The following program extends minimum a n d m a x i m u m v a l u e of an the above example to compute the a r r a y in a m o r e g e n e r a l sense.
70
11.1
} ,output) ;
minmax3(input
of
integer; : integer;
~ocedure m i n m a x ( v _ a r g : l i s t ; liar j,k : i n t e g e r ) ; v a ~ i : 1..n; u ,v : i n t e g e r ; beain j := g[ I] ; k := j; i := 2; ~hile i<n d~ ~_~in u := g [ i ] ; v := g [ i + l ] ; i u > v ~_hen beajd3 if u > k J~h#O k := u ; if v < j J 2 ~ J := V end e ~ ~.e_q.~.n i f v > k ..i~hen k := v ; .i.f" u < j & h e n j : = u
.~ o.#. ;
i := i + 2 end : if i =n ~b#d& i f g [ n ] > k t h e n k := g[n] e ~ & e if g[n] <j J&h~,d3 J := g[n] ; end; {minmax} ~e~in {read array} f o ~ i := 1 t o n do beQi~ r e a d ( e l i ] ); write(a[i] :3) end; writeln ; minmex (a,minl.maxl); writeln(minl,mexl,maxl-minl) ; writelm; fort i := I & O n d o be.qin r e a d ( b i l l ); write(b[i] :3) end: writeln : m i n m a x (b , m i n 2 . m a x 2 ) ; writeln(min2,max2,mex2-min2) : writeln(abs (mini-rain2) ,abs (max 1 - m a x 2 ) ) w r i t e l n ; ~a i := 1 J2a n d ~ begicL e[i] := a[i] + b [ ~ ] : w r i t e ( a [ i ] :5) e~&d; writeln ; m i n m a x (a ,rain 1 , m a x l ) ; wr it e l n (rain I ,max I .max l-rain I ) end.
-1
-3
4 -6 3 -U 2
U 54
23 79 -8 45 34
-5
9 8b
9 -6
45
79
79
45
43
I 34
4 34 53
d -I
3 -2
-4
4.4 40
2 15 -7
9 U8
15 - 4 ~d8
7 43 9.5
12
17 - 7
4U 72
75
'7
12
71
In p r o g r a m heading: procedure
11.2
one
encounters
the
second
form
of
the
procedure
<identifier>
);
The labels in the label definition part and all identifiers introduced in t h e f o r m a l p a r a m e t e r part, the constant definition part, the type definition part, the variable, p r o c e d u r e , or function declaration parts are i~cal to the procedure declaration w h i c h is c a l l e d t h e ~ c o o e of t h e s e o b j e c t s . T h e y a r e not known o u t s i d e t h e i r s c o p e . In t h e c a s e of l o c a l v a r i a b l e s , their values are undefined at t h e b e g i n n i n g of t h e s t a t e m e n t part. Parameters process to minmex is b.) provide a substitution mechanism that allows a be r e p e a t e d w i t h a v a r i a t i o n of its a r g u m e n t s . (e.g. called t w i c e t o s c a n a r r a y a a n d o n c e to s c a n a r r a y
One n o t e s a correspondence between the procedure heeding and the procedure statement. The latter contains a list of ~ctu~J, &arame~@~r_&, which are s u b s t i t u t e d for t h e c o r r e s p o n d i n g ~ormal ~arameters that are d e f i n e d in t h e p r o c e d u r e declaration. The correspondence is established by the positioning of the parameters in t h e l i s t s of a c t u a l and f o r m a l p a r a m e t e r s . There exist four kinds of parameters: so-called value parameters, variable parameters, procedure p a r a m e t e r s (the a c t u a l p a r a m e t e r is a procedure identifier), and function parameters (the a c t u a l parameter is a f u n c t i o n i d e n t i f i e r ) . Program 11.2 shows the case of the E#j~bl~ ~arameter. The actual parcmeter ~ust ~ ~ E~riable; the corresponding formal parameter m u s t be p r e c e d e d by t h e s y m b o l E#32 a n d r e p r e s e n t s this actual variable during t h e e n t i r e e x e c u t i o n of t h e p r o c e d u r e . Furthermore, if x 1 . . x n e r e t h e a c t u a l v a r i a b l e s that correspond to the formal variable parameters v l . . v n , t h e n x l..xn s h o u l d be ~latincj~ v a r i a b l e s . All address c a l c u l a t i o n s a r e d o n e at t h e t i m e of t h e c a l l , H e n c e . if a v a r i a b l e is a c o m p o n e n t o f an a r r a y , expression is e v a l u a t e d w h e n t h e p r o c e d u r e is c a l l e d . To d e s c r i b e arrow for Oarameter parameter. performed parameter with j and When procedure its i n d e x
the memory allocation pictorially, o n e c o u l d d r a w en each variable parameter f r o m t h e n a m e of t h e f o r m a l to the memory l o c a t i o n of t h e c o r r e s p o n d i n g actual Any operation involving the formal parameter is t h e n directly upon the actual parameter. Whenever the represents a ~ e s u l t of t h e p r o c e d u r e - - a s is t h e c a s e k a b o v e - - i t m u s t be d e f i n e d as a v a r i a b l e parameter. heads the parameter section, the parameter(s) of
no s y m b o l
72
t h i s s e c t i o n a r e s a i d to be M~llw_~ ~i@J~eJr~J&~/~(s). In t h i s case t h e actual parameter Wjistha an ~KD/~/~JJ3 (of w h i c h a v a r i a b l e is a simple case). The corresponding formal parameter represents a local variable in t h e c a l l e d p r o c e d u r e . As its i n i t i a l v a l u e , this variable receives t h e c u r r e n t v a l u e of t h e c o r r e s p o n d i n g actual parameter (i.e. t h e v a l u e of t h e e x p r e s s i o n at the t i m e of the procedure call). The procedure may t h e n change the value of this variable by assigning to it; t h i s c a n n o t , h o w e v e r , affect the value of the actual parameter. Hence. a value parameter can never represent a r e s u l t of a c o m p u t a t i o n , The difference in is shown in program the effects 11.3. of value and variable parameters
11.3 Parameters
parameters
(output);
va~ a,b : integer; ~roced~r_e h(x : integer; ~/~ beqin x := x + 1 ; y := y+1; writeln(x ,y) end ; ~e~in e := 0; b := 0; h(a.b); writeln(a,b) e~u~,
y : integer);
In program 11.2 none of the values in array g are altered; i.e. g is not a result. Consequently g could have been defined as a value parameter without affecting the end result. To understand why this was not done. it is helpful to look at the implementation. A procedure c a l l a l l o c a t e s a n e w a r e a for e a c h v a l u e p a r a m e t e r ; this represents the local v a r i a b l e . T h e c u r r e n t v a l u e of t h e actual parameter is " c o p i e d " i n t o this l o c a t i o n ; exit from t h e procedure simply releases this storage. If a parameter is not used to transfer a result of the procedure, a value parameter is generally preferred. The referencing is then quicker, and one is protected against mistakenly altering the data. However in the case wherea parameter is of a structured type (e.g. an array), one should be cautious, for the copying operation is relatively expensive, and the amount of storage needed to allocate t h e c o p y may b e l a r g e . Because referencing of each element in the array occurs only once, it is desirable to define the parameter asa variable parameter.
73
One
may
change
the d i m e n s i o n
of the
array
simply
by r e d e f i n i n g
one the
n. To make the program applicable for an array of reals, needs only to change the type and variable definitions: statements are not dependent upon integer data.
The use of the procedure identifier w i t h i n the text of the procedure itself implies Cenur@_~ve e x e c u t i o n of the p r o c e d u r e . Problems whose definition is n a t u r a l l y r e c u r s i v e , often lend themselves to r e c u r s i v e s o l u t i o n s . An e x a m p l e is the f o l l o w i n g p r o g r a m . G i v e n as data ere the s y m b o l i c e x p r e s s i o n s :
(a+b) ~ (c-d)
a +b *c -d
c-d
)*b+a
which period
to
the
syntax
of
figure
11.a.
expression
identifier
dI letter I v
Figure 11.a Expressions
74
The task is to c o n s t r u c t a p r o g r a m to c o n v e r t t h e e x p r e s s i o n s into postfix form (Polish notation). This is done by constructing an individual conversion ~rocedure for each syntactic construct (expression, term, factor). As these syntactic constructs are defined recursively, their corresponding procedures may activate themselves recursively,
75
postfix
form
mrooram ~ar ch
postfix(input,output); : char ;
orocedure find; beoin ~eoent read(oh) until ( c h < > ) a n d end ; orooedure vat op or_~ure
expression : char: :
~ot
eoln(input)
t erm :
oroce,~ure factor, beoiQ i f o h = (* t h e n beoin find; expression; end #lse write(oh) : find end: {factor}
factor while benin end {term} : oh= * find:
{oh
) }
do factor:
write('*')
~nd;
beoin term ; ~hile (ch='+')oz(ch =-') beqin op : = c h ; f i n d : end ~.d331: { e x p r e s s i o n } beoin find ; ~eoeat write(" "); expression ; writeln until oh='."
do term:
write(op)
end.
a b +cd - * abc~+dab+c*dabcd -*+
a a ~a {a ~
bcdca*a
~+*b*+a +
JEr e e i s a d a t a s t r u c t u r e that is naturally defined in terms and processed by recursive algorithms. It of a finite set of nodes t h a t is e i t h e r e m p t y or of a n o d e (the r o o t ) w i t h t w o d i s j o i n t binary trees.
76
c a l l e d t h e left and r i g h t s u b t r e e s (6). R e c u r s i v e p r o c e d u r e s for generating and traversing binary trees naturally reflect this m o d e of d e f i n i t i o n . Program 11.5 builds a binary t r e e and t r a v e r s e s it in p r e - , posta n d e n d o r d e r . The t r e e is s p e c i f i e d in p r e o r d e r , i.e. by listing t h e n o d e s ( s i n g l e l e t t e r s in this c a s e ) s t a r t i n g at t h e root a n d f o l l o w i n g first t h e left and t h e n t h e r i g h t s u b t r e e s so t h a t t h e i n p u t c o r r e s p o n d i n g to f i g u r e 11.b is:
abc..deo,fg...hi..jkt..m..n..
where a point signifies an e m p t y subtree.
Figure
11.b
Binary
tree s t r u c t u r e
~ro0ra~ traversal(input.output): tvae ptr = tnode; node = ~ecord info : char: llink.rlink : ptr ~nd; ~ar root : ptr; ch : char; ~roced~ preorder(p : ptr); ~eoin if p<>~3il then ~e~iE write (p~ .info ) ; preorder(pf .llink): preorder(pt .rlink) e_~: {preorder}
~ro_~~ postorder(p : ptr); beoin if p<>~il then ~eoin postorder(p~ ,llink): write(pt .info); postorder(p~ ~ l i n k )
and
~d3~; {postorder} orocedw~ endorder(p : ptr): ~eoin i f p <>13~Ll J~hen be~in endorder (p~ ,llink); endorder(p~ .rlink); write(p~ .info)
and
~nd:
{ endorder }
be~i~
_~P.O. new(p);
78
The reader is cautioned against applying reeursive techniques indiscriminately. Although appearing "clever". t h e y do not always produce the most efficient solutions.
The &&andard ~rgcedures in A p p e n d i x A are predeclared in e v e r y implementation of Pascal. Any implementation may feature additional predeclared procedures. Since they a r e , as all standard objects, a s s u m e d t o be d e c l a r e d in a scope surrounding the user program, no conflict arises from a declaration redefining the same identifier within the program. The standard procedures get, put, read, write, reset, and rewrite were introduced in c h a p t e r 9. R e e d a n d w r i t e a r e f u r t h e r d i s c u s s e d in chapter 12.
B.
Functions
Functions are program p a r t s (in t h e s a m e s e n s e as p r o c e d u r e s ) which compute a single s c a l a r or p o i n t e r v a l u e f o r u s e in t h e evaluation o an e x p r e s s i o n . A ~wnction ~ . s ~ specifies the activation of a function and consists of the identifier designating the function a n d a l i s t of a c t u a l parameters. The parameters are variables, exoressions, p r o c e d u r e s , or f u n c t i o n s end are substituted for t h e c o r r e s p o n d i n g formal parameters. The the function exception declaration has the same form of t h e _f_wj3c_t~DJ& ~ e a d i n o which <identifier> : <result type> : section> : <result as t h e p r o g r a m , has the form: with
L~Oct~gJ3 -orL W ~
type>
As in t h e c a s e of p r o c e d u r e s , t h e l a b e l s in t h e l a b e l definition part and all identifiers introduced in t h e f o r m a l parameter part. the constant definition part. the type definition part, the variable, procedure, or f u n c t i o n declaration parts are i~cal to the function declaration, w h i c h is c a l l e d t h e ~ of t h e s e objects. They a r e not k n o w n outside their scope. T h e v a l u e s of local variables a r e u n d e f i n e d at t h e b e g i n n l n B of the statement pert. The identifier specified in the function heading names the function. The result t y p e m u s t be a s c a l a r , subrange, or p o i n t e r type. Within the function declaration there m u s t be an e x e c u t e d assignment (of t h e r e s u l t t y p e ) to t h e f u n c t i o n identifier. This assignment "returns" the result of t h e f u n c t i o n .
79
The examples to date have only dealt with variable and value parameters. Also possible are procedure and function parameters. Both must be introduced by a special symbol: the symbol ~rocedun~ signals a farmal procedure parameter: the symbol function, a formal function parameter. The following program finds a zero of a function by bisection: t h e f u n c t i o n is specified at t h e t i m e of t h e c e l l .
function
by
bisection
Pro~ra~
bisect
(input,
output):
const eps =1a-14; v__ar_ x ,y :reaI; function zero(J~unction f': real; v a t x ,z : r e e l ; e :boalean; b#oin s := f(a)<0;
~eoeat x
:=
a,b:
real):
real:
:=
(a+b)/2.0; then a :: x w l s e b := x
z
if
f(x):
(z<O):s
read(x,y); r e a d ( x ,y ) ; ~n~.
-l.000O00000000e+00 1.00O000000000e+00
1.00O000000000e+00 2.000000000000e+00
-7.105427357601e-15 1.570796326795e+00
An assignment (occurring in a function declaration) to a non-local variable or taa variable parameter i s c a l l e d a ~i9_~ #fec~. Such occurrences often disguise the intent of the program and greatly complicate the task of verification. (Some implementations may e v e n a t t e m p t to forbid side effects.) Hence, the use of functions producing side effects is strongly discouraged. As an e x a m p l e , consider program 11.7.
80
} (output);
v~ a,z : integer : ~wnction sneaky(x : integer): integer; ~e~in z := z - x ; { s i d e e f f e c t on z} sneaky := s q r ( x ) end; j~e~in z := 10; a := s n e a k y ( z ) ; writeln(a,z); z := I0; a := s n e a k y ( t 0 ) * sneaky(z); z := 10; a := s n e a k y ( z ) * sneaky(t0); end.
writeln(aoZ), writeln(a,z)
100 0 10000
0 0 -10
exponentiation
a 3 g o r i t h m of
81
4.8
~AE pi,spi:
w_1~i~ n o t
div 2: x
o dd ( y ) d o
:= s q r ( x )
y
end ;
end ; := y-l:
Z
:= x*z
power := ,@Pd: { p o w e r }
7 2 2 4
The appearance of the function identifier within the function itself implies ~eeursive function.
in an e x p r e s s i o n e x e c u t i o n of the
82
of g c d }
~unction gcd(m,n: integer):integer; h eoin i f n=0 ~b~J3 god := m ~ I s e god := g c d ( n , m m o d n) end; {gcd}
18 312
61 98
27
2142
53 868
6 1
14
definition
if t h e r e
of
C. Remarks
I. P r o c e d u r e (function) calls may o c c u r b e f o r e the p r o c e d u r e (function) definition if t h e r e is a ~9J&_~J&~ ~ e f e r e n c e . The form is as follows: (Notice that t h e p a r a m e t e r list and eventual result type are written ~l~llv in the forward reference.)
Q(a)
~nd :
&~ocedure Q; ~e~in P(b) {parameters are not repeated}
2.
Procedures and functions which are used as parameters to other procedures and functions must have value 9arameters only. (Consequently. it is not necessary to test at run time whether a parameter is called by value or by address.)
3.
A component of a packed structure must not appear as an actual variable parameter. (Consequently. there is no need to pass addresses of partwords, and to test at run time or the internal representation of the actual variable.)
12 ~N PU T _AND # U T P U T
The problem of communication between man and c o m p u t e r was a l r e a d y m e n t i o n e d in c h a p t e r 9. B o t h l e a r n to w ~ e r s t a n d through what is t e r m e d p a t t e r n [ e c 0 ~ n i t ~ . Unfortunately, the patterns recognized most e a s i l y by men ( d o m i n a n t l y t h o s e of p i c t u r e and sound) are very d i f f e r e n t from t h o s e a c c e p t a b l e t o a c o m p u t e r (electrical impulses). In fact, the expense of physically transmitting d a t a - - i m p l y i n g a t r a n s l a t i o n of p a t t e r n s l e g i b l e to man into o n e s l e g i b l e to a c o m p u t e r , a n d v i c e v e r s a - - c a n be as Costly as the processing of the transmitted information. (Consequently, much r e s e a r c h is d e v o t e d t o m i n i m i z i n g the cost by "automatizing" or "'automating" m o r e of t h e t r a n s l a t i o n process.) T h i s t a s k of c o m m u n i c a t i o n is c a l l e d i n p u t a n d o u t p u t h a n d l ~ n g (I /O). The h u m a n can s u b m i t his i n f o r m a t i o n v i a ~ O o u ~ ~ e v i c e & (e.g. key punches, card readers, paper tapes, magnetic tapes, terminals) and r e c e i v e his r e s u l t s v i a ~ A W ~ d e v i c e s (e,g. l l n e p r i n t e r s , card and paper tape punches, terminals, visual display units), Common to b o t h - - a n d d e f i n e d by each i n d i v i d u a l i n s t a l l a t i o n - - I s a set of legible characters (chapter 2). It is over t h i s character set that Pascal defines the two standard textfile variables (program parameters) ~OD~t and ~ (also see c h a p t e r 9). Textfiles may be a c c e s s e d t h r o u g h the s t a n d a r d f i l e p r o c e d u r e s get and put. This can, of c o u r s e be q u i t e c u m b e r s o m e as t h e s e procedures are defined for single character"manipulation. To illustrate, consider one has a natural number s t o r e d in a variable x a n d w i s h e s to p r i n t it on t h e file o u t p u t . Note that t h e p a t t e r n of c h a r a c t e r s d e n o t i n g t h e d e c i m a l r e p r e s e n t a t i o n of the value w i l l be q u i t e d i f f e r e n t from t h a t d e n o t i n g the v a l u e written as a Roman numeral (see p r o o r a m 4 , 7 ) g u t as one is usually interested in d e c i m a l n o t a t i o n , it a p p e a r s s e n s i b l e to offer built-in standard transformation procedures that translate a b s t r a c t n u m b e r s (from w h a t e v e r c o m p u t e r - i n t e r n a l representation is u s e d ) i n t o s e q u e n c e s of d e c i m a l d i g i t s a n d v i c e v e r s a .
The two standard procedures to facilitate the analysis syntax for calling these can be used with a variable not fixed. ~ead and ~rite are thereby extended and the formation of textfiles. The procedures is non-standard, for they number of parameters whose types are
A.
The procedure
read
Let real,
v l.v2 and
of
type
char,
integer,
or
I,
for
85
2.
.,.
end
3.
4.
readln(f)
The effect is that after vn is read (from the the remainder of the current line is skipped, values of v l...vn may s t r e t c h over several lines 5. If ch is read(f,ch)
begin
a variable stands
oh
of type for
char.
then
:= ff ; g e t (f)
~nd
If a parameter v is o f t y p e i n t e g e r (or m s u b r e n g e thereof) or real a sequence of characters, which represents an integer or a r e e l n u m b e r a c c o r d i n g t o t h e P a s c a l syntax, is read. (Consecutive numbers m u s t be s e p a r a t e d by b l a n k s or e n d s of l i n e s . )
examples:
Read and process a sequence of numbers where the last value is immediately followed by an asterisk. Assume f to be a textfile, x and ch to be variables of types integer (or real) and char respectively. reset (f) ; reoe~& read(f,x,ch): P(x) ~t~_~l ch :*"
a more common s i t u a t i o n is w h e n o n e has no w a y o f how m a n y d a t a i t e m s a r e to be r e a d a n d t h e r e is no symbol that terminates the list. Two convenient f o l l o w . In t h e f i r s t , single items are processed.
that true,
eof(f)
to
second
86
reset(f);
read(f
,xl);
~la
beojJ3
not
eof(f)
do
xn);
~nd
(For the of s i n g l e above items schema to function m u s t be a m u l t i p l e properly, of n.) the total number
B.
The p r o c e d u r e
write
The procedure write appends character s t r i n g s (one or m o r e characters) to a textfile. L e t pl p 2 . . . . . p n be p a r a m e t e r s of the form defined b e l o w (see 5), e n d let f be a t e x t f i l e . Then, when writing o n t o t h e f i l e f:
1.
2.
...
e~
3.
4.
writeln b~in
pn) ,pl):
effect current pi must
...
writeln(f)
pn
eo~
end then
of writing l i n e of t h e be of one of
parameter
e e e where 6.
: el : el
: e2
e,
el,
and
e2 a r e
e is the valw_E t o be written a n d may be o f t y o e integer, real, Boolean, o r i t may be a s t r i n g . In the case, write(f,c) stands for ff := c; p u t ( f )
7.
el--called the minimum f i e l d w l d t h - - i s an o p t i o n a l control. It m u s t be a n a t u r a l number and indicates the minimum number of characters to be written. In g e n e r a l , t h e v a l u e e is written w i t h el c h a r a c t e r s (with preceding blanks). If el is "too small", m o r e s p a c e is a l l o c a t e d , ( R e a l s m u s t be w r i t t e n w i t h at l e a s t o n e p r e c e d i n g blank; however, this restriction does not apply to integer values.) I f no f i e l d l e n g t h is specified, a default value (implementation d e p e n d e n t ) is assumed according to t h e t y p e of t h e e x p r e s s i o n e.
87
8.
e2--called the ~raction i~o_q~--is an o p t i o n a l control and is applicable only when e is of t y p e r e a l . It m u s t be a natural n u m b e r and s p e c i f i e s t h e n u m b e r of d i g i t s to f o l l o w t h e d e c i m a l p o i n t . (The n u m b e r is t h e n s a i d to be w r i t t e n in fied-~oint notation.) If no f r a c t i o n l e n g t h is s p e c i f i e d , t h e v a l u e is p r i n t e d in d e c i m a l f l o a t i n g - p o i n t form. e or is of type Booleen, f a l s e is w r i t t e n . then the standard
13
~ S A &000-3.4 AOL
The p u r p o s e of t h i s c h a p t e r is to i n t r o d u c e t h o s e f e a t u r e s t h a t are peculiar to the implementation on t h e C o n t r o l D a t a 6 0 0 0 computers. The reader is w a r n e d t h a t r e l i a n c e u p o n a n y of t h e characteristics peculiar to PASCAL 6000-3.4 may r e n d e r his programs unacceptable to other implementations of P a s c a l . O n e is, therefore, advised to use only features described as ~tandard a s c a l in t h e p r e v i o u s chapters whenever possible, and certainly when writing "portable" programs. The topics A) B) C) D) of t h i s chapter fall into four categories:
Extensions to the l a n g u a g e Specifications left u n d e f i n e d in t h e p r e c e d i n g chapters Restrictions Additional predefined procedures, functions, and types
A.
Extensions
to
the
language
Pascal
This section defines non-standard language constructs available on the Pascal 6000-3,4 system. Although t h e y may b e o r i e n t e d toward the particular environment provided by the given operating system, they a r e d e s c r i b e d a n d can be u n d e r s t o o d in machine independent terms.
A.1
Segmented
files
A file can be regarded as being subdivided into so-called ~e~ments, i.e. as a sequence of segments, e a c h of w h i c h is itself a s e q u e n c e . P A S C A L 6 0 0 0 - 3 . 4 o f f e r s e f a c i l i t y to d e c l a r e a file as b e i n g ~ e ~ m e n t L d , a n d to r e c o g n i z e segments and their boundaries. E a c h s e g m e n t of s u c h a file is a " ~ w e i c a l r e c o r d " in CDC S C O P E t e r m i n o l o g y . declaration: <file type>
::= & e ~ m e n t e ~
Lile
<type>
an
~ile
char;
The p r e d i c a t e
function returns the value positioned st the false. true when the file x is end of a segment, otherwise
eas (x)
The
following
two
standard
procedures
are
introduced:
89
putseg(x)
when been
of
a segment
of
getseg(x)
is called in o r d e r to i n i t i a t e t h e r e a d i n g of t h e next segment of the file x . It a s s i g n s to t h e buffer variable ~ the f i r s t c o m p o n e n t of t h a t next segment. If no next s e g m e n t e x i s t s , e o f ( x ) becomes true; if a next s e g m e n t e x i s t s but is empty, then eos(x) becomes true and xt is undefined. S u b s e q u e n t c a l l s of w e t ~ x ) w i l l e i t h e r step on t o t h e next c o m p o n e n t or, if it does not exist, cause eos(x) to b e c o m e t r u e . not be c a l l e d if e i t h e r i m p l i e s e o s ( x ). eos(x) or e o f ( f ) is t r u e :
Get(x) eof(x)
must always
The advantages of a segmented file lie in the possibility of positioning t h e r e a d i n g or w r i t i n g head (relatively) quickly to any. segment in the file. For the purposes of reading and (re)writing a segmented file, the standard procedures getseg and rewrite are extended to accept two arguments. g e t s e g (x ,n ) initiates the reading of the nth segment c o u n t i n g f r o m t h e c u r r e n t p o s i t i o n of t h e f i l e , n>O implies counting s e g m e n t s in t h e f o r w a r d direction: n<O means counting them backwards: and n=O indicates the c u r r e n t s e g m e n t . N o t e : g e t s e g ( x , 1 ) is e q u i v a l e n t t o g e t s e g ( x ) . i n i t i a t e s t h e ( r e ) w r i t i n g of x at t h e b e g i n n i n g of the nth s e g m e n t c o u n t i n g f r o m the c u r r e n t position. N o t e : r e w r i t e ( x , 1 ) is n & e q u i v a l e n t to r e w r i t e ( x ) . The l a t t e r c a u s e s i n i t i a t i o n of ( r e ) w r i t i n g at t h e v e r y b e g i n n i n g of t h e e n t i r e file . (forward) processing, b e as e f f i c i e n t for
rewrite(x ,n)
Since files are organized for sequentfal one should not expect getseg and rewrite n<=0 as they are for n>0.
to
The following two program schemas, with statements W, R, and S, show the operations writing and reading of a segmented file.
the of
parametric sequential
Writing
a segmented
file x :
W(xt): un~2 p :
putseg w~til q (x)
put(x)
90
schem~
will
never
generate
an
empty
file
nor
an
empty
Reading
a segmented
file
x :
reset
(x):
~hila
not
eof(x)
m~
a segment} a component}
bm.oin { p r o c e s s
abila
be_%i[1 { p r o c e s s
S ( x t );
end
en~ : S: getseg(x)
The next example shows textfile f and copies the file output. orocedure list ; 3&ar i.s : i n t e g e r ; h~iO s := 0; reset(f):
~ b _ i l a zl#-~ e o f ( f )
hf..qin s := s + 1 :
do
i := O;
line}
do get(f)
oo~
The s t a n d a r d procedures segmented textfiles. ~~q.d and ~ r i t e can a l s o be a p p l i e d to
A.2
External
procedures
PASCAL 6000-3.4 provides a facility to access oxt~oal oroeedures, i.e. procedures (functions) that exist outside the user program and have been separately compi3ed. This enables the Pascal programmer to a c c e s s program libraries. The declaration of such a procedure c o n s i s t s of a p r o c e d u r e heading f o l l o w e d by
the
word
"extern"
or
"Fortran".
91
B.
Specifications
left
undefined
in
the
preceding
chapters
8.1
The
program
heading
and
external
files
A PASCAL file variable is implemented as a f i l e in t h e C D C operating system. Local f i l e s a r e a l l o c a t e d on d i s c s t o r e or in the Extended Core Store (ECS). S t o r a g e is a l l o c a t e d when they are generated and automatically released when the block to which t h e y a r e l o c a l is t e r m i n a t e d . Files that exist outside the p r o g r a m ( i . e . b e f o r e or a f t e r program execution) m a y be m a d e a v a i l a b l e to t h e p r o g r a m if t h e y are specified as ~ c t u a I ~arameters in t h e p r o g r a m ceil statement (EXECUTE) of the control card record. They are called external files and ere subsituted for the ~ l ~#ramE~WJ2~ specified in t h e ~ro~j~am ~ a d i n o . The heeding has the following form: ~~Oram <identifier> ( <program parameter> { , <program parameter>}
is either:
where
a program
parameter
<file
identifier>
-or-
<file
identifier> *
The parameters are formal declared as file variables same w a y a s a c t u a l local file
they m u s t be in e x a c t l y the
Files denoted by t h e f o r m a l parameters inowJ2 a n d ~ u t o u ~ have a somewhat special status. The following rules m u s t be n o t e d :
I .
2,
The program heading ~L~S~ contain the formal parameter output. Contrary to all other external files, the two formal file identifiers ~nout and ~-9_~ ~st D o t be defined in a declaration, because their declaration is automatically assumed t o be: 3&&~ i n p u t , output: text;
3.
The procedures reset and rewrite h a v e no to the actual files INPUT and OUTPUT.
effect
if
applied
examp le : Proora~
~_~_ x ,y
P (output, text ;
x,
y);
92
then EXECUTE,(,X,) Ss e q u i v a l e n t t o E X E C U T E , P ( O U T P U T , X . G ) . The full s p e c i f i c a t i o n of t h e f i l e p a r a m e t e r s is r e c o m m e n d e d b e c a u s e reliance on default v a l u e s o f t e n l e a d s t o m i s t a k e s that c o u l d easily have been avoided.
B.2
Representation
of f i l e s
In the case of external files it is i m p o r t a n t t o know t h e representation of files chosen by the P A S C A L c o m p i l e r . E v e r y component of a P A S C A L - 6 0 0 0 file o c c u p i e s an i n t e g r a l n u m b e r of ~O-bit words, with t h e e x c e p t i o n of files w i t h c o m p o n e n t t y p e ~har (~extfiles). In t h i s c a s e P A S C A L f i l e s u s e t h e " s t a n d a r d " representation imDosed by CDCs text file conventions: 10 characters are packed into each word, implying that the procedures put and get i n c l u d e p a c k i n g and u n p a c k i n g o p e r a t i o n s when applied to t e x t f i l e s . The end of a l i n e is r e p r e s e n t e d by at least 12, right-adjusted zero-bits in a word. Files originating from ~ard ~ f o l l o w the s a m e g e n e r a l t e x t f i l e conventions. Note that the operating system ~moves most (but not necessary all) trailing blanks when reading cards, Hence, such files do Dot necessarily c o n s i s t of 8 0 - c h a r a c t e r "card images" Files that are not s e g m e n t e d a r e w r i t t e n as a s i n g l e " l o o i c a l record" (in SCOPE terminology). W h i l e r e a d i n g an u n s e g m e n t e d external file, end-of-record marks are ignored [for an exception, s e e p o i n t 3 b e l o w ] . In s e g m e n t e d f i l e s , each s e g m e n t corresponds to a "logical record". T h e r e is no p r o v i s i o n to specify a "record level".
Use of e x t e r n a l I.
files
(rewrite(x) case of s e g m e n t e d
) files by
and
in t h e
reset(x) getseg(x.n)
(This statement is automatically implied for the f i l e s denoted by the f o r m a l p a r a m e t e r s j~omut a n d ~ u t n u t , and must not be s p e c i f i e d by the p r o g r a m m e r . )
2.
Every
external
file
is a u t o m a t i c a l l y
"opened"
by a call
of
93
the OPE r o u t i n e of t h e o p e r a t i n g s y s t e m . I f t h i s o p e n i n g is to be r e s t r i c t e d to t h e r e a d f u n c t i o n - - e . g , in t h e c a s e of a permanent file without write permission--then t h i s has t o be i n d i c a t e d by an a s t e r i s k f o l l o w i n g t h e f i l e p a r a m e t e r in t h e program heading. The asterisk itself constitutes no protection a g a i n s t w r i t i n g on t h e f i l e . example: ~r_Q_gram ~i
data*) :
d a t a : "f_ila ~ f r: r e a l ; r :='data~ ;
o . .
get(date)
3.
B.3
The
standard
types
INTEGER
The
standard
~on~
identifier
=
~axint
is
defined
{
as
1 }
maxint
281474976710655;
= 2**48
The r e a d e r is c a u t i o n e d , h o w e v e r , that t h e CDC c o m p u t e r p r o v i d e s no indication of o v e r f l o w . It is, t h e r e f o r e , the programmer's responsibility to p r o v i d e a c h e c k w h e n e v e r t h i s m i g h t o c c u r . Actually. the machine is c a p a b l e of s t o r i n g i n t e g e r s up t o an absolute value of 2**59, but then ~ the operations of addition (+), subtraction (-), taking the absolute value, multiplication and division by powers of 2 ( i m p l e m e n t e d as shifts), and comparisons are correctly e x e c u t e d in t h i s r a n g e (as l o n g as no o v e r f l o w o c c u r s ) . In p a r t i c u l a r , one cannot even p r i n t an i n t e g e r v a l u e i w h e n a b s ( i ) > m a x i n t . This does, however, allow the following test: if a b s ( i ) > maxint the write(" too big')
REAL
point to 14
94
CHAR
A v a l u e of t y p e ~ h a r is an e l e m e n t in t h e c h a r a c t e r set p r o v i d e d by t h e p a r t i c u l a r i n s t a l l a t i o n . The f o l l o w i n g 3 v e r s i o n s e x i s t : I) The C D C 2) T h e C D C 3) The CDC Scientific 64-character Scientific 63-character A S C I I 6 4 - c h a r a c t e r set set set
Table 13.a lists the a v a i l a b l e c h a r a c t e r s and i n d i c a t e s t h e i r o r d e r i n g : ~ o t e : t h e CDC s p e c i f i c a t i o n i m p l i e s an o r d e r i n g of the ASCII characters w h i c h d i f f e r s from the I n t e r n a t i o n a l S t a n d a r d (ISO)!
95
CDC
Scientific
Character
Set
with
64
elements
j~ : J T 3
1 A K U 4
2 a L V 5
3 C M W 6
4 O N X 7
5 E 0 Y 8
6 F P Z 9
7 G q ~ +
8 H R I -
9 I S 2 *
/ ]
( ~
) ~
$ m
= v
, ^ ~
-~ ~
[ < >
Comments: ~ not : ' t t used in at at at the ETH ETH ETH in 63-character set set version
- 51 - 48 53 57
63-character
version
ASCII
Character
5et
with
CDC's
ordering
1 : J T 3 A K U 4
2 B L V 5 C M W 6
3 D
4 E 0
5 F P
6 G q Z 9 +
8 H R
9 I 5
N X 7
Y 8
I *
)
,,
=
: &
,
' ?
~
<
[
>
Figure
13.a
CDC
character
sets
96
Based upon the above character sets, the following characters are accepted as s y n o n y m s for t h e s t a n d a r d s y m b o l g i v e n in t h e left c o l u m n :
Pascal
CDC
scientific
-7
ASCII
A V
&
_<
> Alternative representation standard symbols of
13.b:
B.4
The
standard
procedure
10 22 10
1
( w h e r e t h e e x p o n e n t is a l w a y s e x p r e s s e d in t h e f o r m : E~999
a string a l f a (see
length D.I)
10
of t h e
string
The end of each line in a textfile f m u s t be e x p l i c i t l y indicated by writeln(f)o where writeln(output) m a y be w r i t t e n simply as w r i t e l n . If a t e x t f i l e is to be s e n t to a p r i n t e r ~ no line may c o n t a i n m o r e t h a n 136 c h a r a c t e r s . The f i r s t c h a r a c t e r of each line is interpreted by the printer as a control character and ~s not printed. The following characters are interpreted to mean
+"
blank
"0"
no llne f e e d (overprinting) single spacing double spacin~ triple spacing s k i p to top of next p a o e b e f o r e
printing
The procedure writeln(x) is u s e d to m a r k t h e end of a line on fi&e x, The conventions of t h e C D C o p e r a t i n g system reoarding textfile representation a r e s u c h that t h i s p r o c e d u r e is f o r c e d to emit some extra blanks under certain circumstances. Hence,
97
upon that
may c o n t a i n written.
of
lines
C.
Restrictions
(as
of
March
1974)
1. 2.
The word
se.qmented
is r e s e r v e d .
T h e b a s e t y p e of a set m u s t be e i t h e r a) a s c a l a r w i t h at m o s t 58 e l e m e n t s (or a s u b r a n g e
OF
thereof)
b)
c)
a subrange with a minimum element greater than or equal to zero, and a maximum element less than or equal to 58, or a subrange of the type chat with the maximum element less than or equal to the value chr(58).
3.
Standard (built-in) proeedrues or functions are not accepted as actual parameters. For example, in order to run program 11.6 in PASCAL 6 0 0 0 - 3 . 4 , one would have to write auxiliary functions as follows:
zero(function ... e~ :
f: r e a l ;
e,b:
real):
real;
be~in read(x,y); r e a d ( x oy ) ;
writeln writeln
( x .y , z e r o (x ,y , z e r o
(sine ,x ,y ) ) ; (cosine ,x ,y )
4.
It is records
not and
p o s s i b l e to c o n s t r u c t a file of f i l e s : h o w e v e r , a r r a y s w i t h f i l e s as c o m p o n e n t s a r e a l l o w e d .
D. Additional
predefined
types,
procedures,
and
functions
D,I
predefined
The t y p e ~y~
is p r e d e f i n e d
= ~acked ~rrav[1..10]
type of ella this
98
Applicable on operands of type ella are assignment comparison, where = a n d <> t e s t equality and <, <=, test order according to the underlying character values m a y be p r i n t e d by t h e p r o c e d u r e write. { program 13.1 ala values } ~roeram egalfa (output);
vat nl.n2: alfa; beoin write(" names: '); nl := "raymond ": n2 := "debby if n2 < nl then writeln(n2.nl) else writeln (nl,n2) end.
nameS:
debby
raymond
not possible to is s u g g e s t e d :
read
alfa
values
directly;
instead,
b u r : a r r a y [ I..10] of c h a r ; a: a l f a ; i: i n t e g e r ;
D .2 A d d i t i o n a l
predefined
procedures
and
functions
~roce~ures
date (a) halt assigns to the alfa variable of the current the date. and
program
linellmit(f,x)
f is a t e t f i l e a n d x is an i n t e g e r expression, The effect is to cause the program to be terminated, if m o r e t h a n x l i n e s a r e a s k e d t o be written on f i l e f. the string x is written (Hence. x should c o n t a i n at assigns to the the alfa variable to into the dayfile. most 40 characters.) a the rewrite current and time. are
message (x)
time
(a) . getseg,
putseg
and
extensions
reset
99
discussed
in s e c t i o n
13.A.I.
~unctlons
card(x) clock
equals number
a function, without parameters, yielding an i n t e g e r v a l u e e q u a l to the c e n t r a l p r o c e s s o r t i m e , expressed in milliseconds, already u s e d by t h e job. yields an integer the floating~oint value x. v a l u e e q u a l to t h e e x p o n e n t of representation of the real
expo(x)
undefined(x)
is t r u e w h e n t h e or " i n d e f i n i t e " ,
cos(x)
13.A.1)
Uow ~
A. C o n t r o l
statements
A Pascal job u s u a l l y c o n s i s t s of f o u r s t e p s . F i r s t , the P a s c a l compiler is loaded. The s e c o n d s t e p is t h e c o m p i l a t i o n step, which yields a l i s t i n g of t h e s o u r c e p r o g r a m a n d t h e c o m p i l e d code. In the third step t h e c o m p i l e d c o d e , d e p o s i t e d by t h e compiler on secondary store, is loaded and linked with precompiled routines for input and output handling, which are provided on a "program l i b r a r y " f i l e . F i n a l l y , t h e c o m p i l e d a n d loaded code is executed. These four s t e p s a r e i n i t i a t e d by appropriate orders to the operating system in t h e f o r m of ~ontro~ Qtetements. The e x a c t f o r m of t h e s e s t a t e m e n t s and t h e i r abbreviated f o r m s ( l o a d i n g a n d e x e c u t i o n c a n o f t e n be o r d e r e d by a single statement) depend entirely upon the available operating system, and must therefore be specified by the particular installation. The actual file parameters, w h i c h c o r r e s p o n d t o t h e f o r m a l file identifiers l i s t e d in t h e p r o g r a m h e a d i n g , m u s t be s p e c i f i e d in the statement initiating execution of the compiled program ( u s u a l l y an E X E C U T E c o m m a n d ) . The compiler ~r_~wJE~ itself is a l s o a Pascal program. Its heading is
The COC operating systems allow the omission of a c t u a l parameters in t h e c o n t r o l s t a t e m e n t s . If an a c t u a l f i l e name is omitted, the Pascal convention on p r o g r a m p a r a m e t e r s specifies t h a t t h e f o r m a l file i d e n t i f i e r be u s e d as t h e a c t u a l file n a m e . Hence, the standard files INPUT, OUTPUT, and LGO are automatically a s s u m e d as t h e d e f c u l t ~ i l e s for t h e s o u r c e file, the listing, and the relooatable binary code respectively. Note, however, that these roles m a y be a s s u m e d by o t h e r f i l e s w h e n their names are entered as actual parameters. Note: actual parameters m u s t c o n s i s t of at m o s t 7 c h a r a c t e r s .
B . Compiler
options
The compiler may be i n s t r u c t e d to g e n e r a t e c o d e a c c o r d i n g to c e r t a i n o p t i o n s ; in p a r t i c u l a r , it may be r e q u e s t e d to insert or omit r u n - t i m e t e s t i n s t r u c t i o n s . Compiler directives are written as comments and a r e d e s i g n a t e d as s u c h by a S - c h a r a c t e r as the first c h a r a c t e r of t h e c o m m e n t :
101
{$<option Example:
sequence> }
<any
comment>
{$T+.P+
The option s e q u e n c e is a s e q u e n c e of i n s t r u c t i o n s separated by commas. Each instruction c o n s i s t s of a l e t t e r , designating the option, followed either by a p l u s (+) if t h e o p t i o n is t o be activated or a m i n u s (-) if t h e o p t i o n is t o be p a s s ~ v a t e d 0 or by a d i g i t (see X e n d B b e l o w ) .
The
T
following include a) b)
options
are
available"
run-time
tests
e) d)
e)
all array indexing operations to insure that the index lles within the specified array bounds. all assignments to variables of s u b r a n g e t y p e s to m a k e certain that the assigned value lies within the specified range . all divisions to i n s u r e a g a i n s t zero divisors all automatic integer to reel conversions to a s s u r e t h a t the converted value satisfies : a b s (i) <= m s x i n t all case statements to insure that the case selector corresponds to one of the specified case labels. = T+ the code necessary to section 14.C .2) in t h e write a complete Post~ortem c a s e of a r u n - t i m e error.
default P
= P+
if a digit n (0 <= n <= 6) f o l l o w s t h e X. p a s s t h e f i r s t n parameter discriptors in the registers XO to X(n-1) (the first in XO, t h e s e c o n d in XI, etc',). O t h e r w i s e p a s s t h e m in the locations with the addresses B6+3 to B6+n+2. n>O reduces t h e s i z e of t h e c o d e p r o d u c e d by t h e c o m p i l e r a n d probably also s l i g h t ly improves the code. However', the programmer must be a w a r e t h a t w i t h n > O . t h e c o m p i l e r cannot use the registers XO t o X m l n ( n - l , i - 2 ) for the passing of t h e ith parameter. It is therefore possible t h a t for n > O , t h e compiler gives the message " r u n n i n g o u t of r e g i s t e r s " : where f o r n = O o it w o u l d n o t . default = X4 the symbols for the entry (procedures and functions) The following conventions
allows the programmer to control points to the object code modules that he declares in h i s p r o g r a m . . hold :
-- M o d u l e s declared as "extern" or point name equal to the procedure first seven characters.
102
get an E-option
entry (at
name
ere
Whenever the cut module n a m e is t a k e n ( E + a n d " e x t e r n " or "fortran"), it is t h e p r o g r a m m e r s responsibility to a v o i d t h e occurrence of duplicate entry point symbols. default L controls default U : Ethe = L+ listing of the program text.
a l l o w s t h e u s e r to r e s t r i c t t h e n u m b e r of r e l e v a n t characters in every source line to ?2. T h e r e m a i n d e r o f t h e l i n e is treated as a comment. With Uthe number of relevant characters is 120. T h e r e s t of t h e l i n e is t h e n t r e a t e d as a comment. default = Uof f i l e b u f f e r s . the bufffer size t o be S > 1 2 8 . d
used to s p e c i f y a T o w e r l i m i t for t h e s i z e If after the B a digit d (I<=d<=9) occurs, S, computed by the compiler, is g u a r a n t e e d words . default = B4
compiler instructions may be w r i t t e n anywhere in t h e it is p o s s i b l e to activate the options selectively over parts of the program.
C.
Error
messages
0.1
The compiler indicates a detected e r r o r by an the relevant place in the text, followed corresponds to the messaDes in A p p e n d i x E .
C.2
Run~ime
(Post-Mortem
Dump)
compiler o p t i o n P is t u r n e d on ( i . e . P + ) , t h e c o m p i l e r code that c a n be u s e d t o p r i n t a r e a d a b l e "dump'" in that a run-time error occurs. The dump includes the
103
following a) b) the
a description of e a c h o f t h e p r o c e d u r e s (functions) that is activated at t h e t i m e of t h e t r a p . These a p p e a r in t h e reverse o r d e r of t h e i r calls and consist of: I) t h e n a m e o f t h e p r o c e d u r e 2) t h e l o c a t i o n o f i t s c a l l 3) a list of t h e n a m e s and values of the local variables and parameters. the values of t h e global variables in the main program.
c)
Only variables and parameters of the types integer, real, Boolean, char, and alfa. Pointers are either " n i l " or h a v e an octal value (address). For other scaler variables, the ordinal number of their current value is p r i n t e d , When, for any one procedure, the option P is turned off (P-). t h e n o n l y t h e procedure name and the location of its c a l l a p p e a r in t h e d u m p . In the recent) case three of r e c u r s i v e procedure calls, only the last occurrences of each procedure are listed, (most
~&cal.
Acta
~ ~roorammi~_~ L~noua~ ~aal ~p_~), Berichte der Computer-Wissenschaften ETH Z u r i c h , 2. 3. 4. O.d. Dahl,
System~J2~
1973. E .W. D i j k s t r e , ~tructured
Prentice-Hall,
Inc,
Academic
Press of
1972.
5. C.A .R . H o a r e and N. W i r t h , Programming ~nfo~ma~ica, "An A x i o m a t i c Definition Language Pascal", 2, 335-355, 1973.
6, D . E .
7.
Knuth.
SCOPE R e f e r e n c e
Corporation,
1973.
Standard
Appendix ~&edures
A ~nd
~unctions
File
handling
procedures
put (f)
f~ t o prior true,
the to and
get(f)
advances the current file position to the next component, and assigns the value of this component to the buffer variable f~ . I f no n e x t c o m p o n e n t exists, then e o f ( f ) b e c o m e s t r u e , a n d t h e v a l u e of ft is u n d e f i n e d . A p p l i c a b l e o n l y if e a r ( f ) is f a l s e p r i o r t o its e x e c u t i o n . (f) resets the current file p o s i t i o n to its b e g i n n i n g for the purpose of reading, i.e. a s s i g n s to t h e buffer variable f~ the value of the first element of f. ear(f) becomes false if f is not empty: otherwise, f~ is undefined and ear(f) remains true. replaces the current eof(f) becomes true, v a l u e of f w i t h t h e e m p t y f i l e . a n d a new f i l e m a y be w r i t t e n . of a n e w textfile
reset
rewrite(f)
page(f)
instructs the printer to s k i p to t h e t o p page before printing the next l i n e of t h e f, write, chapter writeln 12. are applicable on textfiles
and
are
Dynamic
allocation
procedure
new ( p )
a new v a r i a b l e v and assigns the reference of v to the Pointer p. If the type of v is a record variants, the form to a l l o c a t e a v a r i a b l e of t h e t a g f i e l d v a l u e s t 1 . . , t n . The values must be listed and in the order of t h e i r
new(p ,t 1 .....
dispose(p)
returns the dynamic referenced by P . ,t I .... ,tn) returns the dynamic referenced by p and second form of new.
variable
that
is
dispose(p
106
choose to ignore this statement,)
Data
transfer
procedures
paek(a,i,z)
a i s an a r r a y variable of type arrav[m..n] ~ T and z is a variable of type aacke~ ~_~Z[u..v] ~ T w h e r e n-m >= v - ~ , then this is equivalent .f_or j := u J~D. v d o z[j] := e[j-u+i]
if
to
u n p a c k (z ,a , i )
to v do a[j-u+i] := z[j]
variable
Arithmetic
functions
abs ( x )
c o m p u t e s t h e a b s o l u t e v a l u e of x. The t y p e o f t h e r e s u l t is t h e s a m e as t h a t of x, w h i c h m u s t be e i t h e r i n t e o e or real. c o m p u t e s x * x . T h e t y p e of t h e r e s u l t is t h e of x, w h i c h must be e i t h e r i n t e g e r or r e a l . for the integer. f o l l o w i n g , t h e t y p e o f x m u s t be The t y p e o f t h e r e s u l t is always same as that
sqr(x)
sin(x)
either real.
real
or
cos(x)
aretan (x) (natural (square logarithm) root)
exp ( x )
ln(x) sqrt(x)
Predicates
(Boolean
functions)
odd ( x )
the
result
is t r u e
if x
eoln(f)
eof(f)
file
f.
107
Transfer
functions
trunc(x)
x must be of t y p e r e a l ; t h e r e s u l t is t h e g r e a t e s t integer less than or equal to x for x > = O . a n d t h e l e a s t i n t e g e r g r e a t e r or e q u a l to x for x < O . x must be of t y p e r e a l : t h e r e s u l t , is t h e v a l u e x r o u n d e d . That is, r o u n d ( x ) = t r u n c ( x + 0 . 5 ) , for trunc(x-O.5), for the ordinal number v a l u e s d e f i n e d by t h e x must be of character whose of the a r g u m e n t t y p e of x. of t y p e x x x > 0 < 0 in t h e set of integer,
round(x)
ord (x)
chr(x)
Further
standard
functions
succ(x)
x is is t h e x is is t h e
the result
pred(x)
result
108
~ / i v
Appendix B of Operations
go e r a ~
oeration
~Yoe
of # o e r a n d ( s )
o_
assignment
any t y p e e x c e p t file t y p e s
identity sign inversion addition subtraction multiplication integer division real division modulus
integer
or r e a l
same operand
as
integer
or r e a l
integer or r e a l
/ mad
relational:
= <>
or
real
<=
>=
or s t r i n g
or s t r i n g
set
inclusion membership
ia
set
logical: not or
aad
Boolean
Boolean
set:
+
any
set
type
A.
Table
of
standard
identifiers
maxint
Types: integer,
Boolean,
real,
char,
text
chr, round,
cos, sin,
eof, sqr,
eoln. sqrt,
exp, succ,
page, write,
readln,
reset ,
B.
Table
of
word-delimiters
(reserved
words)
m~ arraK ~a_q~n
nil not of
sa~ thezl ~o
y.~e
~OJ3S t div do dow nt Q e Is e
~unctioq
_onto if in ~abe ~ /nod
~E
o~Gk#d oroceduns o r o ~r a m rw_~or d r_e o w2.c~
tvo~
until var ~bila ~ith
C. Non-standard, Types:
alfa
predefined
identifiers
i n PASCAL 6 0 0 0 - 3 . 4
Functions: card,
clock,
eos, halt,
expo,
iinelimit,
110
Appendix
~vnt ax
~_acku~_-N~_IZ~
F~Lm
(RNF)
the
!
denote possible repetition t i m e s . In g e n e r a l . of the enclosed
is a s h o r t A
form
for
the
purely
recursive
rule:
: := < e m p t y >
[ AB
BNF
<program> <program
: := < p r o g r a m heading>
heading>
::= ~ o ~ r _ ~
<file
<identifier> <letter or
<letter>
~ <digit>
<block>
::: <label declaration part> <constant definition part> <type definition part> <variable declaration part> <procedure and function declaration hart> <statement part> declaration part> ::= <empty> I ~abel <label> ~, <label>} ; ::= <unsigned integer>
<label
<label> <constant
definition>}
<constant <constant>
::: < u n s i g n e d number> I <sign> <unsigned number> I <constant identifier> I <sign> <constant identifier> I <strin~q> number> ::= <unsigned integer> I <unsigned real>
<unsigned
111
<unsigned <unsigned
integer>
::=
<digit>
{<digit>}
r e e l > ::= < u n s i g n e d integer> . <digit> {<digit>} I <unsigned integer> . <digit> {<digit>} E <scale factor> <unsigned integer> E <scale factor> ::= ~ ::= <identifier> {<character>} <unsigned integer> I <sign> <unsigned integer>
<scale <sign>
factor> ::= +
identifier> ::=
' <character>
definition p a r t > ::-- < e m p t y > I Jiyoe < t y p e d e f i n i t i o n > { ; <type definition> ::= <simple : := < i d e n t i f i e r > type>
definition>}
I <structured type>
~ <submange
( <identifier> <constant>
type>
::=
identifier> type>
<structured
<index
<index
: := < t y p e > <field part> l i s t > ~J3~[ ~ <fixed part> ; <variant part> I
type>
::= D e c o r d
<fixed <record
section>
{ ; <record {.
section>
::= < f i e l d
identifier>
<type>
<variant part>
<empty>
<tag field> <type identifier> of
::= c a s e
<variant>
{ ; <variant>}
112
<tag
field>
::= ::=
<field
identifier> list> :
<case
list>
label>
label>}
<pointer <variable
type>
~ <type
declaration>}
<variable <procedure
<identifier>}
: <type>
;} declaration> I
<procedure
<procedure
<procedure <procedure
<procedure
heading>
<block>
heading> ::= & ~ w ~ e d u r e <identifier> ; I &rocedure <identifier> ( <formal parameter { ; <formal parameter section>} ) ; <parameter ~rou#> I I ~unction <parameter {. <identifier>} { <identifier>}
section>
<formal
parameter section> ::= va~ <parameter group> &~ocedure <identifier> group> ::= <identifier> <type identifier> declaration> ::=
group>
<parameter
<function <function
<function
heading>
<block> ; I
heading> ::= f u n c t i o n <identifier> : <result type> f~tio~ <identifier> ( <formal parameter section> { ; <formal parameter section>} ) : <result type> ; type> ::= <type ::= identifier> statement>
<result
<statement
part>
<compound
<statement> ::= < u n l a b e l l e d statement> I <label> : <unlabelled statement> <unlabelled statement> :'= < s i m p l e <structured statement> <simpIe statement> ::= <assignment statement> I
statement>
113
I <go
to
statement>
<assignment statement> ::= < v a r i a b l e > := < e x p r e s s i o n > <function identifier> := < e x p r e s s i o n > <variable> ::-- < e n t i r e variable> <referenced variable> ::= <variable ::= I <component variable>
<entire <variable
variable>
identifier>
identifier>
<component
<indexed
variable> ::= < a r r a y { , <expression>} ] variable> designator> variable> identifier> : := < v a r i a b l e > ::= ::= ::= <record
variable>
[ <exmression>
variable>
. <field
identifier>
buffer> variable>
: := < f i l e ::=
<referenced <pointer
variable> ::=
variable>
<expression> ::= < s i m p l e expression> ~ <simple expression> <relational operator> <simple expression> <relational <simple operator> ::= = I <>
I < I <= I >= I > I in
expression> ::= < t e r m > I <sion> <term> <simple expression> <adding operator> operator> ::= <factor> ::= + I I o~ <multiplyino ~- ! / ~ d~
1 <term>
<adding <term>
I <term> ::=
operator> I a~d
<factor>
<multiplying <factor>
operator>
I ~L~
::= < v a r i a b l e > I <unsigned constant> <function designator> I <set> I not constant> <constant ::= < u n s i g n e d number> identifier> I nil
I ( <expressSon> <factor> I
<unsigned
I <string>
<function
114
: := < e x m r e s s i o n >
statement> ::= < p r o c e d u r e identifier> I <procedure identifier> ( <actual parameter> { . <actual parameter>} ) identifier> ::= <identifier>
<Procedure <actual
::= < e x p r e s s i o n > I <variable> I identifier> I <function identifier> ::= o o t o ::= <label>
<go
to
<empty <empty>
<empty>
<structured statement> ::= < c o m p o u n d statement> <conditional statement> I <repetitive <with statement> <compound statement> ::= b ~ g ~ n ::= <if <statement> statement>
l statement>
[ ; <statement>} I <case
ond
<conditional <if
statement>
statement>
statement> ::= if < e x p r e s s i o n > then <statement> I if <expression> JZ~J~D < s t a t e m e n t > e3se <statement> statement> : := c a s e <expression> [ ; <case list element>} ~nd list element> <empty> label list> ::= <case label of <case list element>
<case
<case
list>
: <statement>
<case
::=
<case
label> <while
{,
<case
label>
} statement} I
statement>
J <repeat
<expression>
do
<statement>
{ ; <statement>}
<for
:=
<for
list>
do
<for
list> ::= < i n i t i a l v a l u e > t o < f i n a l v a l u e > <initial value> dgwnto <final value>
115
::=
<identifier>
<expression>
<expression> ::= ~ i t h list> ::= <recomd <record variable variable> list> ~ <statement> variable>}
statement> variable
{ . <record
identifier
rm
unslgned number
"@--'Ityp~
unsigned con~ta~tt 1 ~
O~
constant identifier]
field list
consta~l
~~'ype'o','d'@ 1
I ~ G - - - ~ q F
I 1.
variable
simple expression
expression
factor
----simpio
oxp .... i o ~
............
~lu..~.. ........ I
OQQ@(~
L i ~ ~ I
.......
,I
l.[i~ptoxp
",4
parameter
list
~-<S
term
statement
lock
~~-~~
i
0
. . . . . . ] =
rogtawl
119
Appendix E ~:~j~umber ~ummar~
I: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: I?: 18: 19: 20: 21:
e r r o r in s i m p l e t y p e identifier expected "program' expected ")" expected ":" expected illegal symbol e r r o r in p a r a m e t e r l i s t "of" e x p e c t e d "( e x p e c t e d e r r o r in t y p e "[" e x p e c t e d '] " e x p e c t e d "end" e x p e c t e d ";" e x p e c t e d integer expected "=" e x p e c t e d "begin" expected e r r o r in d e c l a r a t i o n p a r t e r r o r in f i e l d - l i s t ' " expected "~" expected
50: 51: 52: 53: 54: 55: 56: 57: 58: 59:
error in constant ":=" expected "then" expected "until" expected "do" expected 'to'/'downte expected "if" e x p e c t e d "file" e x p e c t e d e r r o r in f a c t o r e r r o r in v a r i a b l e
101: 102: 103: 104: 105: 106: I07: 108: I09: 110: 111: 112: 113: 114: 115: 116: 117:
identifier declared twice low b o u n d e x c e e d s h i g h b o u n d i d e n t i f i e r is not of a p p r o p r i a t e c l a s s i d e n t i f i e r not d e c l a r e d s i g n not a l l o w e d number expected incompatible subran~e types file not a l l o w e d h e r e t y p e m u s t not be r e a l t a g f i e l d t y p e must be s c a l a r or s u b r a n g e incompatible with tagfield type i n d e x t y p e must not be r e a l i n d e x t y p e must be s c a l a r or s u b r a n g e b a s e t y p e must not be r e a l b a s e t y p e must be s c a l e r or s u b r a n o e e r r o r in t y p e of s t a n d a r d p r o c e d u r e p a r a m e t e r unsatisfied forward reference
120
118: 119: 120: 121: 122: 123: 124: 125: 126: 127: 128: 129: 130: 131: 132: 133:. 134: 135: 136: 137: 138: 139: 140: 141: 142: 143: 144: 145: 146: 147: 148: 149: 150: 151: 152: 153: 154: 155: 156: 157: 158: 159: 160: 161: 162: 163: 164: 165: 166: 167: 168: 169: 170: 171: 172:
m i s s i n g r e s u l t t y p e in f u n c t i o n d e c l a r a t i o n F - f o r m a t for r e a l o n l y e r r o r in t y p e of s t a n d a r d f u n c t i o n p a r a m e t e r n u m b e r of p a r a m e t e r s does not a g r e e w i t h d e c l a r a t i o n illegal parameter substitution r e s u l t t y p e of p a r a m e t e r f u n c t i o n does not a g r e e w i t h declaration t y p e c o n f l i c t of o p e r a n d s e x p r e s s i o n is not of set t y p e t e s t s on e q u a l i t y a l l o w e d o n l y s t r i c t i n c l u s i o n not a l l o w e d file c o m p a r i s o n not a l l o w e d i l l e g a l t y p e of o p e r a n d ( s ) t y p e of o p e r a n d m u s t be B o o l e a n set e l e m e n t t y p e m u s t be s c a l a r or s u b r e n g e set e l e m e n t t y p e s not c o m p a t i b l e t y p e of v a r i a b l e is not a r r a y i n d e x t y p e is not c o m p a t i b l e w i t h d e c l a r a t i o n t y p e of v a r i a b l e is not r e c o r d t y p e of v a r i a b l e m u s t be file or p o i n t e r illegal parameter substitution i l l e g a l t y p e of loop c o n t r o l v a r i a b l e i l l e g a l t y p e of e x p r e s s i o n type conflict a s s i g n m e n t of f i l e s not a l l o w e d label type incompatible with selecting expression s u b r a n g e bounds m u s t be s c a l a r i n d e x t y p e must not be i n t e g e r a s s i g n m e n t to s t a n d a r d f u n c t i o n is not a l l o w e d a s s i g n m e n t to f o r m a l f u n c t i o n is not a l l o w e d no s u c h f i e l d in t h i s r e c o r d t y p e e r r o r in r e a d a c t u a l p a r a m e t e r must be a v a r i a b l e c o n t r o l v a r i a b l e m u s t not be f o r m a l m u l t i d e f i n e d case l a b e l too m a n y cases in c a s e s t a t e m e n t missing corresponding variant declaration r e a l or s t r i n g t a g f i e l d s not a l l o w e d p r e v i o u s d e c l a r a t i o n w a s not f o r w a r d again forward declared p a r a m e t e r s i z e must be c o n s t a n t m i s s i n g v a r i a n t in d e c l a r a t i o n s u b s t i t u t i o n of s t a n d a r d p r o c / f u n c not a l l o w e d multidefined label mu!tideclared label u n d e c l a r e d label undefined label e r r o r in b a s e set value parameter expected s t a n d a r d file was r e d e c l a r e d undeclared external file
121
line
250: 251: 252: 253: 254: 255: 256: 257: 258: 259:
too m a n y n e s t e d s c o p e s of i d e n t i f i e r s too many nested procedures and/or functions too many forward references of p r o c e d u r e entries procedure too long t o o m a n y long c o n s t a n t s in t h i s p r o c e d u r e t o o m a n y e r r o r s on t h i s s o u r c e line too many external references too many externals too many local files expression too c o m p l i c a t e d
398: 399:
implemented
122
PASCAL
6000-3.4
~rocedure rdr(~Aar ?: t e x t ; ~A~r x: r e a l ) ; { read real n u m b e r s in " f r e e f o r m a t ' } ~onst t48 = 281494976910656; limit = 56294995342131 ; z = 27; { ord('O ) } l i m l = 322; { maximum exponent } lim2 = -292; { minimum exponent } tvme posint = 0..323; v a ~ c h : c h a r : y: r e a l ; a,i,e: integer: s,ss: boolean: { signs }
function ten(e: posint): real; ~ a r i: i n t e g e r ; t : real; ~agln i := O; t := 1 . 0 ; ~#~ea& ~ odd(e) ~hen ~ a i af O: t := t * 1 . 0 e l ; 1: t := t * 1 . 0 e 2 : 2: t := t * 1 . 0 e 4 ; 3: t := t * 1 . 0 e 8 ; 4: t := t * 1.0e16; 5: t := t * 1 . 0 e 3 2 ; 6: t := t * 1.0e64; 9: t := t * 1.0e128; 8: t := t * 1,0e256 and : e := e ~ i v 2; i := i+I ~ e = O; ten := t en~ ; ~eein
= lO**e,
0<e<322
if eof(f) ~hen
be~in message ( "**tried halt to read past eos/eo?');
eof(f))
do
get(f);
begin
ch if := ft ; ch = benin s ~hen := t r u e :
get(f);
ch
:= ft
and e l ~
b e o i n s := f a l s e ; if eh = "+ t h e n ]~egi6 get (f): ch
:-- f~
and end :
123
] ) then t expected');
halt;
g e t (f);
then else := ft
a e
:= l O ~ a := e + 1 ;
+ ord(ch)-z
unil if_ ch
beoin
Kbite
D~oin
eh i n
[ 0..
9']
do
; e := e-1
end
ead ; i c h = "e" t h e n be~in { read scale i := 0;
factor
} get(f):
ch
:=
fT ;
if
ch =
"-"
thell
be-qill s s := t r u e ; get(f); c h := f~ and ela~ b a a / / & s s := f a l s e ; i f c h = "+" ~ a ~ h a ~ i z l g e t (f): c h := fT and end ; ~hil_~ ch in [ "0'..'9"] do bg__qin i f i < l i m i t then bemin i := I 0 - i + o r d ( c h ) - z e13~;
~ e t ( f ) ; ch
:=
ft
and ; i f s s i h a n e := e - i a ~ e := e + i ; and ; i f e < lira2 ~h@q beqin a := O: e := 0 end ~lse i f e > l i m l the[l be&Lie m e s s a z e ( ' ~ ' ~ n u m b e r t o o l a r g e ' ) ; halt { 0 < a < 2"~'-49 } i f a > = t q U ~ h e n y := ( ( a + 1 ) d i v 2) ~ 2 . 0 e l s e y := a ; i f s t h e n y := - y : e < 0 t h e n x := y / t e n ( - e ) i_f e < > 0 t_h2Jl x := y ~ t e n ( e ) e l s e x := y ; and ; end ;
end;
124
[ PASCAL
6000-3.4
~racedure wre(var f:text; x: reel; n: i n t e g e r ) ; { write real n u m b e r x in n c h a r a c t e r s } ~st t48 = 281474976710656; [ 2**48 } realt48 = 2,81474976710656e14; z = 27: { ord('O') } tYPe posint : 0..323; c,d.e,eO,el,e2,i: integer; ~WJ3~tio~ ten(e: posint): real; ~ i: i n t e g e r ; t : real; ~ i : : O; t : = 1 . 0 ; ~eoBat i ~ o d d ( e ) ~hg~_~ ~ a s e i ~_[ O: t := t * 1 . 0 e l ; I: t := t * 1 . 0 e 2 : 2: t := t * 1 . 0 e 4 ; 3: t := t * 1 . 0 e 8 ; 4: t :: t * 1.0e16; 5: t := t * 1 . 0 e 3 2 ; 6: t := t * 1 . 0 e 6 4 ; 7: t := t * 1 . 0 e 1 2 8 ; 8: t := t * 1 . 0 e 2 5 6 end ; e := e ~J~3L 2; i := i+I ~ntil e : O; t e n := t end { ten } ;
{ 10**e. 0<e<322 }
bF..g.iZl { at l e a s t 10 c h a r a c t e r s needed: b+9,9e+999 if u n d e f i n e d ( x ) then b e a i n f o r i : = 1 t ~ n - 1 d ~ b e a i n ft ::" "; p u t ( f ) ft :='u ; p u t ( f ) end al~a i f x =0 t h ~ a h ~ ~Zhil: n > I W o bg~w.in ft := " "; p u t ( f ) ; n : = n-1 end ; ft : = 0 ; put(f)
} end;
baaia if n <= 10 ~ h e n n : = 3 eZ~_~ n : = n - 7 ; react f~ := ; put(f); n := n-1 until n <: 14: { 2 <: n <: 14 : n u m b e r of d i g i t s t o be p r i n t e d beqin { test sign, then obtain exponent } iJ[ x < 0 t h e n b e a i n ft .= - 0 put(f); x := -x OD~ e l s e b~_q~n ft :: " "; ~ut(f) end; e :: expo(x) * 7 7 d~AL 2 5 6 ; { "1og(2) } if e >: 0 then ~eq!n e :: e+1; x := x/ten(e) e n d e l s e x := x * t e n ( - e ) ; w h i l e x < 0,I d o b~_qin x := 1 0 . O - x ; e := e-1 end ;
125
{ 0 . 1 <= x < 1.0 } case n o { rounding } 2: x := x+O.5e-2; 3: x := x+O.5e-3; 4 : x :-- x + O . 5 e - 4 ; 5: x := x + O . 5 e - 5 ; 6: x := x + O . S e - 6 ; ?: x := x + O . S e - ? ; U: x := x + O . 5 e - 8 ; 9: x := x + O . S e - 9 ; 1 0 : x := x + O . S e - l O ; 11: x := x+O.Se-11; 12: x := x+O.5e-12; 13: x := x+O.5e-t3; 14: x := x+O.5e-14 e~ ; if x >= 1.0 ~hen pekin x := x * 0 . 1 ; e := e + 1 end ; c := trunc(x~eait48); c := 10-c; d := c d~v t48; ff := chr(d+z); put(f); ff := " "; put(f); f o ~ i := 2 J&~ n d o begLn c := ( c " - d . t 4 8 ) * 10; d := f~ := c h r ( d + z ) ; put(f) end ; f~ := "e'; put(f); e := e - l ; i e < 0 then beoin f~ = . ": put(f)~ -= end else beoin ft := ~ "+ ; put(f) el := e * 205 div 2048; e2 := e eO : = e l * 2 0 5 d&3L 2 0 4 8 7 et := el ff := chr(eO+z); put(f), ff := chr(el+z); put(f); ff := chr(e2+z); put(f)
end end =rid { wr }
d~v
t48;
-~;
~NOEX
always the chapter n u m b e r , x 2 may b e a c a p i t a l letter in case i t may be f o l l o w e d by x3, a number, and refer~s to s section. When x 2 i s a s m a l l letter, the reference is a when x2 is a number, the reference is a program.
alfa (PASCAL 6 0 0 0 - 3 . 4 ) 13.D.1 array types 6 assignment statement 4.A binary tree 11.A block 0 BNF d e f i n i t i o n s Appendix D Boolean 2.A case statement 4.D.2 char 2.D character sets 13.8.3 comment 1 compound statement 4.R compile# error messages 14.C . 1 , Appendix compiler options (PASCAL 6 0 0 0 - 3 . 4 ) 13.B conditional statements 4.D constant declaration part 3.C control statements (PASCAL 6 0 0 0 - 3 , 4 ) 14.A control variable 4.C.3 data types 2 declaration part 3 empty statement 4.B equivalence 2.A expression 4.A
i d e n t i f i e r s , table of s t a n d a r d Appendix C if s t a t e m e n t 4,D.I implication 2.A input 9.B integer 2.B I /0 12 field list ? figures after (list insertion) I0.C a l t e r n a t i v e r e p r e s e n t a t i o n of standard symhols ASCII character set (with CDC's ordering) 13.a before (list insertion) 10.b block s t r u c t u r e O.b binary tree structure 11.b CDC s c i e n t i f i c character set (with 64 elements) expressions 11.a identifier 1.a linked list 10.a
syntax diagram of program structure O.a
13 .b
13 .a
127
two s a m p l e people 7.a u n s i g n e d number 1.b file types 9 13.B .1 e x t e r n a l files (PASCAL 0000-3.4) 13.A .1 s e q m e n t e d files (PASCAL 6 0 0 0 - 3 . 4 ) 13 .D .2 r e p r e s e n t a t i o n in PASCAL 6 0 0 0 - 3 . 4 textfiles 9.A for s t a t e m e n t 4.C.3 forward r e f e r e n c e 11.C functions 11.B d e c l a r a t i o n part 3.F designator 11,D heading 11,B p r e d e f i n e d (PASCAL 6000-3.4) 13.D.2) s t a n d a r d , table of Appendix A global v a r i a b l e s 11.A goto s t a t e m e n t 4.E labels case 7.A declaration part 3.B goto 3 . B . 4~E lists (linked) 10 local v a r i a b l e s 11.A name p r e c e d e n c e 11.A notation I numbers I operator p r e c e d e n c e 18,A o p e r a t o r s , s u m m a r y of Appendix B output 9.B Pecked structures 6 parameters 11.A PASCAL 6 0 0 0 - 3 . 4 13, 14 pointer types 10 procedures 11.A d e c l a r a t i o n part 3.F 13 .A .2 external p r o c e d u r e s (PASCAL 6000-3.4) heading 11.A p r e d e f i n e d (PASCAL 6 0 0 0 - 3 . 4 ) 13.D.2 s t a n d a r d , table of Appendix A p r o c e d u r e statement 11.A programs and p r o g r a m parts beginend 4.1 bisect 11.6 complex 7.1 convert 3.1 cosine 4.5 egalfa 13.1 egfor 4.4 egrepeat 4,3 egwhile 4.2 exponentiation 4.8 expon2 11.8 examples of goto 4.E forward reference 11,C frequency count 9.1 graph1 4.9 graph2 6.2
128
inflation 0.1 insert 9.2 matrixmul 6.3 minmax 6 .I minmax2 11 ,I minmax3 11 .2 parameters 11.3 primes 8.2 pointers, construction via 10 merge two files 9 postfix 11 .4 recursivegcd 1 1 .9 roman 4 .? setop 8.1 sideffect 11 . 7 sum f i l e of real numbers 9 summing 4.6 tree traversal 11.5 program heading 3.A (PASCAL 6 0 0 0 - 3 . 4 13.B.1) record types ? repet ire statements 4.C reserved words--see word-delimiters restrictions (PASCAL 6 0 0 0 - 3 . 4 ) 13.C read. the standard procedure 12.A real 2 .C relational operator 2.A, 4 . A repeat statement 4.0.2 run-time error messages 14.C .2 scalar types 5.A schemata read a text 9.A read a text from "input" 9.A reading arbitrary number of numerical items from a textfile reading a segmented file 1 3 . A .1 reed and write a se;mented file 13.A.1 write a text 9.A write a text x to y 9.A write a text onto "output" 9.A w r i t e a s e g m e n t e d file 13,A.I scope O separators I set o p e r a t o r s 8 set t y p e s 8 side effect 11,B standard identifiers Appendix C string 1 6 subrange types 5,B syntax diagrams Appendix D tables block structure 0 d e f a u l t v a l u e for f i e l d w i d t h 13.B.4 o p e r a t i o n s on t e x t f i l e s 9.A printer control characters 9.B, 13.B .4 special symbols I truth values 2.A
129 type--also see d a t a t y p e s declaration part 3.D 13 D .1 predefined (PASCAL 6 0 0 0 - 3 . 4 ) 13 .B .3 s t a n d a r d (PASCAL 6 0 0 0 - 3 . 4 ) variable d e c l a r a t i o n part 3.E vocabulary I while s t a t e m e n t 4.C.I with s t a t e m e n t 7.A w o r d - d e l i m i t e r s , table of Appendix C write, the s t a n d a r d p r o c e d u r e 12.B (PASCAL 6000-3.4 13.8.4)
REPORT
~reface
to
t~e
Revised
Repot&
The language PASCAL has now been in use for several years, during which considerable experience has been gained through its use, its teaching, and its implementation. Although many r e a s o n s suggest that a language should be k e p t u n c h a n g e d as s o o n as i t has gained a user community, it w o u l d be u n w i s e to ignore this experience and to refrain from making good use of it. This Report therefore describes a revised language which included some changes s u g g e s t e d by t h e w o r k o f t h e l a s t t w o y e a r s . It is still of the form of the original definition, a n d in f a c t t h e changes are very few and relatively minor. They concern the following subjects :
-
Constant sense of
are
replaced
by
value
parameters
(in
the
The class structure is eliminated: pointer variables bound to a data type instead of a c l a s s v a r i a b l e . The handling of files variable f~ always has condition e o f ( f ) is t r u e . is a changed defined such value
are
Packed records end packed arrays are introduced. As a consequence, the type ella becomes a special c~se of a packed character array. The generalization has some consequences on the denotation o s t r i n g s (formely called alfa constants). Programs require parameters. All labels require a program heading with external f i l e s as
Moreover. renaming
of
Implementation efforts on various computers have brought the problem of portability and machine i n d e p e n d e n c e of s o f t w a r e systems to our closer attention. Nlany of t h e a b o v e m e n t i o n e d changes, and also some additional restrictions, were adopted and imposed in the interest of program portability and machine independent definability. T h e y m a d e ~t p o s s i b l e to define almost the entire language by e set of abstract axioms a n d r u l e s of inference. Such a rigorous definition is n e c e s s a r y to be a b l e to prove properties of proorams. This rigour and machine independence has n o t a b l y been achieved without s a c r i f i c e in t h e efficiency of program execution. In o r d e r to p r o v i d e a c o m m o n base for implementations on v a r i o u s computers, the language defined in t h i s R e v i s e d R e p o r t is c a l l e d ~tand&r~ ~E~j&A~, This standard is d e f i n e d in t e r m s of t h e I S O character set. The chapter on PASCAL f o r the CDC 6 0 0 0 computer has been removed
134
from
the
Report
and r e p l a c e d
by a general
chapter
on s u g g e s t e d
standards for implementation and program interchange. This standard specifies ways to represent programs in t e r m s of available c h a r a c t e r s e t s , a n d l i s t s a n u m b e r of r e s t r i c t i o n s on the language with the i n t e n t of s i m p l i f y i n g implementations. Programs to be used on several computers where P A S C A L is available s h o u l d a d h e r e to t h i s s t a n d a r d . The two procedures Kead and ~rite together with the new procedures readln, w r i t e l n , a n d eoln h a v e b e e n i n c l u d e d in t h e set of standard p r o c e d u r e s a n d a r e d e s c r i b e d in a new C h a p t e r 12. T h e y n o w c o n s t i t u t e a b i n d i n g s t a n d a r d for l e g i b l e input a n d output. T h e l a t t e r t h r e e a r e u s e d to c o n t r o l t h e l i n e s t r u c t u r e of text files, and have become necessary, b e c a u s e the S t a n d a r d language cannot depend on the existence of a ~ine control charccter (eol) in t h e c h a r a c t e r s e t .
~efereoces N. W i r t h ,
PASCAL".
ACTA
Programmieren",
Teubner
1972.
Prentice-Hall,
Prooramming",
Englewood C .A .R .
Hoare and N .
Cliffs,
"An
1973.
Axiomatic Definition of t h e
Wlrth,
Programming INFORMATICA,
N. Wirth.
2,
Language 335-355.
PASCAL", (1973).
ACTA
Compiler", !, 309-333
135
Contents
I. I n t r o d u c t i o n 2. Summary 3. Notation, of the language terminology, Numbers, and vocabulary and Strings
4. I d e n t i f i e r s ,
5.
Constant
definitions
6. Data type definitions 6.1. Simple types 6.2. Structured types 6.3. Pointer types
7.
of v a r i a b l e s
8. E x p r e s s i o n s 8.1. Operators U.2. F u n c t i o n d e s i g n a t o r s 9. S t a t e m e n t s 9.1. Simple statements 9.2. Structured s t a t e m e n t s 10. 11, Procedure declarations 10.1. Standard procedures Function declarations 11.1 Standard functions and Output
Programs and
136
I. I n t r o d u c t i o n
The development of the l a n g u a g e ~ a s c a l is b a s e d on t w o p r i n c i p a l aims. The first is t w o m a k e a v a i l a b l e a l a n g u a g e s u i t a b l e to teach programming as a systematic d i s c i p l i n e b a s e d on c e r t a i n fundamental concepts clearly and naturally r e f l e c t e d by t h e language. The second is to develop implementations of t h i s language which are both reliable a n d e f f i c i e n t on p r e s e n t l y available computers. The desire for a new language for t h e p u r p o s e of t e a c h i n g programming is due to my d i s s a t i s f a c t i o n with the present]y used major languages w h o s e f e a t u r e s and c o n s t r u c t s too often cannot be e x p l a i n e d logically and convincingly a n d w h i c h t o o o f t e n defy systematic reasoning. Along with this dissatisfaction goes my conviction that the l a n g u a g e in w h i c h t h e s t u d e n t is t a u g h t to express his ideas profoundly i n f l u e n c e s his h a b i t s of t h o u g h t and invention, and that the disorder governing these languaRes directly imposes itself onto the programming style of t h e students. There is of course plenty of r e a s o n to be c a u t i o u s w i t h t h e introduction of yet another programming language, and the objection against teaching p r o g r a m m i n g in a l a n g u a g e w h i c h is not widely used and accepted has undoubtedly some justification, at least based on short term commercial reasoning. H o w e v e r , t h e c h o i c e of a l a n g u a g e for t e a c h i n g b a s e d on its w i d e s p r e a d acceptance and availability, together with the fact t h a t t h e l a n g u a g e m o s t w i d e Z y t a u g h t is t h e r e a f t e r g o i n g to be the one most widely used, forms the s a f e s t r e c i p e for stagnation in a s u b j e c t of s u c h p r o f o u n d p e d a g o g i c a l influence. I consider it therefore well worth-while to m a k e an e f f o r t to break this vicious circle, Of course a new l a n g u a g e s h o u l d not be d e v e l o p e d just for t h e sake of novelty; e x i s t i n g l a n g u a g e s s h o u l d be u s e d as a b a s i s for d e v e l o p m e n t w h e r e v e r t h e y m e e t t h e c r i t e r i a m e n t i o n e d a n d do not impede a systematic structure. In t h a t s e n s e A l g o l 60 w a s used as a basis for P a s c a l , s i n c e it m e e t s t h e d e m a n d s w i t h respect to teaching to a much h i g h e r d e g r e e t h a n any o t h e r standard language. Thus the principles of s t r u c t u r i n g , a n d in fact t h e f o r m of e x p r e s s i o n s , a r e c o p i e d f r o m A l g o l 60, It w a s , however not d e e m e d a p p r o p r i a t e to a d o p t A l g o l 60 as a s u b s e t of Pascal: certain construction princ~p!e~.particulerly t h o s e of declarations, w o u l d have b e e n i n c o m p a t i b l e with those allowin~ a natural and convenient representation of t h e a d d i t i o n a l features of P a s c a l , The main extensions r e l a t i v e to A l g o l 60 lie in t h e d o m a i n of data structuring facilities, s i n c e t h e i r l a c k in A l g o l 60 was considered as t h e p r i m e c a u s e for its r e l a t i v e l y n a r r o w r a n g e of applicabil~ty. The introduction of r e c o r d and f i l e s t r u c t u r e s should make it p o s s i b l e to s o l v e c o m m e r c i a l t y p e p r o b l e m s w i t h Pascal, or at least to e m p l o y it s u c c e s s f u l l y to d e m o n s t r a t e such problems in a p r o g r a m m i n g course.
137
2.
Summary
of
the
language
An algorithm or computer program consists of t w o e s s e n t i a l parts, a description o ~tiw_o_& which are to be performed, and e description of the #ata, which are manipulated by these actions. Actions are described by so-called &~q~_Ements, and data are described by so-called ~clara~on~ and ~#finitions.
The data are represented by values of variables. Every variable occurring in a statement must be introduced by a ~ a r i a b l ~ ~ ~ o n which associates an i d e n t i f i e r and a data type with that variable. The ~at& ~voe essentially d e f i n e s t h e s e t of v a l u e s w h i c h m a y be a s s u m e d by t h a t v a r i a b l e . A d a t a t y p e m a y in P a s c a l be e i t h e r directly described in t h e v a r i a b l e declaration, or it m a y be r e f e r e n c e d by a t y p e i d e n t i f i e r , in w h i c h case this identifier m u s t be d e s c r i b e d by an e x p l i c i t ~voe definition.
The basic data types are the &calar types. Their definition indicates an o r d e r e d s e t of v a l u e s , i.e. introduces identifiers standing for each value in t h e s e t . A p a r t from the definable scalar types, there exist four ~tandar~ #asi& ~voes : ~oolean, integer, ghar, and ~ealo Except for t h e t y p e B o o l e a n , their values are not d e n o t e d by i d e n t i f i e r s , but instead by n u m b e r s and quotations respectively. These are syntactically distinct from identifiers. The set of values of type char is t h e character set available on a p a r t i c u l a r installation.
A type indicating
may also be d e f i n e d as a subranoe of a scalar type by the smallest and the largest value of the subrange.
~truc[ured ty_&es are defined by d e s c r i b i n g t h e t y p e s of t h e i r components and by i n d i c a t i n g a ~tructuriQ&__metho~. The various structuring methods d i f f e r in t h e s e l e c t i o n mechanism s e r v i n g to select the c o m p o n e n t s of a v a r i a b l e of t h e s t r u c t u r e d t y p e . In Pascal, there are four basic structuring methods available: array structure, record structure, set structure, and file structure. In an ~_~av ~tructure, all components are of the same type. A component is s e l e c t e d by an a r r a y s e l e c t o r , or ~ U ~ m u t a b l e i~!, whose type is i n d i c a t e d in t h e a r r a y t y p e d e f i n i t i o n and which must be s c a l a r . It is u s u a l l y a programmer-defined scalar type, or a subrange of the type integer. Given a value of the index type, an array selector y i e l d s a v a l u e of t h e c o m p o n e n t type. Every array variable can therefore be r e g a r d e d as a m a p p i n g o f the index type onto the component t y p e . T h e t i m e n e e d e d for a selection d o e s not d e p e n d on t h e v a l u e of t h e s e l e c t o r (index). The array structure is therefore celled a ~ando~-~~_~ess ~Jj2u c t ur_~. In a ~#__~d s ~ _ ~ u c t u r e , the components (called ~ield&) are not necessarily of the same type. In order t h a t t h e t y p e of a selected component be evident from the program text (without executing the program), a record selector is n o t a c o m p u t a b l e value, but instead is an identifier uniquely denoting the component to be selected. These component identifiers are
138
declared in the record type definition. Again, the time needed to a c c e s s a s e l e c t e d c o m p o n e n t does not d e p e n d on t h e s e l e c t o r , a n d t h e r e c o r d is t h e r e f o r e a l s o a r a n d o m - a c c e s s structure. A record type may be specified as consisting of several ~ariaots. This i m p l i e s t h a t d i f f e r e n t v a r i a b l e s , althought said to be of t h e s a m e t y p e . may a s s u m e s t r u c t u r e s w h i c h d i f f e r in a c e r t a i n m a n n e r . T h e d i f f e r e n c e m a y c o n s i s t of a d i f f e r e n t n u m b e r and d i f f e r e n t t y p e s of c o m p o n e n t s . The v a r i a n t w h i c h is a s s u m e d by t h e c u r r e n t v a l u e of a r e c o r d v a r i a b l e m a y be i n d i c a t e d by a component field which is c o m m o n to a l l v a r i a n t s a n d is c a l l e d the ~aofie~. Usually. the p a r t c o m m o n t o all v a r i a n t s w i l l c o n s i s t of s e v a r a l c o m p o n e n t s , including the tag field. A ~ u c t u r e defines of its b a s e t y p e . i.e. base type. The base type be a programmer-defined integer. t h e s e t of v a l u e s w h i c h is t h e p o w e r s e t t h e s e t of a l l s u b s e t s of v a l u e s of t h e m u s t be a s c a l a r t y p e . a n d w i l l u s u a l l y s c a l a r t y p e or a s u b r a n g e of the t y p e
A ~ile_~ruc~_W~ is a ~W_g3&~O~e of c o m p o n e n t s of t h e s a m e t y p e . A natural ordering of the components is defined t h r o u g h the sequence. At any instance, only one component is d i r e c t l y accessible. The other components are made accessible by progressing sequentially t h r o u g h t h e f i l e . A f i l e is g e n e r a t e d by sequentially appending c o m p o n e n t s at its e n d . C o n s e q u e n t l y . the file type definition does not determine t h e n u m b e r of components, Variables declared in e x p l i c i t declarations are called ~atic, The d e c l a r a t i o n a s s o c i a t e s an i d e n t i f i e r w i t h t h e v a r i a b l e w h i c h is u s e d to r e f e r to t h e v a r i a b l e . In e o n s t r a t , v a r i a b l e s may be generated by an e x e c u t a b l e s t a t e m e n t . S u c h a ~ m i ~ generation yields a so-called ooi~te~ (a subtstitute for an e x p l i c i t identifier) w h i c h s u b s e q u e n t l y s e r v e s to r e f e r to t h e v a r i a b l e . This pointer may be assigned to other variables, namely variables of type oointer. Every pointer variable may assume values p o i n t i n g to v a r i a b l e s of t h e s a m e t y p e T o n l y , a n d it is said to be h ~ d to t h i s t y p e T. It m a y , h o w e v e r , a l s o a s s u m e the value ~ . which points to no v a r i a b l e . Because pointer variables may a l s o o c c u r as c o m p o n e n t s of s t r u c t u r e d variables, which are themselves dynamically # e n e r a t e d , t h e u s e of p o i n t e r s permits the representation of f i n i t e B r a p h s in full g e n e r a l i t y . The most fundamental statement is the ~ i ~ m e n t _ ~ a t e m e n t . It specifies t h a t a n e w l y c o m p u t e d v a l u e be a s s i g n e d to a v a r i a b l e (or components of a variable). The value is obtained by evaluating an ~xoressio~. Expressions consist of v a r i a b l e s , constants, sets, operators and functions operating on the denoted quantities and producing new values. Variables, constants, and f u n c t i o n s a r e e i t h e r d e c l a r e d in t h e p r o g r a m or are standard e n t i t i e s . P a s c a l d e f i n e s a f i x e d s e t of o p e r a t o r s , each of w h i c h can be r e g a r d e d as d e s c r i b i n g a m a p p i n g from t h e operand types into the result t y p e . The set of o p e r a t o r s is subdivided i n t o g r o u p s of I. ~r_~t hM @~ ie operators of addition, subtraction, sign
139
inversion, remainder. 2. ~olean multiplication, division, and computinc the
operators
of
negation,
union
(or),
and
conjunction
(and).
3. 4. ~et ~oerators of u n i o n , intersection, and set difference. ordering, set of r e l a t i o n a l
The & r o ~ ~ ~ causes the execution of the designated procedure (see below). Assignment and procedure statements are the components or building blocks of ~ u c t u r e d ~tatemeots, which specify sequential, s e l e c t i v e , or r e p e a t e d e x e c u t i o n of their components. Sequential e x e c u t i o n of statements is specified by the ~omeo~ ~tatement, c o n d i t i o n a l or s e l e c t i v e execution by the if &tatemen[ and the ~&~_~ ~ t a t e m e o t , and repeated e x e c u t i o n by t h e ~ # # e ~ t ~ t a t e m e o t , t h e ~ h i ! e &tatemeoj~, and the ~ &~atement. The if s t a t e m e n t s e r v e s to m a k e t h e execution of a statement d e p e n d e n t on t h e v a l u e of a O o o l e a n expression, and the case statement allows for the selection among many statements a c c o r d i n g to t h e v a l u e of a s e l e c t o r . The for statement is used when t h e n u m b e r of i t e r a t i o n s is k n o w beforehand, and the repeat and while statements are used otherwise. A statement can be g i v e n a n a m e ( i d e n t i f i e r ) , a n d be r e f e r e n c e d through that identifier. The statement is then called a orocedur_~, and its d e c l a r a t i o n a ~rocedur~ ~laration. Such a declaration may additionally contain a set of variable declarations, type definitions and further procedure declarations. The v a r i a b l e s , types end procedures thus declared can be referenced only within the procedure ~tself, and are therefore c a l l e d ~ o c a l to t h e p r o c e d u r e . Their identifiers have significance only within the program text which constitutes the procedure declaration and which is c a l l e d t h e & ~ o o e of t h e s e identifiers. Since procedures may be d e c l a r e d l o c a l to o t h e r procedures, s c o p e s may be n e s t e d . E n t i t i e s w h i c h a r e d e c l a r e d in the main p r o g r a m , i.e. not l o c a l to s o m e p r o c e d u r e , are called ~lobal. A procedure has a f i x e d n u m b e r of p a r a m e t e r s , each of which is denoted within the procedure by an i d e n t i f i e r called the ~ a l ~arameter. Upon an activation of the procedure statement, an actual quantity has to be i n d i c a t e d for e a c h parameter which can be referenced from within the procedure through the formal parameter. T h i s q u a n t i t y is c a l l e d t h e #ctu@.~ ~aram~j~W_~, There are three kinds of parameters: value parameters, variable parameters, and procedure or function parameters. In the first case, the actual p a r a m e t e r is an expression which is evaluated once. The formal parameter represents a local variable to which the result of this evaluation is a s s i g n e d b e f o r e t h e e x e c u t i o n of t h e p r o c e d u r e (or function). In the case of a variable parameter, the actual parameter is a v a r i a b l e a n d t h e f o r m a l p a r a m e t e r s t a n d s for t h i s variable. P o s s i b l e i n d i c e s a r e e v a l u a t e d b e f o r e e x e c u t i o n of t h e procedure (or function). In t h e c a s e of p r o c e d u r e or f u n c t i o n
140
parameters, identifier. the actual parameter is procedure or function
~unctions are declared analogously to procedures. The o n l y difference lies in the fact that a function yields a result which is confined to a scalar or p o i n t e r t y p e a n d must be specified in t h e f u n c t i o n d e c l a r a t i o n . F u n c t i o n s may t h e r e f o r e be used as c o n s t i t u e n t s of e x p r e s s i o n s . In o r d e r to e l i m i n a t e side-effects, assignments to non-local variables should be avoided within function declarations.
3. N o t a t i o n ,
terminology,
and
vocabulary
According to traditional Backus-Naur form. syntactic constructs are denoted by English words enclosed between the angular brackets < and > . These w o r d s also d e s c r i b e t h e n a t u r e or meaning of the construct, and are used in the accompanying description of s e m a n t i c s . P o s s i b l e r e p e t i t i o n of a c o n s t r u c t is indicated by e n c l o s i n g t h e c o n s t r u c t w i t h i n m e t a b r a c k e t s { and } . The s y m b o l < e m p t y > d e n o t e s t h e null s e q u e n c e of s y m b o l s . The basic classified vocabulary of Pascal consists into letters, digits, and special of basic symbols. symbols
<letter>
::=
<digit> : : = OI 11213141 5161 7 1 8 1 9 <special symbol> : := + II * I t I = <> 1 I < t > <= t >= I ( I ) t I [ 1 ] 1 { I }:= II 1, 1 : i : I " t di_v. I I f mad I nil I i n I o n I a n d I not I i f I ~ a ~ n f a S s e i ca.~e 1 o I r_eoeat I until I while I do I fan I to 1 dg_~DJ~o I b e a i n I e n d I wiJih I ~ o t o I ~ o n s t I v~j~ I t y p e I a r r a y ~ ~#-~J&r-~ I s.i I f i l e I f u n c t i o n I P_Qced~u~e I l a b e l I ~acd2#_~ ~ ~ m o ~ r a m
The c o n s t r u c t { < a n y s e q u e n c e of s y m b o l s not c o n t a i n i n g "}"> } may be i n s e r t e d b e t w e e n a n y t w o i d e n t i f i e r s , n u m b e r s (cf. 4), or special s y m b o l s . It is c a l l e d a ~ o m m e n t and may be r e m o v e d from the p r o g r a m t e x t w i t h o u t a l t e r i n g its m e a n i n g . The s y m b o l s { and } do not o c c u r o t h e r w i s e in t h e l a n g u a g e , a n d w h e n a p p e a r i n g in syntactic descriptions they are m e t e - s y m b o l s l i k e I and ::= The s y m b o l p a i r s (~ and *) a r e u s e d as s y n o n y m s for { a n d } .
4. I d e n t i f i e r s ,
Numbers,
and
Strings
Identifiers serve to denote constants, types, variables, procedures and functions. Their association must be u n i q u e within their scope of v a l i d i t y , i.e. w i t h i n t h e P r o c e d u r e or function in which they are declared ( o f . 10 a n d 1 1 ) .
141
<identifier> ::= < l e t t e r > { < l e t t e r Or d i g i t > } <letter or d i g i t > : := < l e t t e r > I <digit> The usual decimal n o t a t i o n is u s e d constants of the data types inteoer letter E preceding the scale factor to t h e p o w e r of". for numbers, which are the and ~&l (see 6.1.2.). The is p r o n o u n c e d as " t i m e s 10
<digit sequence> ::= < d i g i t > { < d i g i t > } <unsigned integer> : := < d i g i t sequence> <unsigned r e a l > ::= < u n s i g n e d integer>.<digit sequence> <unsigned integer>.<digit sequence>E<scale factor> <unsigned integer> E <scale factor> <unsigned n u m b e r > ::= < u n s i g n e d integer> I <unsigned real> <scale factor> ::= < u n s i g n e d integer> I <sign><unsigned integer> <sign> ::= + I Examples 1
:
100
O. I
5E-3
8 7 . 3 5 E +8
of characters enclosed by quote mmrks a r e c a l l e d Strings consisting of a single character are the of the standard type char (see 6.1.2). Strings of n (>1) e n c l o s e d c h a r a c t e r s are the constants of (see 6.2.1) [1..hi
aZ
&ac~.~t array
Note:
char
mark, then this quote
'
Examples
5. C o n s t a n t
definitions
A constant constant.
definition
introduces
an
identifier
as
a synonym
to
<constant identifier> ::= < i d e n t i f i e r > <constant> ::= < u n s i g n e d number> ~ <sign><unsigned number> <constant identifier> ] <sign><constant identifier> I <string> <constant definition> ::= < i d e n t i f i e r > = <constant>
142
6. D a t a
type
definitions
< t y p e > ::= < s i m p l e t y p e > I < s t r u c t u r e d t y p e > < t y p e d e f i n i t i o n > ::= < i d e n t i f i e r > = < t y p e >
6.1.
S i m o Z ~ ~y_a_~ ::= < s c a l a r t y p e > I < s u b r a n g e <type identifier> i d e n t i f i e r > ::= < i d e n t i f i e r > types by enumeration of type> type> I
Sr~ar
A scalar
the
<scalar
{.<identifier>}
Examples: (red, o r a n g e , y e l l o w , g r e e n , blue) (club. d i a m o n d , h e a r t , s p a d e ) (Monday j Tuesday, Wednesday, Thursday, Saturday, Sunday) Functions
SUCC
Friday.
applying
to all
scalar
types
(except
real)
are
pred
6.1.2.
The f o l l o w i n g integer
types
The values are a subset of t h e w h o l e n u m b e r s d e f i n e d by i n d i v i d u a l i m p l e m e n t a t i o n s . Its v a l u e s are the i n t e g e r s (see 4). Its values are a subset of the r e a l n u m b e r s depending on the p a r t i c u Z a r i m p l e m e n t a t i o n . The v a l u e s a r e d e n o t e d by r e a l n u m b e r s (see 4). Its values identifiers are true the truth and f a l s e . values denoted by the
real
Boolean
char
t43
6.1.3.
~ubr~noe
types another value bound, scalar type by in the subrange. and must not be
A type may be defined as a subrange of indication of the least and the largest The first constant specifies the lower greater than the upper bound. <subrange
Examples:
::=
<constant>
..
<constant>
+10 .. Friday
6.2.
~#_gJ~red
types
A structure type is characterised by the type(s) of its components and by its structuring method. Moreover, a structured type definition may c o n t a i n an indication of the preferred data representation. If a definition is prefixed with the symbol packed, this has no effect on the meaning of a program, but is a !lint to the compiler that storage should be economised even at the price of some loss in efficiency of access, and even if this may expand the code necessary for expressin~ access to components of the structure. <structured type> ::= <unpacked structured type> lacked <unpacked structured type> <unpacked structured type> ::= <array type> I <record type> I <set type> I <file type> I
6.2.1.
~rrav
types
An array type is a structure consisting of a f i x e d n u m b e r of components w h i c h a r e a l l of t h e s a m e t y p e , c a l l e d t h e ~_W_EJ&oeot ~yoe. The elements of the array are designated by i n d i c e s , values belonging to the so-called index ~p_~. The array type definition specifies the component t y p e as w e l l as t h e i n d e x type.
<array
type>
::=
{,<index
type>}]
types ere specified, the and a component is designated #rray #r~av #tray [ 1..100] of real [1..10,1..20] of 0..99 [Boolean] ~[ color
called
144
6.2.2.
_Rec~L~__J~vo e&
A record type is a structure consisting of a fixed number of components, possibly of different types. The record type definition specifies for each component, called a _f~, its type and an identifier which d e n o t e s i t . T h e s c o p e of t h e s e so-called f ~ identifiers is t h e r e c o r d definition itself, and they are also accessible within a field designator (ef. 7.2) referring to a r e c o r d variable of t h i s t y p e . A record type may have several variants, in w h i c h case a certain field m a y be d e s i g n a t e d as t h e ]2~_q ~ e l d , w h o s e value indicates which variant is a s s u m e d by t h e r e c o r d variable at a g i v e n t i m e . Each variant s t r u c t u r e is i d e n t i f i e d by a c a s e l a b e l w h i c h is a constant o f t h e t y p e of t h e t a g f i e l d . <record type> <field list> ::= E e e o r d <field list> end ::= < f i x e d p a r t > I < f i x e d p a r t > ; < v e r i e n t part> <variant part> <fixed part> ::= < r e c o r d s e c t i o n > [ ;<record section>} <record section> : := <field identifier>{ ,<field identifier>} : <type> I <empty> <variant part> ::= ~ a s e <tag field> <type identifier> of <variant> { ;<variant>} <variant> ::= < c a s e l a b e l l i s t > : ( < f i e l d list>) I <empty> <case label list> ::= <case label> { ,<case label>} <ease label> : := <constant> <tag field> ::= < i d e n t i f i e r > : I <empty> rWcor~[ day: 1..31; month: 1 ,,12; y e a r : Inte~qer
Examples:
and record x,y : real; area : real; ~O~ s : shape o~ trlangle: (side : real; inclination, angle1, angle2: rectangle: (sidel, skde2: real; skew, angle3: angle) ; circle: (diameter: real) and
angle);
6.2.3.
A set type defines the range of values which is the its so-called ~ ~Y.~Za. B a s e types m u s t not be types. Operators a p p l i c a b l e to a l l s e t t y p e s are:
145
+
-
* iS
<set t y p e > ::= s e t o f < b a s e t y p e > < b a s e t y p e > ::= < s i m p l e t y p e >
6.2.4.
Lila__~yoes
A file type definition specifies sequence of components which are number of components, called the fixed by t h e file t y p e d e f i n i t i o n , called ~m&&Z. <file
type>
::= f i l ~
~Z
<type>
Files with component type char are called ~extfilw_&, end are a special case insofar as t h e c o m p o n e n t r a n g e o f v a l u e s m u s t be considered as extended by a m a r k e r d e n o t i n g the end of a line. This marker allows textfiles t o be s u b s t r u c t u r e d into lines. The t y p e ~82~ i s a s t a n d a r d type predeclared as
~X~
text
= ~ile
~f
char
6.3.
~ o i n t ~ r tvoes
Variables which are declared in a program (see 7.) are accessible by their identifier, They exist during the entire execution process of the procedure (scope) to which the variable is local, and these variables are therefore celled stati~ (or statically allocated), In contrast, variables may also be generated dynamically, i,e, without any correlation to t h e structure of t h e p r o g r a m , T h e s e ~ z n a m i c v a r i a b l e s a r e g e n e r a t e d by the s t a n d a r d p r o c e d u r e ~#j~ (see 1 0 . I . 2 , ) : s i n c e t h e y do not occur in an explicit variable declaration, they c a n n o t be referred to by a name. Instead. access is achieved via a so-called &D.i~ v a l u e w h i c h is p r o v i d e d u p o n g e n e r a t i o n of t h e dynamic variable, A p o i n t e r t y p e t h u s c o n s i s t s o an u n b o u n d e d set of values pointing to elements of the same t y p e , No operations a r e d e f i n e d on p o i n t e r s e x c e p t t h e t e s t for e q u a l i t y ,
belongs
to
every
pointer
type;
it p o i n t s
::= ~ < t y p e
identifier>
146
Examples
of
type = = -= = = = =
definitions: (red, yellow, green, blue) (male, female) f~le ~_~ c h a r (triangle, rectangle, circle) ~rray [1..80] o~ char ~ a e k e d ~&rJ~eJL [ 1 , . 1 0 ] of char record re.ira: real ~nd 2ecord name, firstname: ella; age : integer; married :Boolean; father, child, sibling: fperson: case s : sex of male: (enlisted, bold: Boolean); female: (pregnant : Boolean; size: arrav[1..3] of i n t e g e r ) ea~
7. D e c l a r a t i o n s
and
denotations
of variables
of e l i s t of their type.
identifiers
denoting
<identifier>{.<identifier>}
: <type>
Every declaration of a f i l e v a r i a b l e f with components of t y p e T implies the additional declaration of a so-called ~uffer ~ariable of type T. This buffer v a r i a b l e is d e n o t e d by ft a n d serves to append c o m p o n e n t s to t h e f i l e d u r i n g generation, and to access the file during inspection (see ? . 2 . 3 . and I0.I.1.). Examples: X ,y ,Z : r e a l u,v: complex i,j: integer k: 0 . . 9 p ,q : B o o l e a n operator : (plus, minus, a : ~rJ&~L[O,.63] ~ real b: ~ r a y [ c o l o r , B o o l e a n ] c: c o l o r f: f&l~ of char huel,hue2: & a t O~ c o l o r pl p2: ~person
times) ~ complex
Denotations of v a r i a b l e s either d e s i g n a t e an e n t i r e variable, a component of a variable, or a v a r i a b l e referenced by a p o i n t e r (see 6.3). Variables occurring in examples in subsequent chapters a r e a s s u m e d t o be d e c l a r e d as i n d i c a t e d above, <variable> ::= <entire variable> I <component <referenced variable> variable> I
147
7.I. An
entire
7.2.
C prop o n ~ n t _ _ ~ a r i a b l e ~ of a v a r i a b l e specifying the structuring is d e n o t e d by t h e v a r i a b l e f o l l o w e d by the component. The form of the selector type of the variable. <indexed I <file variable> buffer> I
?.2.1.
i~g~gd
<indexed variable> ::= <array variable> [<expression> <array variable> ::= < v a r i a b l e > The types index types Examples : of the declared index in t h e
{,<expression>}]
the
a [ 12]
a[i+j] b [ r e d ,true]
?.2.2.
_Field
: .im
hired,true] p 2~ .s i z e
148
?.2.3,
Eile
~uffers
At any time, o n l y the one c o m p o n e n t d e t e r m i n e d by the c u r r e n t file position (read/write head) is d i r e c t l y a c c e s s i b l e . This component is called the current file component and is r e p r e s e n t e d by t h e f i l e ' s ~ f _ ~ ~ariable. <file <file b u f f e r > ::= <file v a r i a b l e > ~ v a r i a b l e > : := < v a r i a b l e >
7.3. ~ ~ e d
variables variable>t
If p is a pointer variable which is b o u n d to a t y p e T , p denotes t h a t v a r i a b l e a n d its p o i n t e r v a l u e , w h e r e a s p~ d e n o t e s the v a r i a b l e of t y p e T r e f e r e n c e d by m. Examples: p~ .father p I~ .sibling~ .child
8. E x p r e s s i o n s
Expressions are constructs denoting r u l e s of c o m p u t a t i o n for obtaining values of v a r i a b l e s and g e n e r a t i n g new v a l u e s by t h e application of o p e r a t o r s . E x p r e s s i o n s c o n s i s t o f o p e r a n d s , i.e. v a r i a b l e s and c o n s t a n t s , o p e r a t o r s , and f u n c t i o n s . The r u l e s of c o m p o s i t i o n s p e c i f y o p e r a t o r ~ 2 ~ ~ # ~ & according to four c l a s s e s of o p e r a t o r s . The o p e r a t o r ~ J 2 has the h i g h e s t precedence, followed by the so-called multiplying operators, then the so-called adding operators, and finally, with the lowest precedence, the relational operators. Sequences of operators of the same precedence are e x e c u t e d from left to right. The rules of p r e c e d e n c e a r e r e f l e c t e d by the f o l l o w i n g syntax:
149
::= < u n s i g n e d number> I <string> I <constant identifier> I ~il <factor> ::= < v a r i a b l e > I <unsigned constant> 1 <function designator> I <set> I (<expression>) I ~ot <factor> < s e t > ::= [ < e l e m e n t list> ] <element l i s t > ::= < e l e m e n t > {,<element>} I <empty> <element> ::= < e x p r e s s i o n > I <expression>..<expression> < t e r m > ::= < f a c t o r > I < t e r m > < m u l t i p l y i n g operator><factor> <simple expression> ::= < t e r m > I <simple expression> <adding operator><term> I <adding operator><term> <expression> ::= < s i m p l e e x p r e s s i o n > I <simple expression><relational operator><simple expression> Expressions which a r e m e m b e r s o f a s e t m u s t a l l be of t h e s a m e type, which is t h e b a s e t y p e of t h e s e t . [] d e n o t e s t h e e m p t y set, and [x.,y] d e n o t e s t h e s e t of a l l v a l u e s in t h e i n t e r v a l
X,o.y ,
<unsigned
constant>
Examples: Factors:
X
Terms :
x *y
i/(1-i)
p nz q (x<=y) ~[ (y < z )
Simple
expressions
Expressions:
8.1.
09..~r3.tors
not
150
The
operator
denotes
negation
of
its
Boolean
operand.
8.1.2.
~ul&iolyinQ
<multiplying
operator>
Ioperatorl
operation
t y p eof o p e r a n d s
type of resultI
real,
integer
T
real integer
/ dlv
mod
integer Boolean
integer Boolean
and
8,1.3.
<addinc
Ioperatorl
operation
I type
of o p e r a n d s
) type
of r e s u l t l
..............................................................
I
1
I
I addition set union
I
I integer, real I any set type T
I
1 integer, ~ T reel
I
1 I
I I I I I I
I
I subtraction I set difference
I
] integer, real I a n y set t y p e T
I
I integer, I T real
I
I I
I
] logical "or"
I
] Ooolean
I
I Boolean
I
I
I
- denotes
I
sign
as operators with one operand only, and + denotes the identity operation.
~3.I.4. _ R e l a t i o n a l
<relational
operator>
151
operator
type
of
operands
result
I
l
=
<
<>
>
T
l any scalar or subrange type
I
I Boolean
T
I
I I
I
<-->=
! T
I any I and
scalar
l 1
its set or s u b r a n g e t y p e I type respectivelyl Boolean
I i
I
I in I
Notice
that
all
scalar
types
define ordered
sets
of v a l u e s .
The operators <>. < = . >= s t a n d for unequal, less or equal,and oreater or equal respectively. The operators <= a n d >= may a l s o be used for comparing values of set type. and then denote set inclusion. tf p and q are Boolean expressions, p = q denotes their
<=
q denotes
im#llcation
of q by p.
(Note
operators arrays
= with
denote of t h e
to
the
collating
8.2. E # n ~ t i o n
dEsianator&
corresponding
formal
parameters
(cf.
9.1.2.o
I0, a n d
11).
< f u n c t i o n d e s i g n a t o r > ::= < f u n c t i o n i d e n t i f i e r > I <function identifier>(<actual parameter>{ ,<actual < f u n c t i o n i d e n t i f i e r > ::= < i d e n t i f i e r > Examples :
Sum(a .100) SCD ( 1 4 7 , k )
parameter>})
s i n (x+y)
eof (f) ord(ff )
9. S t a t e m e n t s
said which
to be can be
152
<statement>::=<unlabelled statement> I <label>:<unlabelled statement> <unlabelled statement> ::= < s i m p l e statement> <structured <label> ::= < u n s i g n e d integer>
I statement>
9,1.
~&mo!e
statements
A simple s t a t e m e n t is a s t a t e m e n t of w h i c h no p a r t c o n s t i t u t e s another statement. The empty statement c o n s i s t s of no s y m b o l s and denotes no a c t i o n . <simple statement> ::= < a s s i g n m e n t <procedure statement> I <goto <empty statement> <empty statement> ::= < e m p t y > 9.1.1. Assignment statemeoJza s e r v e s to r e p l a c e the current specified as an e x p r e s s i o n . <variable> := < e x p r e s s i o n > := < e x p r e s s i o n > value of statement> statement>
I
I
<assignment statement> ::= <function identifier> The variable (or the identical type, with the I. t h e type expression 2. t h e type variable, Examples:
function) following
and the expression m u s t be of exceptions being permitted: the the type type of of the the
p i hue
9.1.2,
~ro~_~dure
statements
A procedure statement serves to execute the procedure denoted by the procedure identifier, The procedure statement may c o n t a i n a list of a~ual ~aramet~a which are substituted in place of their corresponding ~orma~ ~ar~et@~S defined in the procedure declaration (cf. 10). The correspondence is established by the positions of the parameters in the lists of actual and formal Parameters respectively, There exist four kinds of parameters: so-called value parameters, variable parameters, procedure parameters (the a c t u a l p a r a m e t e r is a P r o c e d u r e identifier), and function parameters (the actual parameter is a function identifier). In an the case expression of a ~alue ~jc_~m__~, the (of which a variable actual p a r a m e t e r m u s t be is a simple case). The
153
corresponding formal parameter r e p r e s e n t s a l o c a l v a r i a b l e of t h e c a l l e d p r o c e d u r e , a n d t h e c u r r e n t v a l u e of t h e e x p r e s s i o n is initially assigned to t h i s v a r i a b l e . In t h e c a s e of a ~ l e ~arameter, the actual parameter must be a v a r i a b l e , and the corresponding formal parameter represents this actual variable during the e n t i r e e x e c u t i o n of t h e p r o c e d u r e . If t h i s v a r i a b l e is a component of an array, its index is evaluated when the procedure is called, A variable parameter must be used whenever the parameter represents a result of the procedure. Components of a packed variable parameters. structure must not appear as actual
<procedure statement> ::= < p r o c e d u r e identifier> I <procedure identifier> (<actual parameter> {,<actual parameter>}) <procedure identifier> ::: < i d e n t i f i e r > <actual parameter> ::: < e x p r e s s i o n > I <variable> I <procedure identifier> I <function identifier> Examples : next Transpose(a on,m) Bisect (fct.-1.0,+1.0.x)
9.1.3.
A gore statement serves to indicate should continue at a n o t h e r p a r t of the t h e p l a c e of t h e l a b e l . <goto statement> ::: ot <label> hold
restrictions
concerninD
the
applicability
of
I. T h e scope of a label is defined, it is therefore procedure. 2. E v e r y label heading of statement. must the
the not
procedure possible
w i t h i n w h i c h it to jump into
is a
9.2.
~r_w_~t~@3!~tatemen~:
Structured statements are constructs composed of other statements which have to be executed either in sequence (compound statement), conditionally (conditional s t a t e m e n t s ) , or repeatedly (repetitive statements). <structured statement> ::: < c o m p o u n d s t a t e m e n t > I <conditional statement> I <repetitive statement> <with statement>
154
9,2.1,
~I~Ol&~Dd
statements
The compound s t a t e m e n t s p e c i f i e s t h a t its c o m p o n e n t statements are to be e x e c u t e d in t h e s a m e s e q u e n c e as t h e y a r e w r i t t e n . The s y m b o l s ~ . ~ & ~ a n d ~031 act as s t a t e m e n t brackets, <compound Example: 9.2.2, statement> ~ ::= ~ _ E i n ; x <statement> y := z ~ { ;<statement>} ~
z := x
:= y;
9 , 2 , 2 . I , If__~&~d~ements The if s t a t e m e n t s p e c i f i e s t h a t a s t a t e m e n t be e x e c u t e d only if a. c e r t a i n condition (Boolean expression) is t r u e . If it is false, then either no statement is to be e x e c u t e d , or t h e statement f o l l o w i n g t h e s y m b o l ~ I s ~ is to be e x e c u t e d . <if statement> ::= & ~ ~ <expression> ~ between the < e x p r e s s i o n > &b~l! < s t a t e m e n t > I <statement> ~l&~ <statement> symbols ~ and ~ h e & must be of t y p e
The e x p r e s s i o n Boolean.
ambiguity
arising
from
the
construct
~ <statement-l>
<expression-2>
is
resolved
the
construct
as
equivalent
to
iheo
<statement-l>
~.~
<statement-2>
1 .5
9,2,2,2.
~ e
stat@ments
The case statement c o n s i s t s of an e x p r e s s i o n (the s e l e c t o r ) a n d a list of s t a t e m e n t s , e a c h b e i n g l a b e l l e d by a c o n s t a n t of t h e type of the selector, It s p e c i f i e s t h a t t h e o n e s t a t e m e n t be executed whose label is equal to the c u r r e n t v a l u e of the
155 selector
<case statement> ::= ~ , ~ <expression> D~ <case list element> { ;<case list element>~ ~A~ <case list element> ::= < c a s e l a b e l l i s t > : < s b a t e m e n t > <empty> < c a s e l a b e l l i s t > ::= < c ~ s e l a b e l > {,<case label> ] E x a m p 1as : c & s e o p e r a t o r of" plus : x := x+y ; m i n u s : x := x - y ; t i m e s : x := x * y end
case
i of 1: x := 2: x := 3: x := 4: x :=
LoAd
9.2.3.
~#3z~ti~ve
s ~ t ~ & ~
Repetitive statements specify that certain s t a t e m e n t s a r e t o be executed repeatedly. If the number of repetitions is k n o w n beforehand, i.e. before the repetitions are started, the for statement is the appropriate construct to express this situation; otherwise the while or r e p e a t statement s h o u l d be used . <repetitive statement> ::= < w h ~ l e s t a t e m e n t > <repeat statement> [ <for statement> [
9.2.3.1o <while
The expression controlling repetition m u s t be of t y p e g o o l e a n . The statement is repeatedly executed until the expression becomes false. I its value is f a l s e at t h e b e g i n n i n g , the statement is not e x e c u t e d at a 1 1 . T h e w h i l e s t a t e m e n t ~hile is B do to
equivalent
B do
156
Examples: whil~ while beoin a[i] <> x d o i := i + I
:= z ' x ;
x and
~W~O
:= s q r ( x )
~]3ile ~ e e l ( f ) da P ( f t ); g e t ( f )
9.2.3.2.
~931eat
statemeoj&&
{ :<statement>} until <expression>
The expression controlling repetition m u s t be o f t y p e B o o l e a n . The sequence of statements between t h e s y m b o l s [9~2eat a n d w n t i ~ is repeatedly executed (and at l e a s t o n c e ) u n t i l the expression becomes true. The repeat statement reoeat is equivalent S ~il to B
P(ft);
eof(f)
get(f)
9.2.3.3.
157
statement> ::= <control variable> := < f o r l i s t > ~ <statement> list> ::= < i n i t i a l value> ~O <final value> I <initial value> ~owot~ <final value> <control variable> ::= < i d e n t i f i e r > <initial value> ::= < e x p r e s s i o n > <final value> ::= < e x p r e s s i o n > The control variable, the initial value, and the final value must be o f t h e s a m e s e a l e r t y p e (or s u b r a n g e thereof), and must n o t be a l t e r e d by t h e r e p e a t e d statement. T h e y c a n n o t be of t y p e real. A for
for
<for ~ <for
statement
v := el
of
to
the
form
S
e2 do
is
to S; v
the
sequence
of S;
:= s u c c ( v ) ; of the S
and
statement
form
fD~l v is
:= el
do~jl~J& e 2 d o to S; v the
equivalent v := el; :
:= p r e d ( S ) ;
Examples
for
:= 2 t o
100
do ii
a[i]
> max
tbru& m a x
:= a [ i ]
:= x + a [ i , k ]
*b[k,j] ;
do
Q (c)
9.2.4.
~h_~tatements ::= ~ i t h <record variable list> dO <statement> l i s t > ::= < r e c o r d variable>{ ,<record variable>}
Within the component statement of the with statement, the components ( f i e l d s ) of t h e r e c o r d variable specified by t h e w i t h Clause can be denoted by their field identifier only, i.e. without preceding t h e m w i t h t h e d e n o t a t i o n of t h e e n t i r e r e c o r d variable. The with clause effectively opens the scope containing the field identifiers of the specified record variable, so that the field identifiers m a y o c c u r as v a r i a b l e identifiers.
158
I; y e a r
:= y e a r
equivalent i~
1;
date.year
:= d a t e . y e a r + 1
~]_.~ d a t e . m o n t h
:= d a t e . m o n t h + l any are
No assignments may be m a d e in t h e q u a l i f i e d statement to elements of the record variable list. However, assignments possible to t h e c o m p o n e n t s of t h e s e v a r i a b l e s .
10.
Procedure
declarations
p a r t s of they can
programs and be a c t i v a t e d
to by
<procedure declaration> : := < p r o c e d u r e heading> <block> <block> ::= < l a b e l d e c l a r a t i o n oart> <constant definition part><type definition part> <variable declaration part> <procedure and function declaration part> <statement part> The ~ ~ ~ d ~ specifies the identifier naming the procedure and the formal parameter identifiers (if ~ n y ) . The parameters are either value-, variable-, procedureor function parameters (cf. also 9,1,2,), Procedures and functions which are u s e d as p a r a m e t e r s to o t h e r p r o c e d u r e s end functions must have value parameters only. <procedure heading> ::= ~ 2 o c w ~ d u r e < i d e n t i f i e r > ; 1 ~2~r~W~ <identifier> (<formal parameter section> I ;<formal parameter section>}) : <formal parameter section> ::= <parameter group> 1 ~&~ <parameter group> ~nc~on <parameter group> ~ce~ur~ <identifier> { ,<identifier>t <parameter group> ::= <identifier>{,<identifier>} <type identifier> A parameter constituents The i ~ group without preceding are value parameters. de~l~ration ~it specifier
implies that
its
specifies
all
labels
which
mark
159
statement <label
in
the
statement
part. I
all
constant
synonym
definition>}
to
~efioij~ion &arl contains all the procedure declaration. definition ty_~ <type
definitions
which are
<type
p a r t > : := < e m p t y > I definition> { :<type definition> ~&~ contains declaration. all variable
}: declarations
The ~&r_i&hl~ l o c a l to t h e
~cleation procedure
<variable declaration part> vat <variable declaration> The &2~~r_@ procedure and declaration.
<procedure and function declaration p a r t > ::= {<procedure or f u n c t i o n declaration> :} <procedure or f u n c t i o n declaration> ::= <procedure declaration> ~ <function declaration> The &~atg@~ELt executed upon statement. <statement ~r_J2 specifies an activation the algorithmic of the procedure a c t i o n s to be by a p r o c e d u r e
part>
::=
<compound
statement>
All identifiers introduced in the formal parameter part, the constant definition part, the type definition part, the variable-, p r o c e d u r e or f u n c t i o n declaration parts are l~l to the procedure declaration which is c a l l e d t h e &_q~Z~ of t h e s e identifiers. T h e y a r e not k n o w n outside t h e i r s c o p e . In t h e c a s e of local variables, their values e r e u n d e f i n e d at t h e b e c i n n i n ~ of t h e s t a t e m e n t part. The use of within its procedure. the procedure identifier in a p r o c e d u r e statement declaration implies recursive execution of the
160
Examples
of
procedure
declarations: x: integer) ;
~ro_~dure readinteger (3Aor f : t e x t ; M a r va_~r i . j : i n t e g e r ; ~_qin w _ h i l e f = " " d o g e t ( f ) : i := O: .~bile f t ~O. [ ' 0 " . . "9"] do begio j := o r d ( f ~ )- o r d ( ' O ' ) ; i :: I 0 - i + j ; g e t (f) end ; x := i and ~rocedwj~e Bisect(functio~ f: real; a.b: va~ m: real; beqin {assume f(a) < 0 and f(b) > 0 } whi]j& abs (a-b) > IE-10*abs(a) do b~g[in m :: ( a + b ) / 2 . 0 : if f ( m ) < O Jzh~J3 a : = m e l s e b end ; Z :: m ~d
real;
Mar z:
real);
::m
or~.~e~_~re GCD (m 0 n : i n t e g e r ; v o ~ x 0y , z : i n t e g e r ) : ~ al,a2, bl,b2,c,d ,q , r : i n t e g e r ; {m>=O, n>O} be~in {Greatest Common D i v i s o r x of m and n, Extended Euclid's Algorithm} al : : O; a 2 : = I ; bl ;:I; b 2 : = O; e : : m: d : : n : ~hi~ d <> 0 d o beo3J3 {a1*m + b1*n = d, a2*m + b2*n = e. god(cod) : gcd(mon)} q := c ~ d ; r :-- c rnDj~ d ; a 2 := a 2 - q * a I; b 2 := b 2 - q * b l ; o :: d; d := r : r :: a l ; e l :: a 2 : a 2 :: r ; r := b 1 : b l := b 2 ; b 2 := r end ; x :: c ; y := a 2 ; z := b 2 { x = gcd(m,n) = y*m + z*n } end
10.1.
~Zld~rd
erocedwres
Standard procedures are supposed to be predeclared in every implementation of Pascal. Any implementation may feature additional predeclared procedures. Since they are, as all standard quantities, assumed as declared in a scope surrounding the program, no conflict arises from a declaration redefining the same identifier within the program, The standard procedures are l~sted and explained below.
161
10.1.1. put(f)
Eile
handling
appends
orocedur~
the value of the buffer variable f~ to the
file f. The effect is defined o n l y if p r i o r to execution the predicate eof(f) is true. eof(f) r e m a i n s t r u e . a n d t h e v a l u e of f~ b e c o m e s u n d e f i n e d . get(f) a d v a n c e s the c u r r e n t f i l e p o s i t i o n (read/write head) to t h e next c o m p o n e n t , and a s s i g n s t h e v a l u e of t h i s component to the buffer variable ft . if no n e x t component exists, then eof(f) becomes true. and the value of ft is not d e f i n e d . T h e e f f e c t of g e t ( f ) is defined only if ear(f) = false prior to its execution. (see 1 1 . 1 . 2 ) resets the current file p o s i t i o n to its b e g i n n i n g end assigns to t h e b u f f e r v a r i a b l e f~ t h e v a l u e of the first e l e m e n t of f. e o f ( f ) b e c o m e s f a l s e , if f is not empty; otherwise f~ is not d e f i n e d , a n d eof(f) remains true. d i s c a r d s t h e c u r r e n t v a l u e of f s u c h t h a t m a y be g e n e r a t e d , eof(f) becomes true. the
see
reset (f)
rewrite(f)
a new
file
Concerning
and page,
textfile
Chapter
procedures
12.
read,
write,
readln,
writeln,
ne.
(p)
allocates
new
variable
and
assigns
the
pointer
If t h e form
a
type
of v
is
variable
of
the
variant dispose(p)
with
tag
field
values
t 1 ..... t n .
a n d d i s p o s e ( p , t 1 , . . . . t n ) can be u s e d to i n d i c a t e t h a t storaoe occupied by t h e v a r i a b l e r e f e r e n c e d by t h e pointer p is no l o n g e r n e e d e d . (Implementations may use this information to r e t r i e v e s t o r a g e , or t h e y may i g n o r e it,)
Let
the
variables
a and
be
declared
by
a:
z: where n-m ~or and the
&~&~
oack~ >= j v-u :=
[m..n]
azrav o Then u to v
of T
[u..v] the do z[j] of T statement := pack (a ,i ,z ) means
a[j-~+i] means
statement
unpack(z,a,i)
162
f~l~ J
:= u t o an
v do
a[J-u+i]
auxiliary
variable
11. F u n c t i o n
declarations
Function declarations serve to define parts of the program which compute a scalar value or a pointer value. Functions are activated by the evaluation of a f u n c t i o n designator (cf. 8 . 2 ) w h i c h is a c o n s t i t u e n t o f an e x p r e s s i o n . <function declaration> ::: <function heading><block>
soecifies parameters
type
of
<function heading> ::: ~WJl&~i9_~ < i d e n t i f i e r > : < r e s u l t type>; ~tion <identifier> (<formal parameter section> { :<formal parameter section>}) : <result type> ; <result t y p e > ::= < t y p e i d e n t i f i e r >
The t y p e of t h e f u n c t i o n m u s t be a s c a l a r , subrange, or p o i n t e r type. Within the function declaration t h e r e m u s t be at l e a s t o n e assignment statement assigning a value to the function identifier. This assignment determines the result of the function. Occurrence of the function identifier in a f u n c t i o n designator w i t h i n its d e c l a r a t i o n implies recursive e x e c u t i o n of the function. Examples: fu~l~J~ioa S q r t (x : r e a l ) : r e a l : vgr xU.x1: real: b~_~i~ x l := x; {x>l. Newton's method} ~e~zoat xO :: x l; x l := (xO+ x/xO)*O.5 until abs(xl-xO) < eps*xl ; Sqrt := x 0 ~nd
f u n ~ d ~ i o ~ N~ax(e : v e c t o r ; n: v~ x : r e a l ; i: i n t e g e r : b a ~ i n x := a [ 1 ] : _fD/i i := 2 t ~ n do
integer):
real;
b.~lin_
if
{x
X
= max(a[ I] .....
< a[i] I] ..... ~h~ii x a[n]
a[i-1])}
:= a [ i ] )}
163
:= G C O (n,m
mod
n)
real
: {y
>=
O}
11.1.
~&ndard
functig_Q&
in every feature
Standard functions are supposed to be predeclered implementation of Pascal. Any implementation may additional predeclared functions (cf. also 10.1).
The
standard
functions
are
listed
and
explained
below:
11.1.1,
Ar_~_bmetic
fg_ectiojl&
the absolute either ~Ca~ is the type value of iO~e~er, x. x . The t y p e o f x and the type of
abs(x)
or of
sqr
(x)
T h e t y p e o f x m u s t be t h e t y p e of t h e r e s u l t
either is t h e
~ type
s in (x) cos (x) exp (x) ln(x ) sqrt (x) erctan (x)
the the
type type
of x m u s t be e i t h e r ~ e a l of t h e r e s u l t is ~ e a l .
or 3 n t e g e r ,
and
11.1.2. odd(x)
~e~_~tes
the true, type if x of is x m u s t be ~ o t e ~ w J : . e n d t h e odd, and false otherwise. result is
eof(f)
eoln(f)
whether
the
f i l e f is
in
the
of
line
in
e textfile
(see
164
11.1.3.
funct~j&~& real . argument x is rounded to the nearest value x is truncated to its integral
trune(x)
round (x)
ord
(x)
x m u s t be of a s c a l e r type (including Boolean and char), and the result (of t y p e i n t e g e r ) is t h e ordinal number of t h e v a l u e x in t h e s e t d e f i n e d by t h e t y p e o f x. x m u s t be o f t y p e i n t e g e r , and char) is the character whose (if it e x i s t s ) . t h e r e s u l t (of t y p e ordinal n u m b e r is x
chr ()
11.1.4.
Fw.~_he~
standard of is of is
functions any scalar the successor any the or subrange type, and the v a l u e of x (if it e x i s t s ) . subrange value type, of x and t h e (if it
succ(x)
pred(x)
scalar or predecessor
12.
Input
end
output
The basis of l e g i b l e input and output are textfiles (cf.6.2.4) that are passed as program parameters (cf. 13) t o a PASCAL program and in its environment represent some i n p u t or output device such as e terminal, a card reader, or a line printer. In order to facilitate the handling of textfiles, the four standard procedures ~.~3~, writE, ~eadlo, and ~rite!~ are introduced in addition t o ~e~ a n d ~W~. T h e y c a n be a p p l i e d to textfiles only; however, these textfiles must not necessarily represent input/output devices, but cam also be local files. The new procedures are used with a non-standard syntax for their parameter lists, allowing, a m o n g o t h e r t h i n g s , for a v a r i a b l e number of parameters. Moreover, the parameters must not necessarily be of t y p e c h a r , b u t m a y a l s o be of c e r t a i n o t h e r types, in which case the date transfer is a c c o m p a n i e d by an implicit data conversion operation. If the first parameter is s file variable, then this is t h e f i l e to be r e a d or w r i t t e n . Otherwise, the standard files iO&ut and ~g~&~& are automatically assumed as default v a l u e s in t h e c a s e s of r e a d i n g and writing respectively. These two files are predeclared as vat input 0 output : text
Textfiles represent a special case among file types i n s o f a r as texts are substructured into l i n e s by s o - c a l l e d line markers (cf. b.2.4.). If, u p o n r e a d i n g a textfile f, t h e f i l e p o s i t i o n
165
is a d v a n c e d to a l i n e m a r k e r , t h a t is p a s t t h e l a s t c h a r a c t e r of a line, then the value of the buffer variable ft becomes a blank, and the standard function ~#_~O(~) ( ~ n d l i n e ) yields the value true. Advancing the file position o n c e m o r e a s s i g n s to f~ the first character of the next line, and eoln(f) yields false (unless the next line c o n s i s t s of 0 c h a r a c t e r s ) . Line markers, not being elements o f t y p e c h a r , c a n o n l y be g e n e r a t e d by t h e p r o c e d u r e ~r~teln,
12.1.
!~__~r_Q~edure
The following rules hold for the procedure ~ ; textfile and vl...vn denote v a r i a b l e s of t h e t y p e s (or s u b r a n g e of i n t e g e r ) , or r e a l .
1. r e a d ( v 1 2.
....
,vn) vn)
is
equivalent is
to
read(input,v to
1 ..... read(f,v
equivalent
3.
is a v a r i a b l e := f? ; g e t ( f )
of
type
~b&2,
then
read(f,v)
is
equivalent
4.
if v is a v a r i a b l e of type integer (or s u b r a n g e of integer) or real, then read(f.v) implies the reading f r o m f of a sequence of characters which form a number according to t h e syntax of PASCAL (cf. 4.) a n d t h e a s s i g n m e n t of t h a t n u m b e r to v. P r e c e d i n g blanks and line markers are skipped,
12.2.
r ~
1. r e a d l n ( v l 2. readln(f,vl
is
to
readln(input,vl to
.....
vn)
.....
vn)
read(f,v
3, r e a d l n ( f ) is
1 .....
readln
(f)
equivalent
~ h i ] d ~ D_~& e o l n ( f )
get(f);
get(f)
Readln of the is used to next line, read and subsequently skip to the beginning
12.3.
!b~_~roe~dure~r_i~
The following rules hold for the procedure ~i~-~; f denotes a textfile, p 1 ..... pn d e n o t e so-called write-parameters, e denotes an e x p r e s s i o n , m and n denote expressions of t y p e integer.
1. w r i t e ( p
1.....
pn)
is
equivalent
to
write(output,p1
.....
pn)
166
2. w r i t e ( f , p
1 ..... pn)
write(f
is
equivalent
.., ;
to
.pl);
write(f,pn)
3.
The
write-parameters
e :m
p
e :m : n
have
e
the
followin~
forms:
e represents t h e v a l u e t o be " w r i t t e n " on t h e f i l e f, a n d m and n are so-celled field width parameters. If t h e v a l u e e, which is either a number, a character, a Boolean value, or e string requires less than m characters for its representation, then an a d e q u a t e n u m b e r of b l a n k s is i s s u e d such that exactly m characters are written. If m is o m i t t e d , an implementation-defined d e f a u l t v a l u e w i l l be m s s u m e !. T h e form with the width parameter n is applicable on~y if e is of type reel (see r u l e 6 ) . 4. e is of t y p e c h a r , t h e n write(fo e : m ) is e q u i v a l e n t to f~ := : put(f); (repeated m-1 times) ft := e ; p u t (f) N o t ~ : t h e d e f a u l t v a l u e f o r m is in t h i s c a s e I, If e is of t y p e i~_~_W_g~ (or a s u b r a n o e of i n t e g e r ) , then the decimal representation of t h e n u m b e r e w i l l he w r i t t e n on t h e file f, preceded by an appropriate number of b l a n k s as specified by m. If e is of t y p e f e e l , a decimal representation of t h e n u m b e r e is w r i t t e n on t h e f i l e f, p r e c e d e d by a n a p p r o p r i a t e number of blanks as specified by m. If t h e p a r a m e t e r n is m i s s i n g ( s e e r u l e 3), e f l o a t i n o ~ o i n t representation e o n s i s t i n o of a coefficient and a scale f a c t o r w i l l be c h o s e n . Otherwise a fixed~oint representation with n dioits after the decimal p o i n t is o b t a i n e d . if e is of type ~ i ~ , then written on t h e f i l e f, p r e c e d e d b l a n k s as s p e c i f i e d by m, if e is written an on (packed) the file array f. of t h e w o r d s T R U E or by an a p p r o p r i a t e FALSE are n u m b e r of if
5.
6.
2.
C.
characters,
then
the
string
e is
12.4.
I. w r i t e l n
2. w r i t e l n ( f , p w r i t e l n (f) 3. w r i t e l n ( f )
1,...,pn)
equivalent
write(f,p
appends
line
marker
(cf.6.2,4)
to
the
file
f.
167
12.5.
page(f)
13.
Programs
has
the
form
of
a procedure
declaration
except
<program> <program
::=
<program
heading>
<block>
(<program
{ ,
parameters>)
}
<program
<identifier>
<identifier>
The identifier f o l l o w i n g t h e s y m b o l ~roorej~ is t h e p r o g r a m n a m e ; it has no f u r t h e r s i g n i f i c a n c e inside the program. The p r o o r a m parameters denote entities that exist outside the program, and through which the program communicates w i t h its e n v i r o n m e n t . These entities (usually files) are called ~9/:~ , a n d must be declared in the block which constitutes the program like ordinary local variables. The two standard files i~&W_~ a n d ~ u t o u ~ m u s t not be d e c l a r e d (cf. 12)0 but have to be l i s t e d as p a r a m e t e r s in t h e p r o g r a m heading, if they are used. The initialising statements reset(input) and r e w r i t e ( o u t p u t ) are automatically generated and must not be s p e c i f i e d by t h e p r o g r a m m e r . Examples: or~g~, c o p y (f ,~ ) ; v_all f.g: _file o f r e a l ; ~ e o i ~ r e s e t (f); r e w r i t e ( g ) ; w h i l e n o t e o f ( f ) do ~eoio gT : = f ~ ; p u t ( g ) ;
oad
get(f)
orw_qram e o p y t e x t (input , o u t p u t ) , )jar oh : c h a r ; begin w~LiiO D o t e o f ( i n p u t ) lip ba_q~a while not eoln(input) do bwlljJ3 r e a d ( c h ) ; w r i t e ( c h ) ea~ ; readln; writeln eo/
168
14. A s t a n d a r d
for
implementation
and
program
interchange
A primary motivation for the development of P A S C A L w a s t h e n e e d for a powerful end flexible language t h a t c o u l d be r e a s o n a b l y efficiently implemented on m o s t c o m p u t e r s . Its features w e r e to be defined without reference to any particular m a c h i n e in o r d e r to facilitate the interchange of programs. The following s e t of Proposed restrictions is designed as a guideline for implementors and for programmers who anticipate that their programs be used on d i f f e r e n t computers. The purpose of t h e s e standards is to increase the likelihood that different implementations will be compatible, and that programs are transferable from one installation to a n o t h e r .
distinct
objects
must
differ over
their
most
4 digits.
The implementor may s e t a l i m i t to t h e s i z e of a b a s e t y p e o v e r w h i c h a s e t can be d e f i n e d . (Consequently, a bit pattern representation may reasonably be u s e d f o r s e t s . ) The first character on each line of printfiles m a y be interpreted as a p r i n t e r control character with the following meanings: blank : single spacing 0' : double spacing "1" : print on top of next page of P A S C A L in t e r m s following rules: of available character sets
4.
6.
Blanks, ends of lines, and comments are considered as separators. An arbitrary number of separators may occur between any two consecutive PASCAL symbols with the following restriction: no separators must occur within ~dentifiers, numbers, and word symbols. At least consecutive one separator identifiers, must occur between any n u m b e r s , or w o r l d s y m b o l s . pair of
7.
169
15. I n d e x
actual parameter adding operator array type array variable assignment statement base t y p e block case l a b e l c a s e l a b e l list case l i s t e l e m e n t case statement component type component variable compound statement conditional statement constant constant definition c o n s t a n t d e f i n i t i o n part constant identifier control v a r i a b l e digit digit s e q u e n c e element e l e m e n t list empty statement entire variable expression factor field designator field identifier f i e l d list file b u f f e r file t y p e file v a r i a b l e final v a l u e fixed p a r t for list formal Parameter section for s t a t e m e n t function declaration function designator furct ton h e a d i n g function identifier goto s t a t e m e n t identifier if s t a t e m e n t index t y p e indexed variable initial value label label d e c l a r a t i o n part letter l e t t e r or digit multiplying operator
9.1.2. 8.1.3 6.2.1 7.2.1 9.1.1 6.2.3 10. 6.2.2 9.2.2.2 9.2.2.2 9.2.2.2 6.2.1 7.2 9,2.1 9,2.2 5. 5. 10. 5. 9.2.3.3 3. 4. 8. 8, 9.1 7.I 8. 8. 7.2.2 72.2 62.2 72.3 62.4 72.3 92.3.] 62.2 92.3.3 10. 9.2.3.3 11. 8.2 11. B.2 9.1.3 4. 9.2.2.1 0.2.1 7.2,1 9.2.3.3 9. 10. 3. 4. 8.1.2
and
6.2.2
170 p a r a m e t e r group pointer variable pointer t y p e p r o c e d u r e and function d e c l a r a t i o n part Procedure declaration procedure heading p r o c e d u r e identifier p r o c e d u r e or function d e c l a r a t i o n p r o c e d u r e statement program program h e a d i n g program P a r a m e t e r s record s e c t i o n record type record variable record variable list referenced variable r e l a t i o n a l operator repeat s t a t e m e n t repetitive statement result type scale factor scalar t y p e set set t y p e sign simple e x p r e s s i o n simple s t a t e m e n t simple type special symbol statement statement part string structured statement structured type subrange type tag field term type type d e f i n i t i o n type d e f i n i t i o n pert type i d e n t i f i e r variable variable d e c l a r a t i o n variable d e c l a r a t i o n part variable i d e n t i f i e r variant variant part u n l a b e l l e d statement unpacked s t r u c t u r e d type unsigned constant unsigned integer unsigned number unsigned real with s t a t e m e n t while s t a t e m e n t 10. ?.~ 6.3 10. 10. 10. 9.1.2 10. 9.1.2 13. 13. 13. 6.2.2 6.2.2 7.2.2 9.2.4 7.3 8.1.4 9.2.3.2 9.2.3 11. 4. 6.1 .t 6.2.3 4. U. 9.1 6.1 3. 9. 10. 4. 9.2 6.2 6.1 .3
6.2.2
8. 6. 6. 10. 6.1 7. 7. 10. 7.1 6.2.2 6.2.2 9. 6.2 8. 4. 4. 4. 9.2.4 9.2.3.1