The LET Statement

.

In addition to dealing with the assignment statement here, we will also go over the rules governing expressions in EXALT.

The LET or assignment statement has the form

       LET variable/variable...=expression;
           error-clause,error-clause...

where variable can be a simple variable, an array element, or a whole array.

Recommended @-comments, which may also be used as &'...' replacements:

       LET var @AND/ var @EQUAL= expression @UPON;
           error-clause, error-clause

Array subscripts can be full general expressions, and are enclosed by the same normal parentheses as function arguments. Both some predefined functions, and user-defined 'left-hand functions', may also be the object of an assignment.

A LET statement may also assign a value to two or more variables. Such a statement might look like this:

       LET X/Y/Z=3

The = sign can also be used as a relational operator; that is, A=B is a valid expression, returning a result of type LOGICAL. Thus,

       LET A=B=C

does not assign C to B and A; instead, it assigns either _T or _F to A depending on whether or not B and C are equal.

A cautionary example of how this can possibly lead to confusion is the statement

       LET A/B=C=D/E

which assigns either _T or _F to A and B depending on whether or not C is equal to D divided by E.

For this reason, in FORTRAN, a multiple assignment statement uses the comma instead of the equals sign to separate all left-hand assignment arguments. The slash (/), which is also a symbol found within expressions (it expresses division) is used instead in EXALT to allow assignments, even multiple assignments, to be used as arguments to subprograms. Since the comma is a possible argument separator, using it for this purpose would preclude that.

In addition to allowing the slash or diaresis to be used on the left side of an equals sign, the plus sign is also allowed on the left side of the equals sign, to permit statements like this:

       DIM ARRAY(3)
...
       LET A+B+C=ARRAY

which allows the elements of the array ARRAY to be individually assigned to the variables A, B, and C, making the assignment statement equivalent to the three assignment statements

       LET A=ARRAY(1)
       LET B=ARRAY(2)
       LET C=ARRAY(3)

A similar form of component-wise assignment is present in Python. When a multi-dimensional array is assinged, parentheses are required when more than one level of the structure is broken up; for example:

       DIM SOURCE(2,3), TARGET(2,3)
       DIM P(3),Q(3)
...
       TARGET/(A+B+C)+(D+E+F)/P+Q=SOURCE

performs the assignments

       LET P=SOURCE(1,)
       LET Q=SOURCE(2,)
       LET A=SOURCE(1,1)
       LET B=SOURCE(1,2)
       LET C=SOURCE(1,3)
       LET D=SOURCE(2,1)
       LET E=SOURCE(2,2)
       LET F=SOURCE(2,3)
       LET TARGET=SOURCE

Again, in a multiple assignment statement, all assignments are directly from the expression on the right of the equals sign, so no type conversions performed for any one assignment affect other assignments.

The symbol ?= indicates an assignment operator that always performs assignment, and is never a relational operator. After a ?=, equals signs are interpreted as being relational in the remainder of an assignment statement just as they would after the first =. An expression, the last term in which is a variable, can precede a ?= (provided it is not the first assignment operator, ?= or first =, in the assignment) and the last term is the recipient of the assignment. That is,

       . A=1+B?=C

is equivalent to

       . B=C
       . A=1+B

as is the case with the distinctive assignment operators used in languages such as APL, ALGOL, Pascal, and C.

In the assignment statement

      . X=N*J?=L+M

note that ?= acts on J on its left side, and L+M on its right side. Thus, ?=, if we think of it as having priority, has priority lower than + on the right side, but priority higher than * on the left side. On the other hand,

      . T?=V(N)?=5

assigns 5 to V(N), not to N. Thus, array subscripting and, towards the left, the assignment operator, can be considered to have very high priorities, and the assignment operator can be considered to have a very low priority towards the right.

While / and = have different meanings at the start of an assignment statement, ?= has its usual meaning, except that it also indicates the end of the unusual start of the assignment statement. Thus, ?= can replace the first = in an assignment statement. User-defined operators also have their usual meanings at this point, subject to the same qualification as for ?= . Thus, a normal user-defined operator would lead to a statement that calculated, but didn't store the result, but user-defined assigment operators become able to be used here.

This also applies to the other built-in assignment operator, the operator/function &A(op) .

Another way to store intermediate results in an assignment is through the use of argument brackets within an expression. The statement

     . R=A*[P]B+C

