.\"	@(#)efl	6.1 (Berkeley) 4/29/86
.\"
.EH 'PS2:6-%''The Programming Language EFL'
.OH 'The Programming Language EFL''PS2:6-%'
.\".ds [[ \fR\z[\h'.15m'[\fP
.\".ds ]] \fR\z]\h'.15m']\fP
.ND "4 June 1979"
.\". .TM 79-1273-6 39199 39199-11
.TL
The Programming Language EFL
.AU "MH 2C-570" 2059
Stuart I. Feldman
.AI
.MH
.OK
Fortran
Preprocessors
Ratfor
.AB
.PP
EFL is a clean, general purpose computer language intended to encourage
portable programming.
It has a uniform and readable syntax and good data and control flow structuring.
EFL programs can be translated into efficient Fortran code,
so the EFL programmer can take advantage of the ubiquity of Fortran,
the valuable libraries of software written in that language, and the portability
that comes with the use of a standardized language,
without suffering from Fortran's many failings as a language.
It is especially useful for numeric programs.
The EFL language permits the programmer to express
complicated ideas in a comprehensible way,
while permitting access to the power of the Fortran environment.
EFL can be viewed as a descendant of B. W. Kernighan's Ratfor [1];
the name originally stood for `Extended Fortran Language'.
The current version of the EFL compiler is written in
portable C.
.AE
.CS 35 0 35 0 0 1
.SH
.ds ~ \\v'.25m'\\s+2~\\s-2\\v'-.25m'
.if n .ls 2
.EQ
delim @@
.EN
.NH 1
INTRODUCTION
.NH 2
Purpose
.PP
EFL is a clean, general purpose computer language intended to encourage
portable programming.
It has a uniform and readable syntax and good data and control flow structuring.
EFL programs can be translated into efficient Fortran code,
so the EFL programmer can take advantage of the ubiquity of Fortran,
the valuable libraries of software written in that language, and the portability
that comes with the use of a standardized language,
without suffering from Fortran's many failings as a language.
It is especially useful for numeric programs.
Thus, the EFL language permits the programmer to express
complicated ideas in a comprehensible way,
while permitting access to the power of the Fortran environment.
.NH 2
History
.PP
EFL can be viewed as a descendant of B. W. Kernighan's Ratfor [1];
the name originally stood for `Extended Fortran Language'.
A. D. Hall designed the initial version of the language and wrote a preliminary version of a compiler.
I extended and modified the language and wrote a full compiler (in C) for it.
The current compiler is much more than a simple preprocessor:
it attempts to diagnose all syntax errors, to provide readable Fortran output,
and to avoid a number of niggling restrictions.  To achieve this goal, a sizable two-pass translator is needed.
.NH 2
Notation
.PP
In examples and syntax specifications,
.B boldface
type is used to indicate literal words and punctuation, such as
\fBwhile\fR.
Words in
.I italic
type
indicate an item in a category, such as an
.I expression.
A construct surrounded by double brackets represents a list of one or more of those items, separated by commas.
Thus, the notation
.DS C
\fI\*([[ item \*(]]\fR
.DE
could refer to any of the following:
.DS B
.I
item
item\fB, \fIitem
\fIitem\fB, \fIitem\fB, \fIitem\fR
.DE
.PP
The reader should have a fair degree of familiarity with some procedural language.
There will be occasional references to Ratfor and to Fortran
which may be ignored if the reader is unfamiliar with those languages.
.bp
.NH 1
LEXICAL FORM
.NH 2
Character Set
.PP
The following characters are legal in an EFL program:
.KS
.TS
center;
ll.
\fIletters	\fBa b c d e f g h i j k l m\fI
	\fBn o p q r s t u v w x y z\fI
digits	\fB0 1 2 3 4 5 6 7 8 9\fI
white space	\fIblank  tab\fI
quotes	\fB\'  "\fI
sharp	\fB#\fI
continuation	\fB\(ru\fI
braces	\fB{   }\fI
parentheses	\fB(  )\fI
other	\fB,   ;   :   .   +   \-   \(**   /\fI
	\fB=   <   >   &   \*~   |   $\fI
.TE
.KE
Letter case (upper or lower) is ignored except within strings,
so `\fBa\fR' and `\fBA\fR' are treated as the same character.
All of the examples below are printed in lower case.
An exclamation mark (`\fB!\fR') may be used in place of a tilde (`\fB\*~\fR').
Square brackets (`[' and `]') may be used in place of braces (`{' and `}').
.NH 2
Lines
.PP
EFL is a line-oriented language.
Except in special cases (discussed below),
the end of a line marks the end of a token and the end of a statement.
The trailing portion of a line may be used for a comment.
There is a mechanism for diverting input from one source file to another,
so a single line in the program may be replaced by a number of lines from the other file.
Diagnostic messages are labeled with the line number of the file on which they are detected.
.NH 3
White Space
.PP
Outside of a character string or comment,
any sequence of one or more spaces or tab characters acts as a single space.
Such a space terminates a token.
.NH 3
Comments
.PP
A comment may appear at the end of any line.
It is introduced by a sharp (#) character,
and continues to the end of the line.
(A sharp inside of a quoted string does not mark a comment.)
The sharp and succeeding characters on the line are discarded.
A blank line is also a comment.
Comments have no effect on execution.
.NH 3
Include Files
.PP
It is possible to insert the contents of a file at a point in the source text,
by referencing it in a line like
.DS C
.B
include joe
.R
.DE
No statement or comment may follow an
.B include
on a line.
In effect, the
.B include
line is replaced by the lines in the named file,
but diagnostics refer to the line number in the included file.
\fBInclude\fRs may be nested at least ten deep.
.NH 3
Continuation
.PP
Lines may be continued explicitly by using the underscore (\fB_\fR) character.
If the last character of a line (after comments and trailing white space have been stripped) is an underscore,
the end of line and the initial blanks on the next line are ignored.
Underscores are ignored in other contexts (except inside of quoted strings).
Thus
.DS B
     1_000_000_
         000
.DE
equals @10 sup 9@.
.PP
There are also rules for continuing lines automatically:
the end of line is ignored whenever it is obvious that the statement is not complete.
To be specific, a statement is continued if the last token on a line is an operator, comma,
left brace, or left parenthesis.
(A statement is not continued just because of unbalanced braces or parentheses.)
Some compound statements are also continued automatically;
these points are noted in the sections on executable statements.
.NH 3
Multiple Statements on a Line
.PP
A semicolon terminates the current statement.
Thus, it is possible to write more than one statement on a line.
A line consisting only of a semicolon, or a semicolon following a semicolon, forms a null statement.
.NH 2
Tokens
.PP
A program is made up of a sequence of tokens.
Each token is a sequence of characters.
A blank terminates any token other than a quoted string.
End of line also terminates a token unless explicit continuation (see above) is signaled by an underscore.
.NH 3
Identifiers
.PP
An identifier is a letter or a letter followed by letters or digits.
The following is a list of the reserved words that have special meaning in EFL.
They will be discussed later.
.KF
.TS
center;
lll .
.B
array	exit	precision
automatic	external	procedure
break	false	read
call	field	readbin
case	for	real
character	function	repeat
common	go	return
complex	goto	select
continue	if	short
debug	implicit	sizeof
default	include	static
define	initial	struct
dimension	integer	subroutine
do	internal	true
double	lengthof	until
doubleprecision	logical	value
else	long	while
end	next	write
equivalence	option	writebin
.R
.TE
.KE
The use of these words is discussed below.
These words may not be used for any other purpose.
.NH 3
Strings
.PP
A character string is a sequence of characters surrounded by quotation marks.
If the string is bounded by single-quote marks ( \fB\'\fR ), it may contain double
quote marks ( \fB"\fR ), and vice versa.
A quoted string may not be broken across a line boundary.
.DS
.B
 \'hello there\'
 "ain\'t misbehavin\'"
.R
.DE
.NH 3
Integer Constants
.PP
An integer constant is a sequence of one or more digits.
.DS B
.B
0
57
123456
.R
.DE
.NH 3
Floating Point Constants
.PP
A floating point constant contains a dot and/or an exponent field.
An
.I "exponent field"
is a letter
.B d
or
.B e
followed by an optionally signed integer constant.
If
@I@
and
@J@
are integer constants and
@E@
is an exponent field, then a floating constant has one of the following forms:
.DS B
.I
 \fB.\fPI
 I\fB.\fP
 I\fB.\fPJ
 IE
 I\fB.\fPE
 \fB.\fPIE
 I\fB.\fPJE
.R
.DE
.NH 3
Punctuation
.PP
Certain characters are used to group or separate objects in the language.
These are
.TS
center;
ll.
parentheses	(  )
braces	{  }
comma	,
semicolon	;
colon	:
end-of-line
.TE
The end-of-line is a token (statement separator)
when the line is neither blank nor continued.
.NH 3
Operators
.PP
The EFL operators are written as sequences of one or more
non-alphanumeric characters.
.DS B
+   \-   \(**   /   \(**\(**
<   <=   >   >=   ==   \*~=
&&   |\||   &   |
+=   \-=   \(*=   /=   \(**\(**=
&&=   |\||=      &=   |=
\->   .   $
.DE
A dot (`\fB.\fR') is an operator when it qualifies a structure element name,
but not when it acts as a decimal point in a numeric constant.
There is a special mode (see the Atavisms section)
in which some of the operators may be represented by a string consisting of a dot, an identifier, and a dot
(\fIe.g., \fB.lt.\fR ).
.NH 2
Macros
.PP
EFL has a simple macro substitution facility.
An identifier may be defined to be equal to a string of tokens;
whenever that name appears as a token in the program,
the string replaces it.
A macro name is given a value in a
.B define
statement like
.DS
define count     n += 1
.DE
Any time the name
.B count
appears in the program, it is replaced by the statement
.DS C
.B
n += 1
.R
.DE
A
.B define
statement must appear alone on a line;
the form is
.DS  C
\fBdefine   \fIname   \fIrest-of-line\fR
.DE
Trailing comments are part of the string.
.NH 1
PROGRAM FORM
.NH 2
Files
.PP
A
.I file
is a sequence of lines.
A file is compiled as a single unit.
It may contain one or more procedures.
Declarations and options that appear outside of a procedure
affect the succeeding procedures on that file.
.NH 2
Procedures
.PP
Procedures are the largest grouping of statements in EFL.
Each procedure has a name by which it is invoked.
(The first procedure invoked during execution, known as the
.I main
procedure,
has the null name.)
Procedure calls and argument passing are discussed in Section 8.
.NH 2
Blocks
.PP
Statements may be formed into groups inside of a procedure.
To describe the scope of names, it is convenient to introduce the ideas of
.I block
and of
.I "nesting level."
The beginning of a program file is at nesting level zero.
Any options, macro definitions,
or variable declarations there are also at level zero.
The text immediately following a
.B procedure
statement is at level 1.
After the declarations,
a left brace marks the beginning of a new block and increases the nesting level by 1;
a right brace drops the level by 1.
(Braces inside declarations do not mark blocks.)
(See Section 7.2).
An
.B end
statement marks the end of the procedure, level 1, and the return to level 0.
A name
(variable or macro)
that is defined at level
@k@
is defined throughout that block and in all deeper nested levels in which that name is not
redefined or redeclared.
Thus, a procedure might look like the following:
.DS B
.ta .7i 1.4i 2.1i 2.8i
.B
#   block 0
procedure george
real x
x = 2
 . . .
if(x > 2)
	{	# new block
	integer x	# a different variable
	do x = 1,7
		write(,x)
	. . .
	}	# end of block
end	# end of procedure, return to block 0
.DE
.NH 2
Statements
.PP
A statement is terminated by end of line or by a semicolon.
Statements are of the following types:
.DS B
Option
Include
Define
.sp .3
Procedure
End
.sp .3
Declarative
Executable
.DE
The
.B option
statement is described in Section 10.
The
.B include,
.B define,
and
.B end
statements have been described above;
they may not be followed by another statement on a line.
Each procedure begins with a
.B procedure
statements and finishes with an
.B end
statement; these are discussed in Section 8.
Declarations describe types and values of variables and
procedures.
Executable statements cause specific actions to be taken.
A block is an example of an executable statement; it is made up
of declarative and executable statements.
.NH 2
Labels
.PP
An executable statement may have a
.I label
which may be used in a branch statement.
A label is an identifier followed by a colon, as in
.DS B
.B
.ta 1i
	read(, x)
	if(x < 3) goto error
	. . .
error:	fatal("bad input")
.R
.DE
.NH 1
DATA TYPES AND VARIABLES
.PP
EFL supports a small number of basic (scalar) types.
The programmer may define objects made up of variables of basic type;
other aggregates may then be defined in terms of previously defined aggregates.
.NH 2
Basic Types
.PP
The basic types are
.DS B
\fBlogical
\fBinteger
\fBfield(\fIm\|\fB:\fIn\|\fB)
\fBreal
\fBcomplex
\fBlong real
\fBlong complex
\fBcharacter(\fIn\|\fB)
.R
.DE
A logical quantity may take on the two values true and false.
An integer may take on any whole number value in some machine-dependent range.
A field quantity is an integer restricted to a particular closed interval
@([m:n])@.
A `real' quantity is a floating point approximation to a real or rational number.
A long real is a more precise approximation to a rational.
(Real quantities are represented as single precision floating point numbers;
long reals are double precision floating point numbers.)
A complex quantity is an approximation to a complex number, and is represented as a pair of reals.
A character quantity is a fixed-length string of @n@ characters.
.NH 2
Constants
.PP
There is a notation for a constant of each basic type.
.LP
A logical may take on the two values
.DS B
.B
true
false
.R
.DE
An integer or field constant is a fixed point constant,
optionally preceded by a plus or minus sign, as in
.DS B
.B
17
\-94
+6
0
.R
.DE
A long real (`double precision') constant is a floating point constant containing an exponent field that
begins with the letter
.B d.
A real (`single precision') constant is any other floating point constant.
A real or long real constant may be preceded by a plus or minus sign.
The following are valid
.B real
constants:
.DS B
.B
 17.3
 \-.4
 7.9e\-6   @(~=~7.9 times 10 sup -6 )@
14e9    @(~=~1.4 times 10 sup 10 )@
.R
.DE
The following are valid
.B "long real"
constants
.DS B
.B
 7.9d\-6   @(~=~7.9 times 10 sup -6 )@
5d3
.R
.DE
.LP
A character constant is a quoted string.
.NH 2
Variables
.PP
A variable is a quantity with a name and a location.
At any particular time the variable may also have a value.
(A variable is said to be
.I undefined
before it is initialized or assigned its first value,
and after certain indefinite operations are performed.)
Each variable has certain attributes:
.NH 3
Storage Class
.PP
The association of a name and a location is either
transitory or permanent.
Transitory association is achieved when arguments are passed to procedures.
Other associations are permanent (static).
(A future extension of EFL may include dynamically allocated variables.)
.NH 3
Scope of Names
.PP
The names of
common areas
are global,
as are procedure names:
these names may be used anywhere in the program.
All other names are local to the block in which they are declared.
.NH 3
Precision
.PP
Floating point variables are either of normal or
.B long
precision.
This attribute may be stated independently of the basic type.
.NH 2
Arrays
.PP
It is possible to declare rectangular arrays (of any dimension) of values of the same type.
The index set is always a cross-product of intervals of integers.
The lower and upper bounds of the intervals must be constants for arrays that are local or
.B common.
A formal argument array may have intervals that are of length equal to one of the other formal arguments.
An element of an array is denoted by the array name followed by a parenthesized comma-separated list of integer values,
each of which must lie within the corresponding interval.
(The intervals may include negative numbers.)
Entire arrays may be passed as procedure arguments or in input/output lists,
or they may be initialized;
all other array references must be to individual elements.
.NH 2
Structures
.PP
It is possible to define new types which are made up of elements of other types.
The compound object is known as a
.I structure;
its constituents are called
.I members
of the structure.
The structure may be given a name,
which acts as a type name in the remaining statements within the scope of its declaration.
The elements of a structure may be of any type
(including previously defined structures),
or they may be arrays of such objects.
Entire structures may be passed to procedures or be used in input/output lists;
individual elements of structures may be referenced.
The uses of structures will be detailed below.
The following structure might represent a symbol table:
.DS B
.B
.ta .7i 1.4i 2.1i
struct tableentry
	{
	character(8) name
	integer hashvalue
	integer numberofelements
	field(0:1) initialized, used, set
	field(0:10) type
	}
.DE
.NH 1
EXPRESSIONS
.PP
Expressions are syntactic forms that yield a value.
An expression may have any of the following forms, recursively applied:
.DS B
.I
primary
\fB(\fI expression \fB)\fI
unary-operator  expression
expression  binary-operator  expression
.DE
In the following table of operators,
all operators on a line have equal precedence
and have higher precedence than operators on later lines.
The meanings of these operators are described in sections 5.3 and 5.4.
.DS B
.B
\->  .
\(**\(**
\(**  /      \fIunary\fB +  \-  ++  \-\-
+  \-
<  <=  >  >=  ==  \*~=
&  &&
|  |\||
$
=  +=  \-=  \(**=  /=  \(**\(**=    &=  |=  &&=  |\||=
.R
.DE
Examples of expressions are
.DS B
.B
a<b && b<c
\-(a + sin(x)) / (5+cos(x))\(**\(**2
.R
.DE
.NH 2
Primaries
.PP
Primaries are the basic elements of expressions, as follows:
.NH 3
Constants
.PP
Constants are described in Section 4.2.
.NH 3
Variables
.PP
Scalar variable names are primaries.
They may appear on the left or the right side of an assignment.
Unqualified names of aggregates (structures or arrays)
may only appear as procedure arguments and in input/output lists.
.NH 3
Array Elements
.PP
An element of an array is denoted by the array name followed by a parenthesized list of subscripts,
one integer value for each declared dimension:
.DS B
.B
a(5)
b(6,\|\-3,\|4)
.R
.DE
.NH 3
Structure Members
.PP
A structure name followed by a dot followed by the name of a member of that structure constitutes a reference to
that element.
If that element is itself a structure, the reference may be further qualified.
.DS B
.B
a.b
x(3).y(4).z(5)
.R
.DE
.NH 3
Procedure Invocations
.PP
A procedure is invoked by an expression of one of the forms
.DS B
\fIprocedurename \fB( )\fR
\fIprocedurename \fB( \fIexpression\fB )\fR
\fIprocedurename \fB( \fIexpression-1\fB, \fI...\fB, \fIexpression-n \fB)\fR
.DE
The
.I procedurename
is either the name of a variable
declared
.B external
or it is the name of a
function known to the EFL compiler (see Section 8.5),
or it is the actual name of a procedure, as it appears in a
.B procedure
statement.
If a
.I procedurename
is declared
.B external
and is an argument of the current procedure,
it is associated with the procedure name passed as actual argument;
otherwise it is the actual name of a procedure.
Each
.I expression
in the above is called an
.I "actual argument".
Examples of procedure invocations are
.DS B
.B
f(x)
work()
g(x, y+3, 'xx')
.R
.DE
When one of these procedure invocations is to be performed,
each of the actual argument expressions is first evaluated.
The types, precisions, and bounds of actual and formal arguments should agree.
If an actual argument is a variable name, array element, or structure member,
the called procedure is permitted to use the corresponding formal argument as the left side
of an assignment or in an input list;
otherwise it may only use the value.
After the formal and actual arguments are associated,
control is passed to the first executable statement of the procedure.
When a
.B return
statement is executed in that procedure,
or when control reaches the
.B end
statement of that procedure,
the function value is made available as the value of the procedure invocation.
The type of the value is determined by the attributes of
the
.I procedurename
that are declared or implied in the calling procedure,
which must agree with the attributes declared for the function in its procedure.
In the special case of a generic function,
the type of the result is also affected by the type of the argument.
See Chapter 8 for details.
.NH 3
Input/Output Expressions
.PP
The EFL input/output syntactic forms
may be used as integer primaries that have
a non-zero value
if an error occurs during the input or output.
See Section 7.7.
.NH 3
Coercions
.PP
An expression of one precision or type may be converted to another by an expression of the form
.DS C
\fIattributes \fB( \fIexpression \fB)\fR
.DE
At present, the only
.I attributes
permitted are precision and basic types.
Attributes are separated by white space.
An arithmetic value of one type may be coerced to any other arithmetic type;
a character expression of one length may be coerced to a character expression of another length;
logical expressions may not be coerced to a nonlogical type.
As a special case,
a quantity of
.B complex
or
.B "long complex"
type may be constructed from two integer or real quantities
by passing two expressions (separated by a comma) in the coercion.
Examples and equivalent values are
.DS B
.B
integer(5.3) = 5
long real(5) = 5.0d0
complex(5,3) = @5+3i@
.R
.DE
Most conversions are done implicitly,
since most binary operators permit operands of different arithmetic types.
Explicit coercions are of most use when it is necessary to convert the type of an actual argument
to match that of the corresponding formal parameter in a procedure call.
.NH 3
Sizes
.PP
There is a notation which yields the amount of memory required to store a datum
or an item of specified type:
.DS B
\fBsizeof ( \fIleftside\fB )
\fBsizeof ( \fIattributes\fB )
.R
.DE
In the first case,
.I leftside
can denote a variable, array, array element, or structure member.
The value of
.B sizeof
is an integer, which gives the size in arbitrary units.
If the size is needed in terms of the size of some specific unit, this
can be computed by division:
.DS B
.B
sizeof(x) / sizeof(integer)
.R
.DE
yields the size of the variable
.B x
in integer words.
.PP
The distance between consecutive elements of an array may not equal
.B sizeof
because certain data types require final padding on some machines.
The
.B lengthof
operator gives this larger value, again in arbitrary units.
The syntax is
.DS B
\fBlengthof ( \fIleftside\fB )
\fBlengthof ( \fIattributes\fB )
.R
.DE
.NH 2
Parentheses
.PP
An expression surrounded by parentheses is itself an expression.
A parenthesized expression must be evaluated before an expression of which it is a part is evaluated.
.NH 2
Unary Operators
.PP
All of the unary operators in EFL are prefix operators.
The result of a unary operator has the same type as its operand.
.NH 3
Arithmetic
.PP
Unary
.B +
has no effect.
A unary
.B \-
yields the negative of its operand.
.PP
The prefix operator
.B ++
adds one to its operand.
The prefix operator
.B \-\-
subtracts one from its operand.
The value of either expression is the result of the addition or subtraction.
For these two operators, the operand must be a scalar,
array element, or structure member of arithmetic type.
(As a side effect, the operand value is changed.)
.NH 3
Logical
.PP
The only logical unary operator is complement
(\fB\*~\fR).
This operator is defined by the equations
.DS B
.B
\*~ true = false
\*~ false = true
.R
.DE
.NH 2
Binary Operators
.PP
Most EFL operators have two operands, separated by the operator.
Because the character set must be limited,
some of the operators are denoted by strings of two or three special characters.
All binary operators except exponentiation are left associative.
.NH 3
Arithmetic
.PP
The binary arithmetic operators are
.KS
.TS
center;
ll.
+	addition
@-@	subtraction
\(**	multiplication
/	division
\(**\(**	exponentiation
.TE
.KE
Exponentiation is right associative:
a\(**\(**b\(**\(**c = a\(**\(**(b\(**\(**c) = @a sup {(b sup c )}@
The operations have the conventional meanings:
@8+2~=~10@,
@8-2 ~=~ 6@,
@8\(** 2 ~=~ 16@,
@8/2~=~ 4@,
@8 \(**\(** 2 ~=~ 8 sup 2 ~=~ 64@.
.PP
The type of the result of a binary operation
@A~op~B@
is determined by the types of its operands:
.KS
.TS
center;
l|lllll .
			Type of B
.sp .5
Type of A	integer	real	long real	complex	long complex
_
integer	integer	real	long real	complex	long complex
real	real	real	long real	complex	long complex
long real	long real	long real	long real	long complex	long complex
complex	complex	complex	long complex	complex	long complex
long complex	long complex	long complex	long complex	long complex	long complex
.TE
.KE
If the type of an operand differs from the type of the result,
the calculation is done as if the operand were first coerced to the type of the result.
If both operands are integers, the result is of type integer, and is computed exactly.
(Quotients are truncated toward zero, so
@8/3 = 2@.)
.NH 3
Logical
.PP
The two binary logical operations in EFL,
.B and
and
.B or,
are defined by the truth tables:
.KS
.TS
center;
cccc
aaaa .
A	B	A and B	A or B
_
false	false	false	false
false	true	false	true
true	false	false	true
true	true	true	true
.R
.TE
.R
.KE
Each of these operators comes in two forms.
In one form, the order of evaluation is specified.
The expression
.DS C
.B
a && b
.R
.DE
is evaluated by first evaluating
.B a ;
if it is false then the expression is false and
.B b
is not evaluated;
otherwise the expression has the value of
.B b.
The expression
.DS C
.B
a |\|| b
.R
.DE
is evaluated by first evaluating
.B a;
if it is true then the expression is true and
.B b
is not evaluated;
otherwise the expression has the value of
.B b.
The other forms of the operators
(\fB&\fR for \fBand\fR and \fB|\fR for \fBor\fR)
do not imply an order of evaluation.
With the latter operators,
the compiler may speed up the code by
evaluating the operands in any order.
.NH 3
Relational Operators
.PP
There are six relations between arithmetic quantities.
These operators are not associative.
.KS
.TS
center;
ccs
lll.
EFL Operator	Meaning
_
<	<	less than
<=	@<=@	less than or equal to
==	@=@	equal to
\*~=	@!=@	not equal to
>	>	greater than
>=	@>=@	greater than or equal
.TE
.KE
Since the complex numbers are not ordered, the only relational operators that may take complex operands
are
\fB==\fR
and
\fB\*~=\fR .
The character collating sequence is not defined.
.NH 3
Assignment Operators
.PP
All of the assignment operators are right associative.
The simple form of assignment is
.DS C
\fIbasic-left-side  \fB=  \fIexpression\fR
.DE
A
.I basic-left-side
is a scalar variable name, array element, or structure member of basic type.
This statement computes the expression on the right side, and stores that value
(possibly after coercing the value to the type of the left side)
in the location named by the left side.
The value of the assignment expression is the value assigned to the left side after coercion.
.PP
There is also an assignment operator corresponding to each binary arithmetic and logical operator.
In each case,
@a ~op = ~ b@
is equivalent to
@a ~=~ a ~ op~ b@.
(The operator and equal sign must not be separated by blanks.)
Thus,
.B n+=2
adds 2 to n.
The location of the left side is evaluated only once.
.NH 2
Dynamic Structures
.PP
EFL does not have an address (pointer, reference) type.
However, there is a notation for dynamic structures,
.DS B
\fIleftside \fB\-> \fIstructurename\fR
.DE
This expression is a structure with the shape implied by
.I structurename
but starting at the location of
.I leftside.
In effect, this overlays the structure template at the specified location.
The
.I leftside
must be a variable, array, array element, or structure member.
The type of the
.I leftside
must be one of the types in the structure declaration.
An element of such a structure is denoted in the usual way using the dot operator.
Thus,
.DS C
.B
place(i) \-> st.elt
.R
.DE
refers to the
.B elt
member of the
.B st
structure starting at the
@i sup th@
element of the array
.B place.
.NH 2
Repetition Operator
.PP
Inside of a list, an element of the form
.DS C
\fIinteger-constant-expression \fB$\fI constant-expression\fR
.DE
is equivalent to the appearance of the
.I expression
a number of times equal to the first expression.
Thus,
.DS C
.B
(3, 3$4, 5)
.R
.DE
is equivalent to
.DS C
.B
(3, 4, 4, 4, 5)
.R
.DE
.NH 2
Constant Expressions
.PP
If an expression is built up out of operators (other than functions) and constants,
the value of the expression is a constant, and may be used anywhere a constant is required.
.NH 1
DECLARATIONS
.PP
Declarations statement describe the meaning, shape, and size of named
objects in the EFL language.
.NH 2
Syntax
.PP
A declaration statement is made up of attributes and variables.
Declaration statements are of two form:
.DS B
.I
attributes  variable-list
attributes  {  declarations  }
.R
.DE
In the first case, each name in the
.I variable-list
has the specified attributes.
In the second, each name in the declarations also has the specified attributes.
A variable name may appear in more than one variable list,
so long as the attributes are not contradictory.
Each name of a nonargument variable may be accompanied by an initial value specification.
The
.I declarations
inside the braces are one or more declaration statements.
Examples of declarations are
.DS B
.B
integer k=2
.sp .5
long real b(7,3)
.sp .5
common(cname)
      {
      integer i
      long real array(5,0:3) x, y
      character(7) ch
      }
.R
.DE
.ne 1i
.NH 2
Attributes
.NH 3
Basic Types
.PP
The following are basic types in declarations
.DS
.B
logical
integer
field(@m:n@)
character(@k@)
real
complex
.R
.DE
In the above, the quantities @k@, @m@, and @n@ denote integer constant expressions with the properties
@k>0@ and @n>m@.
.NH 3
Arrays
.PP
The dimensionality may be declared by an
.B array
attribute
.EQ C
bold array( b sub 1 , ..., b sub n bold )
.EN
Each of the @b sub i@
may either be a single integer expression or a pair of integer expressions separated by a colon.
The pair of expressions form a lower and an upper bound; the single expression is an upper bound with
an implied lower bound of 1.
The number of dimensions is equal to
@n,@
the number of bounds.
All of the integer expressions must be constants.
An exception is permitted only if all of the variables associated with an
array declarator are formal arguments of the procedure; in this case, each bound
must have the property that
@upper - lower + 1@
is equal to a formal argument of the procedure.
(The compiler has limited ability to simplify expressions, but it will recognize
important cases such as
.B "(0:n\-1)".
The upper bound for the last dimension
@(b sub n )@
may be marked by an asterisk
( \fB\(**\fR )
if the size of the array is not known.
The following are legal @bold array@ attributes:
.DS B
.B
array(5)
array(5, 1:5, \-3:0)
array(5, \(**)
array(0:m\-1, m)
.R
.DE
.NH 3
Structures
.PP
A structure declaration is of the form
.DS B
\fBstruct \fIstructname \fB{ \fI declaration statements \fB}\fR
.DE
The
.I structname
is optional; if it is present, it acts as if it were the name of a type in the rest of its scope.
Each name that appears inside the
.I declarations
is a
.I member
of the structure, and has a special meaning when used to qualify any variable declared with the structure type.
A name may appear as a member of any number of structures,
and may also be the name of an ordinary variable,
since a structure member name is used only in contexts where the parent type is known.
The following are valid structure attributes
.DS B
.B
struct xx
        {
        integer a, b
        real x(5)
        }

struct { xx z(3); character(5) y }
.R
.DE
The last line defines a structure containing an array of three @bold xx 's@
and a character string.
.NH 3
Precision
.PP
Variables of floating point
(@bold real@ or @bold complex@) type may be declared to be
@bold long@
to ensure they have higher precision than ordinary floating point variables.
The default precision is
\fBshort\fR.
.NH 3
Common
.PP
Certain objects called
.I common\ areas
have external scope,
and may be referenced by any procedure that has a declaration for the name using a
.DS C
\fBcommon ( \fI commonareaname \fB)\fR
.DE
attribute.
All of the variables declared with a particular \fBcommon\fR attribute are in the same
block; the order in which they are declared is significant.
Declarations for the same block in differing procedures must have the variables in the same order and with the
same types, precision, and shapes, though not necessarily with the same names.
.NH 3
External
.PP
If a name is used as the procedure name in a procedure invocation,
it is implicitly declared to have the
.B external
attribute.
If a procedure name is to be passed as an argument, it is necessary to declare
it in a statement of the form
.DS B
\fBexternal \*([[ \fIname \fB\*(]]\fR
.DE
If a name has the external attribute and it is a formal argument of
the procedure,
then it is associated with a procedure identifier passed as an actual argument
at each call.
If the name is not a formal argument, then that name is the actual name
of a procedure, as it appears in the corresponding
.B procedure
statement.
.NH 2
Variable List
.PP
The elements of a variable list in a declaration
consist of a name,
an optional dimension specification,
and an optional initial value specification.
The name follows the usual rules.
The dimension specification is the same form and meaning as the parenthesized list in an
.B array
attribute.
The initial value specification is an equal sign (\fB=\fR) followed by a constant expression.
If the name is an array, the right side of the equal sign may be a parenthesized list of constant expressions,
or repeated elements or lists; the total number of elements in the list must not exceed the number of elements of the
array, which are filled in column-major order.
.NH 2
The Initial Statement
.PP
An initial value may also be specified for a simple variable,
array, array element, or member of a structure
using a statement of the form
.DS B
\fBinitial \*([[ \fIvar \fB= \fIval \*(]]\fR
.DE
The @var@ may be a variable name, array element specification, or member of structure.
The right side follows the same rules as for an initial value specification
in other declaration statements.
.NH 1
EXECUTABLE STATEMENTS
.PP
Every useful EFL program contains executable statements \(em
otherwise it would not do anything and would not need to be run.
Statements are frequently made up of other statements.
Blocks are the most obvious case,
but many other forms contain statements as constituents.
.PP
To increase the legibility of EFL programs,
some of the statement forms can be broken without an explicit continuation.
A square (\fR\(sq\fP) in the syntax represents a point where the end of a line will be ignored.
.NH 2
Expression Statements
.NH 3
Subroutine Call
.PP
A procedure invocation that returns no value is known as a subroutine call.
Such an invocation is a statement.
Examples are
.DS B
.B
work(in, out)
run(\|)
.R
.DE
.PP
Input/output statements (see Section 7.7)
resemble procedure invocations
but do not yield a value.
If an error occurs
the program stops.
.NH 3
Assignment Statements
.PP
An expression that is a simple assignment (\fB=\fR) or
a compound assignment (\fB+=\fR etc.) is a statement:
.DS B
.B
a = b
a = sin(x)/6
x \(**= y
.R
.DE
.NH 2
Blocks
.PP
A block is a compound statement that acts as a statement.
A block begins with a left brace,
optionally followed by declarations,
optionally followed by executable statements,
followed by a right brace.
A block may be used anywhere a statement is permitted.
A block is not an expression and does not have a value.
An example of a block is
.DS B
.B
 {
 integer i     # this variable is unknown outside the braces
.sp .3
 big = 0
 do i = 1,n
     if(big < a(i))
            big = a(i)
 }
.R
.DE
.NH 2
Test Statements
.PP
Test statements permit execution of certain statements conditional on the truth of a predicate.
.NH 3
If Statement
.PP
The simplest of the test statements is the
.B if
statement, of form
.DS C
\fBif ( \fIlogical-expression\fB ) \fR\(sq\fP \fIstatement\fR
.DE
The logical expression is evaluated;
if it is true, then the
.I statement
is executed.
.NH 3
If-Else
.PP
A more general statement is of the form
.DS B
\fBif ( \fIlogical-expression \fB) \fR\(sq\fP \fI statement-1 \fR\(sq\fP \fBelse \fR\(sq\fP \fI statement-2 \fR
.DE
If the expression is
.B true
then
.I statement-1
is executed, otherwise
.I statement-2
is executed.
Either of the consequent statements may itself be an
.B if-else
so a completely nested test sequence is possible:
.DS B
.B
if(x<y)
    if(a<b)
        k = 1
    else
        k = 2
else
    if(a<b)
        m = 1
    else
        m = 2
.R
.DE
An
.B else
applies to the nearest preceding un-\fBelse\fRd \fBif\fR.
A more common use is as a sequential test:
.DS B
.B
if(x==1)
    k = 1
else if(x==3  |  x==5)
    k = 2
else
    k = 3
.R
.DE
.NH 3
Select Statement
.PP
A multiway test on the value of a quantity is succinctly stated as a
.B select
statement, which has the general form
.DS B
\fBselect( \fIexpression\fB ) \fR\(sq\fP \fIblock\fR
.DE
Inside the block
two special types of labels are recognized.
A prefix of the form
.DS B
\fBcase \fI\*([[ constant \*(]] \fB:\fR
.DE
marks the statement to which control is passed if the
expression
in the select has a value equal to one of the case constants.
If the expression equals none of these constants, but there is
a label
.B default
inside the select,
a branch is taken to that point;
otherwise the statement following the right brace is executed.
Once execution begins at a
.B case
or
.B default
label, it continues until the next
.B case
or
.B default
is encountered.
The
.B else-if
example above is better written as
.DS B
.B
select(x)
    {
    case 1:
        k = 1
    case 3,5:
        k = 2
    default:
        k = 3
    }
.R
.DE
Note that control does not `fall through' to the next case.
.NH 2
Loops
.PP
The loop forms provide the best way of repeating a statement
or sequence of operations.
The simplest (\fBwhile\fR) form is theoretically sufficient, but it is very convenient to have
the more general loops available, since each expresses a mode of control
that arises frequently in practice.
.NH 3
While Statement
.PP
This construct has the form
.DS C
\fBwhile ( \fIlogical-expression\fB ) \fR\(sq\fP \fIstatement\fR
.DE
The expression is evaluated; if it is true, the statement is executed, and then the test is performed again.
If the expression is false, execution proceeds to the next statement.
.NH 2
For Statement
.PP
The
.B for
statement is a more elaborate looping construct.
It has the form
.DS C
\fBfor ( \fIinitial-statement \fB, \fR\(sq\fP \fIlogical-expression \fB, \fR\(sq\fP \fI iteration-statement \fB) \fR\(sq\fP \fIbody-statement
.DE
Except for the behavior of the
.B next
statement (see Section 7.6.3), this construct is equivalent to
.DS B
\fIinitial-statement
\fBwhile ( \fIlogical-expression\fB )
    {
    \fIbody-statement
    \fIiteration-statement
    }
.DE
This form is useful for general arithmetic iterations, and for various pointer-type operations.
The sum of the integers from 1 to 100 can be computed by the fragment
.DS B
.B
n = 0
for(i = 1, i <= 100, i += 1)
        n += i
.R
.DE
Alternatively, the computation could be done by the single statement
.DS B
.B
for(  { n = 0 ;  i = 1 } ,  i<=100 ,  { n += i ;  ++i } )
        ;
.R
.DE
Note that the body of the
.B for
loop is a null statement in this case.
An example of following a linked list will be given later.
.NH 3
Repeat Statement
.PP
The statement
.DS B
\fBrepeat \fR\(sq\fP \fIstatement\fR
.DE
executes the statement, then does it again, without any termination test.
Obviously, a test inside the
.I statement
is needed to stop the loop.
.NH 3
Repeat...Until Statement
.PP
The
.B while
loop performs a test before each iteration.
The statement
.DS B
\fBrepeat \fR\(sq \fIstatement \fR\(sq \fBuntil ( \fIlogical-expression \fB)
.DE
executes the
.I statement,
then evaluates the logical;
if the logical is
true the loop is complete;
otherwise control returns to the
.I statement.
Thus, the body is always executed at least once.
The
.B until
refers to the nearest preceding
.B repeat
that has not been paired with an
.B until.
In practice, this appears to be the least frequently used looping construct.
.NH 3
Do Loops
.PP
The simple arithmetic progression is a very common one in numerical applications.
EFL has a special loop form for ranging over an ascending arithmetic sequence
.DS B
\fBdo \fIvariable \fB= \fIexpression-1, expression-2, expression-3\fR
     \fIstatement\fR
.DE
The variable is first given the value
.I expression-1.
The statement is executed, then
.I expression-3
is added to the variable.
The loop is repeated until the variable exceeds
.I expression-2.
If
.I expression-3
and the preceding comma are omitted, the increment is taken to be 1.
The loop above is equivalent to
.DS B
t2 = expression-2
t3 = expression-3
for(variable = expression-1 , variable <= t2 , variable += t3)
     statement
.DE
(The compiler translates EFL
.B do
statements into Fortran
DO statements,
which are in turn usually compiled into excellent code.)
The
.B do
.I variable
may not be changed inside of the loop,
and
.I expression-1
must not exceed
.I expression-2.
The sum of the first hundred positive integers could be computed by
.DS B
.B
n = 0
do i = 1, 100
           n += i
.R
.DE
.NH 2
Branch Statements
.PP
Most of the need for branch statements in programs can be
averted by using the loop and test constructs,
but there are programs where they are very useful.
.NH 3
Goto Statement
.PP
The most general, and most dangerous, branching statement is the simple unconditional
.DS B
\fBgoto \fIlabel\fR
.DE
After executing this statement, the next statement performed is the one following the given label.
Inside of a
.B select
the case labels of that block may be used as labels, as in the following example:
.KS
.B
.TS
center;
lll .
select(k)
	{
	case 1:
		error(7)

	case 2:
		k = 2
		goto case 4

	case 3:
		k = 5
		goto case 4

	case 4:
		fixup(k)
		goto default

	default:
		prmsg("ouch")
	}
.TE
.KE
.R
(If two
.B select
statements are nested,
the case labels of the outer
.B select
are not accessible from the inner one.)
.NH 3
Break Statement
.PP
A safer statement is one which transfers control to the statement following the current
.B select
or loop form.
A statement of this sort is almost always needed in a
.B repeat
loop:
.DS B
.B
repeat
    {
    \fIdo a computation
    if\|( finished )
          \fBbreak\fI
    }
.R
.DE
More general forms permit controlling a branch out of more than one construct.
.DS C
.B
break 3
.R
.DE
transfers control to the statement following the third loop and/or
.B select
surrounding the statement.
It is possible to specify which type of construct
(\fBfor\fR, \fBwhile\fR, \fBrepeat\fR, \fBdo\fR, or \fBselect\fR)
is to be counted.
The statement
.DS C
.B
break while
.R
.DE
breaks out of the first surrounding
.B while
statement.
Either of the statements
.DS B
.B
break 3 for
break for 3
.R
.DE
will transfer to the statement after the third enclosing
.B for
loop.
.NH 3
Next Statement
.PP
The
.B next
statement causes the first surrounding loop statement to go on to the next iteration:
the next operation performed is the
test of a
.B while,
the
.I iteration-statement
of a
.B for,
the body of a
.B repeat,
the test of a
.B repeat...until,
or the increment of a
.B do.
Elaborations similar to those for
.B break
are available:
.DS B
.B
next
next 3
next 3 for
next for 3
.R
.DE
A
.B next
statement ignores
.B select
statements.
.NH 3
Return
.PP
The last statement of a procedure is followed by a return of control to the caller.
If it is desired to effect such a return from any other point in the procedure, a
.DS B
\fBreturn\fR
.DE
statement may be executed.
Inside a function procedure, the function value is specified as an argument of the statement:
.DS B
\fBreturn ( \fIexpression \fB)
.DE
.NH 2
Input/Output Statements
.PP
EFL has two input statements (\fBread\fR and \fBreadbin\fR),
two output statements (\fBwrite\fR and \fBwritebin\fR),
and three control statements (\fBendfile\fR, \fBrewind\fR, and \fBbackspace\fR).
These forms may be used either as a primary with a
.B integer
value
or as a statement.
If an exception occurs when one of these forms is used as a statement,
the result is undefined but will probably be treated as a fatal error.
If they are used in a context where they return a value,
they return
zero if no exception occurs.
For the input forms, a negative value indicates end-of-file and
a positive value an error.
The input/output part of EFL very strongly reflects the facilities of Fortran.
.NH 3
Input/Output Units
.PP
Each I/O statement refers to a `unit',
identified by a small positive integer.
Two special units are defined by EFL,
the
.I "standard input unit"
and the
.I "standard output unit."
These particular units are assumed if no unit is specified in an I/O transmission statement.
.PP
The data on the unit are organized into
.I records.
These records may be read or written in a fixed sequence,
and each transmission moves an integral number of records.
Transmission proceeds from the first record until the
.I "end of file."
.NH 3
Binary Input/Output
.PP
The
.B readbin
and
.B writebin
statements transmit data in a machine-dependent but swift manner.
The statements are of the form
.DS B
\fBwritebin( \fIunit \fB, \fIbinary-output-list \fB)\fR
\fBreadbin( \fIunit \fB, \fIbinary-input-list \fB)\fR
.DE
Each statement moves one unformatted record between storage and the device.
The
.I unit
is an integer expression.
A
.I binary-output-list
is an
.I iolist
(see below) without any format specifiers.
A
.I binary-input-list
is an
.I iolist
without format specifiers in which each of the expressions
is a variable name, array element, or structure member.
.NH 3
Formatted Input/Output
.PP
The
.B read
and
.B write
statements
transmit data in the form of lines of characters.
Each statement moves one or more records (lines).
Numbers are translated into decimal notation.
The exact form of the lines is determined by format specifications,
whether provided explicitly in the statement
or implicitly.
The syntax of the statements is
.DS B
\fBwrite( \fIunit \fB,\fI formatted-output-list \fB)\fR
\fBread( \fIunit \fB,\fI formatted-input-list \fB)\fR
.DE
The lists are of the same form as for binary I/O,
except that the lists may include format specifications.
If the
.I unit
is omitted, the standard input or output unit is used.
.NH 3
Iolists
.PP
An
.I iolist
specifies a set of values to be written or a set of variables into which
values are to be read.
An
.I iolist
is a list of one or more
.I ioexpressions
of the form
.DS B
\fIexpression
\fB{ \fIiolist \fB}
\fIdo-specification \fB{ \fIiolist \fB}\fR
.DE
For formatted I/O,
an
.I ioexpression
may also have the forms
.DS B
\fIioexpression \fB:\fI format-specifier
\fB:\fI format-specifier\fR
.DE
A
.I do-specification
looks just like a
.B do
statement, and has a similar effect:
the values in the braces are transmitted repeatedly until the
.B do
execution is complete.
.NH 3
Formats
.PP
The following are permissible
.I format-specifiers.
The quantities
@w@, @d@, and @k@ must be integer constant expressions.
.KS
.TS
center;
ll .
\fBi(\fIw\fB)\fR	integer with \fIw\fR digits
\fBf(\fIw\fB,\fId\fB)\fR	floating point number of \fIw\fR characters,
	\fId\fR of them to the right of the decimal point.
\fBe(\fIw\fB,\fId\fB)\fR	floating point number of \fIw\fR characters,
	\fId\fR of them to the right of the decimal point,
	with the exponent field marked with the letter \fBe\fR
\fBl(\fIw\fB)\fR	logical field of width \fIw\fR characters,
	the first of which is \fBt\fR or \fBf\fR
	(the rest are blank on output, ignored on input)
	standing for \fBtrue\fR and \fBfalse\fR respectively
\fBc\fR	character string of width equal to the length of the datum
\fBc(\fIw\fB)\fR	character string of width \fIw\fR
\fBs(\fIk\fB)\fR	skip \fIk\fR lines
\fBx(\fIk\fB)\fR	skip \fIk\fR spaces
" ... "	use the characters inside the string as a Fortran format
.TE
.KE
If no format is specified for an item in a formatted input/output statement,
a default form is chosen.
.PP
If an item in a list is an array name,
then the entire array is transmitted as a sequence of elements,
each with its own format.
The elements are transmitted in column-major order,
the same order used for array initializations.
.NH 3
Manipulation statements
.PP
The three input/output statements
.DS B
.B
backspace(@unit@)
rewind(@unit@)
endfile(@unit@)
.R
.DE
look like ordinary procedure calls,
but may be used either as statements or as integer expressions
which yield
non-zero
if an error is detected.
.B backspace
causes the specified unit to back up,
so that the next
read will re-read the previous record,
and the next write will over-write it.
.B rewind
moves the device to its beginning,
so that the next input statement will read the first record.
.B endfile
causes the file to be marked so that the record most recently written will be the last record on the file,
and any attempt to read past is an error.
.NH 1
PROCEDURES
.PP
Procedures are the basic unit of an EFL program,
and provide the means of segmenting a program into separately compilable
and named parts.
.NH 2
Procedure Statement
.PP
Each procedure begins with a statement of one of the forms
.DS B
\fBprocedure
\fIattributes \fBprocedure \fIprocedurename
\fIattributes \fBprocedure \fIprocedurename \fB( )\fR
\fIattributes \fBprocedure \fIprocedurename \fB( \fI\*([[ name \*(]] \fB) \fR
.DE
The first case specifies the main procedure, where execution begins.
In the two other cases, the
.I attributes
may specify precision and type,
or they may be omitted entirely.
The precision and type of the procedure may be declared in an ordinary declaration statement.
If no type is declared, then the procedure is called a
.I subroutine
and no value may be returned for it.
Otherwise, the procedure is a function and a value of the declared type is returned for each call.
Each
.I name
inside the parentheses in the last form above is called a
.I "formal argument"
of the procedure.
.NH 2
End Statement
.PP
Each procedure terminates with a statement
.DS C
.B
end
.R
.DE
.NH 2
Argument Association
.PP
When a procedure is invoked,
the actual arguments are evaluated.
If an actual argument is the name of a variable, an array element,
or a structure member,
that entity becomes associated with the formal argument,
and the procedure may reference the values in the object,
and assign to it.
Otherwise,
the value of the actual is associated with the formal argument,
but the procedure may not attempt to change the value of that formal argument.
.PP
If the value of one of the arguments is changed in the procedure,
it is not permitted that the corresponding actual argument be associated
with another formal argument or with a
.B common
element that is referenced in the procedure.
.NH 2
Execution and Return Values
.PP
After actual and formal arguments have been associated,
control passes to the first executable statement of the procedure.
Control returns to the invoker
either when the
.B end
statement of the procedure is reached or when a
.B return
statement is executed.
If the procedure is a function
(has a declared type),
and a
@bold return( value )@
is executed, the value
is coerced to the correct type and precision and returned.
.NH 2
Known Functions
.PP
A number of functions are known to EFL, and need not be declared.
The compiler knows the types of these functions.
Some of them are
.I generic;
i.e., they name a family of functions that differ in the types of their arguments and return values.
The compiler chooses which element of the set to invoke based upon the attributes of the actual arguments.
.NH 3
Minimum and Maximum Functions
.PP
The generic functions are
.B min
and
.B max.
The
.B min
calls return the value of their smallest argument;
the
.B max
calls return the value of their largest argument.
These are the only functions that may take different numbers of arguments in different calls.
If any of the arguments are
.B "long real"
then the result is
.B "long real".
Otherwise, if any of the arguments are
.B real
then the result is
.B real;
otherwise all the arguments and the result must be
.B integer.
Examples are
.DS B
.B
min(5, x, \-3.20)
max(i, z)
.R
.DE
.NH 3
Absolute Value
.PP
The
.B abs
function is a generic function that returns the magnitude of its argument.
For
integer and real arguments the type of the result is identical to the type of the argument;
for complex arguments the type of the result is the real of the same precision.
.NH 3
Elementary Functions
.PP
The following generic functions take arguments of
\fBreal\fR, \fBlong real\fR, or \fBcomplex\fR
type and return a result of the same type:
.DS
.TS
center;
ll.
.B
sin	sine function
cos	cosine function
exp	exponential function (@e sup x@).
log	natural (base \fIe\fP) logarithm
log10	common (base 10) logarithm
sqrt	square root function (@sqrt x@).
.R
.TE
.DE
In addition, the following functions accept only
.B real
or
.B "long real"
arguments:
.DS
.TS
center;
ll .
\fBatan\fR	@atan(x) = tan sup -1 x@
\fBatan2\fR	@atan2(x,y) = tan sup -1 x over y@
.TE
.DE
.NH 3
Other Generic Functions
.PP
The
.B sign
functions takes two arguments of identical type;
@bold sign (x,y) ~=~ sgn(y) |x|@.
The
.B mod
function yields the remainder of its first argument when divided by its second.
These functions accept integer and real arguments.
.NH 1
ATAVISMS
.PP
Certain facilities are included in the EFL language to ease the conversion of old
Fortran or Ratfor programs to EFL.
.NH 2
Escape Lines
.PP
In order to make use of nonstandard features of the local Fortran compiler,
it is occasionally necessary to pass a particular line through to the EFL compiler output.
A line that begins with a percent sign (`\fB%\fR')
is copied through to the output, with the percent sign removed but no other change.
Inside of a procedure, each escape line is treated as an executable statement.
If a sequence of lines constitute a continued Fortran statement, they should be enclosed in braces.
.NH 2
Call Statement
.PP
A subroutine call may be preceded by the keyword
.B call.
.DS B
.B
call joe
call work(17)
.R
.DE
.NH 2
Obsolete Keywords
.PP
The following keywords are recognized as synonyms of EFL keywords:
.TS
center;
cc
ll.
Fortran	EFL
.sp .3
\fBdouble precision	long real
\fBfunction	procedure
\fBsubroutine	procedure \fI(untyped)\fR
.TE
.NH 2
Numeric Labels
.PP
Standard statement labels are identifiers.
A numeric (positive integer constant) label is also permitted;
the colon is optional following a numeric label.
.NH 2
Implicit Declarations
.PP
If a name is used but does not appear in a declaration,
the EFL compiler gives a warning and assumes a declaration for it.
If it is used in the context of a procedure invocation, it is assumed to be a procedure name;
otherwise it is assumed to be a local variable defined at nesting level 1 in the current procedure.
The assumed type is determined by the first letter of the name.
The association of letters and types may be given in an
.B implicit
statement, with syntax
.DS C
\fBimplicit ( \fIletter-list\fB ) \fI type \fR
.DE
where a
.I letter-list
is a list of individual letters or ranges (pair of letters separated by a minus sign).
If no
.B implicit
statement appears, the following rules are assumed:
.DS B
.B
implicit (a\-h, o\-z) real
implicit (i\-n) integer
.R
.DE
.NH 2
Computed \fBgoto\fR
.PP
Fortran contains an indexed multi-way branch; this facility may be used in EFL
by the computed GOTO:
.DS C
\fBgoto ( \fI\*([[ label \*(]] \fB), \fIexpression\fR
.DE
The expression must be of type integer and be positive but be no larger than the number of labels in the list.
Control is passed to the statement marked by the label whose position in the list is equal to the expression.
.NH 2
Go To Statement
.PP
In unconditional and computed \fBgoto\fR
statements, it is permissible to separate the \fBgo\fR and \fBto\fR words, as in
.DS B
.B
go to xyz
.R
.DE
.NH 2
Dot Names
.PP
Fortran uses a restricted character set,
and represents certain operators by multi-character sequences.
There is an option (\fBdots=on\fR; see Section 10.2) which forces the compiler to recognize the forms
in the second column below:
.DS
.B
.TS
center;
ll.
<	.lt.
<=	.le.
>	.gt.
>=	.ge.
==	.eq.
\*~=	.ne.
&	.and.
|	.or.
&&	.andand.
|\||	.oror.
\*~	.not.
true	.true.
false	.false.
.TE
.R
.DE
In this mode, no structure element may be named
.B lt,
.B le,
etc.
The readable forms in the left column are always recognized.
.NH 2
Complex Constants
.PP
A complex constant may be written as a parenthesized list of real quantities, such as
.DS C
.B
(1.5, 3.0)
.R
.DE
The preferred notation is by a type coercion,
.DS C
.B
complex(1.5, 3.0)
.R
.DE
.NH 2
Function Values
.PP
The preferred way to return a value from a function in EFL is the
@bold return ( value )@
construct.
However, the name of the function acts as a variable to which values may be assigned;
an ordinary
@bold return@
statement returns the last value assigned to that name as the function value.
.NH 2
Equivalence
.PP
A statement of the form
.EQ C
bold equivalence ~ v sub 1 ,~  v sub 2 ,~ ...,~ v sub n
.EN
declares that each of the @v sub i@ starts at the same memory location.
Each of the @v sub i@ may be a variable name, array element name, or structure member.
.NH 2
Minimum and Maximum Functions
.PP
There are a number of non-generic functions in this category,
which differ in the required types of the arguments and the type of the return value.
They may also have variable numbers of arguments, but all the arguments must have the same type.
.DS
.TS
center;
ccc
lll .
Function	Argument Type	Result Type
_
.B
amin0	integer	real
amin1	real	real
min0	integer	integer
min1	real	integer
dmin1	long real	long real

amax0	integer	real
amax1	real	real
max0	integer	integer
max1	real	integer
dmax1	long real	long real
.R
.TE
.DE
.NH 1
COMPILER OPTIONS
.PP
A number of options can be used to control the output
and to tailor it for various compilers and systems.
The defaults chosen are conservative, but it is sometimes necessary to change the output to match peculiarities of the
target environment.
.PP
Options are set with statements of the form
.DS C
\fBoption \fI\*([[ \fIopt \fI\*(]]\fR
.DE
where each
.I opt
is of one of the forms
.DS B
.I
optionname
optionname \fB= \fIoptionvalue
.R
.DE
The
.I optionvalue
is either a constant (numeric or string) or
a name associated with that option.
The two names
.B yes
and
.B no
apply to a number of options.
.NH 2
Default Options
.PP
Each option has a default setting.
It is possible to change the whole set of defaults to those appropriate
for a particular environment
by using the
.B system
option.
At present, the only valid values are
.B system=unix
and
.B system=gcos.
.NH 2
Input Language Options
.PP
The
.B dots
option determines whether the compiler recognizes
.B .lt.
and similar forms.  The default setting is
.B no.
.NH 2
Input/Output Error Handling
.PP
The
.B ioerror
option can be given three values:
.B none
means that none of the I/O statements may be used in expressions, since there is no way to detect errors.
The implementation of the
.B ibm
form uses ERR= and END= clauses.
The implementation of the
.B fortran77
form uses IOSTAT= clauses.
.NH 2
Continuation Conventions
.PP
By default, continued Fortran statements are indicated by a character in column 6 (Standard Fortran).
The option
.B "continue=column1"
puts an ampersand (\fB&\fR) in the first column of the continued lines instead.
.NH 2
Default Formats
.PP
If no format is specified for a datum in an
iolist
for a
.B read
or
.B write
statement, a default is provided.
The default formats can be changed by setting certain options
.DS
.TS
center;
cc
ll.
Option	Type
_
\fBiformat\fR	integer
\fBrformat\fR	real
\fBdformat\fR	long real
\fBzformat\fR	complex
\fBzdformat\fR	long complex
\fBlformat\fR	logical
.TE
.DE
The associated value must be a Fortran format, such as
.DS C
.B
option rformat=f22.6
.R
.DE
.NH 2
Alignments and Sizes
.PP
In order to implement
.B character
variables, structures, and the
.B sizeof
and
.B lengthof
operators, it is necessary to know how much space various Fortran data types require,
and what boundary alignment properties they demand.
The relevant options are
.DS
.B
.TS
center;
ccc
lll.
Fortran Type	Size Option	Alignment Option
_
integer	isize	ialign
real	rsize	ralign
long real	dsize	dalign
complex	zsize	zalign
logical	lsize	lalign
.R
.TE
.DE
The sizes are given in terms of an arbitrary unit;
the alignment is given in the same units.
The option
.B charperint
gives the number of characters per
.B integer
variable.
.NH 2
Default Input/Output Units
.PP
The options
.B ftnin
and
.B ftnout
are the numbers of the standard input and output units.
The default values are
.B ftnin=5
and
.B ftnout=6.
.NH 2
Miscellaneous Output Control Options
.PP
Each Fortran procedure generated by the compiler will be preceded by the value of the
.B procheader
option.
.PP
No Hollerith strings will be passed as subroutine arguments if
.B hollincall=no
is specified.
.PP
The Fortran statement numbers normally start at 1 and increase by 1.
It is possible to change the increment value by using the
.B deltastno
option.
.ta .5i 1i 1.5i 2i 2.5i 3.0i
.NH 1
EXAMPLES
.PP
In order to show the flavor or programming in EFL,
we present a few examples.
They are short, but show some of the convenience of the language.
.NH 2
File Copying
.PP
The following short program copies the standard input to the standard output,
provided that the input is a formatted file containing
lines no longer than a hundred characters.
.DS 
.B
procedure   # main program
character(100) line

while( read( , line) == 0 )
	write( , line)
end
.R
.DE
Since
.B read
returns
zero
until the end of file (or a read error),
this program keeps reading and writing until the input is exhausted.
.NH 2
Matrix Multiplication
.PP
The following procedure multiplies the
@m times n@ matrix a
by the
@n times p@ matrix b
to give the @m times p@ matrix c.
The calculation obeys the formula
@c sub ij ~=~ sum a sub ik b sub kj@.
.DS 
.ta .7i 1.4i 2.1i 2.8i
.B
procedure matmul(a,b,c, m,n,p)
integer i, j, k, m, n, p
long real a(m,n), b(n,p), c(m,p)
.sp .3
do i = 1,m
do j = 1,p
	{
	c(i,j) = 0
	do k = 1,n
		c(i,j) += a(i,k) \(** b(k,j)
	}
end
.R
.DE
.NH 2
Searching a Linked List
.PP
Assume we have a list of pairs of numbers @(x,y)@.
The list is stored as a linked list sorted in ascending order of @x@ values.
The following procedure searches this list for a particular value of @x@
and returns the corresponding @y@ value.
.DS 
.B
.ta .7i 1.4i 2.1i 2.8i
define LAST	0
define NOTFOUND	\-1

integer procedure val(list, first, x)

#   list is an array of structures.
#   Each structure contains a thread index value, an x, and a y value.
.sp .3
struct
	{
	integer nextindex
	integer x, y
	} list(\(**)
.sp .3
integer first, p, arg

for(p = first , p\*~=LAST && list(p).x<=x , p = list(p).nextindex)
	if(list(p).x == x)
		return( list(p).y )

return(NOTFOUND)
end
.R
.DE
The search is a single
.B for
loop that begins with the head of the list
and examines items until either the list is exhausted
(p==LAST)
or until it is known that the specified value is not on the list
(list(p).x > x).
The two tests in the conjunction must
be performed in the specified order
to avoid using an invalid subscript in the
.B list(p)
reference.
Therefore, the
.B &&
operator is used.
The next element in the chain is found by the iteration statement
.B "p=list(p).nextindex".
.NH 2
Walking a Tree
.PP
As an example of a more complicated problem, let us imagine we have
an expression tree stored in a common area,
and that we want to print out an infix form of the tree.
Each node is either a leaf (containing a numeric value)
or it is a binary operator, pointing to a left and a right descendant.
In a recursive language,
such a tree walk would be implement by the following simple pseudocode:
.DS 
.I
if this node is a leaf
	print its value
otherwise
	print a left parenthesis
	print the left node
	print the operator
	print the right node
	print a right parenthesis
.R
.DE
In a nonrecursive language like EFL, it is necessary to maintain an explicit stack
to keep track of the current state of the computation.
The following procedure
calls a procedure
.B outch
to print a single character
and a procedure
.B outval
to print a value.
.DS 
.ta .7i 1.4i 2.1i 2.8i
.B
procedure walk(first)	# print out an expression tree
.sp .5
integer first		# index of root node
integer currentnode
integer stackdepth
common(nodes) struct
	{
	character(1) op
	integer leftp, rightp
	real val
	} tree(100)	# array of structures
.sp .5
struct
	{
	integer nextstate
	integer nodep
	} stackframe(100)
.sp .5
define NODE	tree(currentnode)
define STACK	stackframe(stackdepth)
.sp .5
#   nextstate values
define DOWN	1
define LEFT	2
define RIGHT	3
.DE
.DS
.B
#   initialize stack with root node
stackdepth = 1
STACK.nextstate = DOWN
STACK.nodep = first
.DE
.DS
.B
while( stackdepth > 0 )
	{
	currentnode = STACK.nodep
	select(STACK.nextstate)
		{
		case DOWN:
			if(NODE.op == " ")   # a leaf
				{
				outval( NODE.val )
				stackdepth \-= 1
				}
			else	{   # a binary operator node
				outch( "(" )
				STACK.nextstate = LEFT
				stackdepth += 1
				STACK.nextstate = DOWN
				STACK.nodep = NODE.leftp
				}
.sp .5
		case LEFT:
			outch( NODE.op )
			STACK.nextstate = RIGHT
			stackdepth += 1
			STACK.nextstate = DOWN
			STACK.nodep = NODE.rightp
.sp .5
		case RIGHT:
			outch( ")" )
			stackdepth \-= 1
		}
	}
end
.DE
.NH 1
PORTABILITY
.PP
One of the major goals of the EFL language is to make it easy to write portable programs.
The output of the EFL compiler is intended to be acceptable to any Standard Fortran
compiler
(unless the
.B fortran77
option is specified).
.NH 2
Primitives
.PP
Certain EFL operations cannot be implemented in portable Fortran,
so a few machine-dependent procedures must be provided in each environment.
.NH 3
Character String Copying
.PP
The subroutine
.B ef1asc
is called to copy one character string to another.
If the target string is shorter than the source,
the final characters are not copied.
If the target string is longer, its end is padded with blanks.
The calling sequence is
.DS B
subroutine ef1asc(a, la, b, lb)
integer a(\(**), la, b(\(**), lb
.DE
and it must copy the first
.B lb
characters from
.B b
to the first
.B la
characters of
.B a.
.NH 3
Character String Comparisons
.PP
The function
.B ef1cmc
is invoked to determine the order of two character strings.
The declaration is
.DS B
integer function ef1cmc(a, la, b, lb)
integer a(\(**), la, b(\(**), lb
.DE
The function returns a negative value if the string
.B a
of length
.B la
precedes the string
.B b
of length
.B lb.
It returns zero if the strings are equal, and a positive value otherwise.
If the strings are of differing length, the comparison is carried out
as if the end of the shorter string were padded with blanks.
.NH 1
ACKNOWLEDGMENTS
.PP
A. D. Hall originated the EFL language and wrote the first compiler for it;
he also gave inestimable aid when I took up the project.
B. W. Kernighan and W. S. Brown made a number of useful suggestions about the language and about this report.
N. L. Schryer has acted as willing, cheerful, and severe first user
and helpful critic of each new version and facility.
J. L. Blue, L. C. Kaufman, and D. D. Warner
made very useful contributions by making serious use of the compiler,
and noting and tolerating its misbehaviors.
.NH 1
REFERENCE
.IP 1.
B. W. Kernighan,
``Ratfor \(em A Preprocessor for a Rational Fortran'',
Bell Laboratories Computing Science Technical Report #55
.bp
.SH
APPENDIX A.  Relation Between EFL and Ratfor
.PP
There are a number of differences between Ratfor and EFL,
since EFL is a defined language while Ratfor is
the union of the special control structures and the language accepted by the underlying Fortran compiler.
Ratfor running over Standard Fortran is almost a subset of EFL.
Most of the features described in the Atavisms section are present to ease
the conversion of Ratfor programs to EFL.
.PP
There are a few incompatibilities:
The syntax of the
.B for
statement is slightly different in the two languages:
the three clauses are separated by semicolons in Ratfor,
but by commas in EFL.
(The initial and iteration statements may be compound statements in EFL because of this change).
The input/output syntax is quite different in the two languages,
and there is no FORMAT statement in EFL.
There are no ASSIGN or assigned GOTO statements in EFL.
.PP
The major linguistic additions are
character data,
factored declaration syntax,
block structure,
assignment and sequential test operators,
generic functions,
and
data structures.
EFL permits more general forms for expressions,
and provides a more uniform syntax.
(One need not worry about the Fortran/Ratfor restrictions
on subscript or DO expression forms, for example.)
.SH
APPENDIX B.  COMPILER
.SH
B.1.  Current Version
.PP
The current version of the EFL compiler is a two-pass translator written in
portable C.
It implements all of the features of the language described above except for
.B "long complex"
numbers.
Versions of this compiler run under the
.SM GCOS
and
.UX
operating systems.
.SH
B.2.  Diagnostics
.PP
The EFL compiler diagnoses all syntax errors.
It gives the line and file name (if known) on which the error was detected.
Warnings are given for variables that are used but not explicitly declared.
.SH
B.3.  Quality of Fortran Produced
.PP
The Fortran produced by EFL is quite clean and readable.
To the extent possible, the variable names that appear in the EFL program are used in the Fortran code.
The bodies of loops and test constructs are indented.
Statement numbers are consecutive.
Few unneeded GOTO and CONTINUE statements are used.
It is considered a compiler bug if incorrect Fortran is produced
(except for escaped lines).
The following is the Fortran procedure produced by the EFL compiler for
the matrix multiplication example (Section 11.2):
.DS B
.B
\0\0\0\0\0\0subroutine\0matmul(a,\0b,\0c,\0m,\0n,\0p)
\0\0\0\0\0\0integer\0m,\0n,\0p
\0\0\0\0\0\0double\0precision\0a(m,\0n),\0b(n,\0p),\0c(m,\0p)
\0\0\0\0\0\0integer\0i,\0j,\0k
\0\0\0\0\0\0do\0\03\0i\0=\01,\0m
\0\0\0\0\0\0\0\0\0do\0\02\0j\0=\01,\0p
\0\0\0\0\0\0\0\0\0\0\0\0c(i,\0j)\0=\00
\0\0\0\0\0\0\0\0\0\0\0\0do\0\01\0k\0=\01,\0n
\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0c(i,\0j)\0=\0c(i,\0j)+a(i,\0k)*b(k,\0j)
\0\0\01\0\0\0\0\0\0\0\0\0\0\0continue
\0\0\02\0\0\0\0\0\0\0\0continue
\0\0\03\0\0\0\0\0continue
\0\0\0\0\0\0end
.R
.DE
The following is the procedure for the tree walk (Section 11.4):
.DS B
.B
\0\0\0\0\0\0subroutine\0walk(first)
\0\0\0\0\0\0integer\0first
\0\0\0\0\0\0common\0/nodes/\0tree
\0\0\0\0\0\0integer\0tree(4,\0100)
\0\0\0\0\0\0real\0tree1(4,\0100)
\0\0\0\0\0\0integer\0staame(2,\0100),\0stapth,\0curode
\0\0\0\0\0\0integer\0const1(1)
\0\0\0\0\0\0equivalence\0(tree(1,1),\0tree1(1,1))
\0\0\0\0\0\0data\0const1(1)/4h\0\0\0\0/
c\0print\0out\0an\0expression\0tree
c\0index\0of\0root\0node
c\0array\0of\0structures
c\0\0\0nextstate\0values
c\0\0\0initialize\0stack\0with\0root\0node
\0\0\0\0\0\0stapth\0=\01
\0\0\0\0\0\0staame(1,\0stapth)\0=\01
\0\0\0\0\0\0staame(2,\0stapth)\0=\0first
\0\0\01\0\0if\0(stapth\0.le.\00)\0goto\0\09
\0\0\0\0\0\0\0\0\0curode\0=\0staame(2,\0stapth)
\0\0\0\0\0\0\0\0\0goto\0\07
\0\0\02\0\0\0\0\0\0\0\0if\0(tree(1,\0curode)\0.ne.\0const1(1))\0goto\03
\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0call\0outval(tree1(4,\0curode))
c\0a\0leaf
\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0stapth\0=\0stapth-1
\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0goto\0\04
\0\0\03\0\0\0\0\0\0\0\0\0\0\0call\0outch(1h()
c\0a\0binary\0operator\0node
\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0staame(1,\0stapth)\0=\02
\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0stapth\0=\0stapth+1
\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0staame(1,\0stapth)\0=\01
\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0staame(2,\0stapth)\0=\0tree(2,\0curode)
\0\0\04\0\0\0\0\0\0\0\0goto\0\08
\0\0\05\0\0\0\0\0\0\0\0call\0outch(tree(1,\0curode))
\0\0\0\0\0\0\0\0\0\0\0\0staame(1,\0stapth)\0=\03
\0\0\0\0\0\0\0\0\0\0\0\0stapth\0=\0stapth+1
\0\0\0\0\0\0\0\0\0\0\0\0staame(1,\0stapth)\0=\01
\0\0\0\0\0\0\0\0\0\0\0\0staame(2,\0stapth)\0=\0tree(3,\0curode)
\0\0\0\0\0\0\0\0\0\0\0\0goto\0\08
\0\0\06\0\0\0\0\0\0\0\0call\0outch(1h))
\0\0\0\0\0\0\0\0\0\0\0\0stapth\0=\0stapth-1
\0\0\0\0\0\0\0\0\0\0\0\0goto\0\08
\0\0\07\0\0\0\0\0\0\0\0if\0(staame(1,\0stapth)\0.eq.\03)\0goto\0\06
\0\0\0\0\0\0\0\0\0\0\0\0if\0(staame(1,\0stapth)\0.eq.\02)\0goto\0\05
\0\0\0\0\0\0\0\0\0\0\0\0if\0(staame(1,\0stapth)\0.eq.\01)\0goto\0\02
\0\0\08\0\0\0\0\0continue
\0\0\0\0\0\0\0\0\0goto\0\01
\0\0\09\0\0continue
\0\0\0\0\0\0end
.R
.DE
.SH
APPENDIX C.  CONSTRAINTS ON THE DESIGN OF THE EFL LANGUAGE
.PP
Although Fortran can be used to simulate any finite computation,
there are realistic limits on the generality of a language that can be
translated into Fortran.
The design of EFL was constrained by the implementation strategy.
Certain of the restrictions are petty (six character external names),
but others are sweeping (lack of pointer variables).
The following paragraphs describe the major limitations imposed by Fortran.
.SH
C.1.  External Names
.PP
External names (procedure and COMMON block names)
must be no longer than six characters in Fortran.
Further, an external name is global to the entire program.
Therefore, EFL can support block structure within a procedure,
but it can have only one level of external name if the
EFL procedures are to be compilable separately,
as are Fortran procedures.
.SH
C.2.  Procedure Interface
.PP
The Fortran standards, in effect, permit arguments to be passed between
Fortran procedures either by reference or by copy-in/copy-out.
This indeterminacy of specification shows through into EFL.
A program that depends on the method of argument transmission is
illegal in either language.
.PP
There are no procedure-valued variables in Fortran: a procedure name may
only be passed as an argument or be invoked; it cannot be stored.
Fortran (and EFL) would be noticeably simpler if a procedure variable mechanism
were available.
.SH
C.3.  Pointers
.PP
The most grievous problem with Fortran is its lack of a pointer-like
data type.
The implementation of the compiler would have been far easier if certain hard
cases could have been handled by pointers.
Further, the language could have been simplified considerably if pointers were
accessible in Fortran.
(There are several ways of simulating pointers by using subscripts,
but they founder on the problems of external variables and initialization.)
.SH
C.4.  Recursion
.PP
Fortran procedures are not recursive,
so it was not practical to permit EFL procedures to be recursive.
(Recursive procedures with arguments can be simulated only with great pain.)
.SH
C.5.  Storage Allocation
.PP
The definition of Fortran does not specify the lifetime of variables.
It would be possible but cumbersome to implement stack or heap
storage disciplines by using COMMON blocks.