is equivalent to either

     . P=A*B
     . R=P+C

or

     . R=C+P?=A*B

Note that the second form would not be correct if the + sign were replaced by a - sign. In addition to this, the use of argument brackets within an expression provides additional flexibility by allowing the secondary result of an operator to be stored. This is done by placing a second argument within the square brackets.

Two operators have secondary results. The division operator, /, has as its secondary result the remainder of the division, provided that both of the arguments of the division are of an INTEGER type. The &ANG operator has the square root of the sum of the squares of its arguments as its secondary result.

Thus, a conversion from rectangular to polar coordinates can be expressed as:

     . THETA=X &ANG[,R] Y

Note that a space is not required to separate ANG from [, although other optional spaces are shown in the assignment for clarity.

Incidentally, the behavior of division and remainder, when integers can be both positive and negative, is as follows:

    A      B      A/B    remainder
   11      5       2         1
  -11      5      -2        -1
   11     -5      -2         1
  -11     -5       2        -1

Thus, the absolute values of quotient and remainder are the same when the absolute values of the dividend and the divisor are the same; only the signs are changed to make the result consistent.

The error-clauses are usually omitted. An error-clause has the form

     condition = alternative

and causes the alternative to be taken when the condition is present. Conditions are:

ERR     any error in evaluating the expression
FAIL    an error, or a negative result to a search, relational
        or membership operator
FXO     fixed overflow
FLO     floating overflow
FLU     floating underflow

Where a non-error condition is encountered, as with FAIL, the assignment is performed before the alternative is taken.

An expression may be a constant, a variable, a dyadic operator between two expressions, either of which may be in parentheses, a function with expressions as arguments, a unary operator acting on an expression, or an operator-function with expressions in all appropriate locations. This is, of course, a rule with which complicated expressions can be built from constants and variables.

A variable can be an array element. A constant can be an expression in itself, so it might be better to refer to simple constants. A simple constant is a sequence of digits, or a decimal point either preceded or followed or both by a sequence of digits, a character string in quotes, or an entity formed by use of the % symbol. Other constants are simply expressions which include no variables but which include at least one simple constant.

Operators are performed from left to right in an expression unless they differ in priority, higher priority operators being performed first. The elementary operators in EXALT, grouped according to priority, separated by commas, and preceded by their numerical priority levels, are:

Expressions as well as arrays can be subscripted by being followed by an expression or series of expressions in parentheses without an intervening operator.

Many of these operators perform familiar operations. Those that may not be obvious are described below:

&ADD, &SUB, &MUL, and &DIV act upon arrays of integer type numbers (along only the last dimension of any array) to perform multi-precision arithmetic using the array as one large number. Any fixed-point or scale specification applying to the elements of the array is taken to apply to the array as a whole, and thus variables may be declared to have a fixed-point type such that the maximum value of a single variable of that type would be much less than 1, even though this would mean that multiplication of simple variables of such a type would always produce a zero result. (These operators are defined as the operations they represent are most effectively performed using portions of the results of arithmetic operations usually discarded when going from assembly language to a higher-level language, but they are sufficiently specialized that the alternative of defining a type BIGNUM(integer-type) upon which +, -, * and / can act was not considered reasonable: partly because there would be no intention of allowing _SIN, _SQR, let alone _GAMMA, to act on such variables.)

Thus,

       . X &A.(+) 1

is equivalent to

        . X=X+1

which makes &A.(+) equivalent to += in the language C.

Operators and functions are syntactically distinct within the programs that call them, and may also have different calling sequences. Also, arguments may be omitted within function calls. Therefore, it is necessary to indicate explicitly whether a function is being used as an operator or as a function.

Predefined operators are represented by tokens beginning with an ampersand, continuing with the name of the operator. The token is ended by any character other than a letter; if the next thing to follow begins with a letter, a space is needed.

User-defined operators are indicated by preceding their names with an ampersand, then surrounding their names by periods. The trailing period cannot be mistaken for a decimal point as a pair of special characters are required to close the token begun with an ampersand; thus, &.OP.5 is perfectly legal, and operates on five, not one-half.

An operator can have, as its right operand, an expression that happens to begin with a left parenthesis. Thus, operator/functions are distinguished by placing a period between the operator and the left parenthesis following it which begins the argument list to join the parenthesized clause to the operator.

To use a function as an operator is possible in two ways; through use of the ALIAS statement, which will be described considerably later in this manual, or by placing its name between colons following an ampersand. This applies to built-in functions as well, and the leading underscore is a part of the function's name in this case. Note that the use of colons (which are separators) following the ampersand does not indicate that the resulting token is a separator, unlike the case for tokens which begin with a question mark.

In terms of the calling sequence for operators created from functions, a &:op: b is equivalent to op(a,b) and a &:op:.(x...) b is equivalent to op(x...,a,b) whatever separators may be used within the area x... . The default priority for operators is 95, which applies to all user-defined operators unless explicitly declared, and to all built-in functions other than those given in the list of operators above.

Also, &:op: a is equivalent to op(a) while b &:op: is equivalent to op(,b), not the other way around.

For user-defined operators and operators created from functions, an explicit priority can be indicated by placing the number, (if unsigned) immediately after the ampersand. As 95 is the default priority, this means that &95.op. is equivalent to &.op.*nbsp;, and &95:op: is equivalent to &:op: .

Note that AND and OR do not have the same priority, but OR and XOR do. Also, the logical operators can act on INTEGER and UNSIGNED type operands, performing bitwise operations in that case. This fact does not constrain the internal representation of LOGICAL constants; for example, the bit pattern 00000001 might correspond to _T. Thus, &NOT K, where K is of type LOGICAL, and has the value _T with the above representation, could produce a result with the internal representation 00000000, whereas if K were of BYTE type, the result would have the representation 11111110.

These operators can act on arrays, producing array-valued results, as well as on simple variables.

For example, the program

       INTEGER A(3)/5,6,7/,B(3)/2,3,4/,C(3)
       . C=A*B
     7 FOR I=1,3
       PRINT C(I)
       REPEAT 7
       END

would produce the output

10
18
28

An array-valued constant can be generated with the function _A, which produces an array containing its arguments. Thus, B above could have been replaced by _A(2,3,4).

The built-in operators and functions of EXALT, if they perform a function upon a single number or string or other object, normally perform the same function upon each element of an array if given arrays as their arguments; if they perform a function upon an array of n dimensions, given an array with more dimensions, each subarray corresponding to a value of the previous dimensions is affected by that function, producing a part of the array result. However, there are some exceptions: functions such as _IF and _CASE, and operators that affect multi-dimensional arrays in special ways relating to their dimensionality, such as .RH .

Many functions are built into the EXALT language. Here is a list of some of them:

The functions _NUMBER and _PRESENT concern argument passing, which is discussed in the description of the FUNCTION statement below, and other non-arithmetical functions will be dealt with in connection with the appropriate topic.

Functions with no arguments usually represent constants:

_PI

3.14159..., the ratio of the circumference of a circle to its diameter

_E

2.71828..., the base of the natural logarithms

_GAMMA

0.57721..., Euler's constant

_I

i, the principal value of the square root of minus one

_J

j, the second imaginary unit quaternion

_K

k, the third imaginary unit quaternion

_T

the LOGICAL value meaning 'true'

_F

the LOGICAL value meaning 'false'

_NIL

the value of a MUTABLE variable having the value of a one-dimensional array of MUTABLE values with zero elements

_FBASE

the number (most commonly 2, 8, 16, or 10) a power of which is directly indicated by the exponent part of a floating-point number in its internal form.

but not always:

_RAND

a random number uniformly distributed between 0 and 1, with 0, but not 1, as a possible value for it.

_PAR

a character string containing any options for program execution specified in the operating system command invoking the program (as many operating systems allow text to be passed to a program in the command to execute that program).

_TERM

_T if the program has been invoked from a terminal and is potentially in communication with the user; _F if it is running in batch mode.

In addition to non-arithmetical functions, EXALT also posesses pseudofunctions. These have the same syntax as functions, but may only be used within certain types of statements, and take actions which depend on information elsewhere in the statement, producing results which may not belong to any EXALT type.

Most commonly, pseudofunctions are found in input/output statements; the _TAB(position) and _IND(keyname,value) pseudofunctions are examples.

Also, there are some functions in EXALT which can appear on the left-hand side of the equals sign in an assignment statement. Thus, while they have a syntax resembling that of functions, they receive a result rather than producing one. The simpler LEFT_FUNCTIONS in EXALT are the following:

       . A='EV' ?+ ('AE' ?/ 'RO')