An expression is a constant, a variable, an array element, a function or a combination of these with one or more operators. The result of an expression will be an integer, a numeric or a text value. Operators are discussed below. Expressions can be used wherever constants can be used: in assignments, in comparisons, as part of a larger expression or as an argument in an ADAPL function.

Arithmetic expressions

If a calculation consists of a number of different expressions (e.g. 2 + 3 * 2 / 10 - 5), Collections will evaluate them in a fixed order. This order corresponds with the standard arithmetic order: exponentiation, multiplication, division, integer modulus, addition, and subtraction. The table below shows the operators that can be used in numeric expressions, in order of evaluation:

The following functions with a numeric or integer result are available in arithmetic expressions:

Text expressions

One operator is available in ADAPL for text expressions: +. The ‘plus’ sign concatenates text strings. For example:

ERRORM 'He said:' + '''' + 'Hello!' + '''' + '.'
* four consecutive quotes as separate (sub) string are
* required to actually include (display) only one quote (see also ADAPL constants).

The result of this instruction appears on screen: He said: 'Hello!'.

The following functions with a text result are available for text expressions:

Logical expressions

Logical expressions are expressions that contain logical operators and operators for comparison. The result of a logical expression is either TRUE or FALSE. These values are defined numerically: 0 represents FALSE, any other value represents TRUE.

Integers and numerics are interchangeable for logical expressions. With text comparisons, the value of the logical expression is numeric.

ADAPL allows the following operators for logical expressions:

Tag indirection

Tag indirection means that the content of a text variable is treated as if it were a database tag. Typically, tag indirection is used when the database tags you wish to use in your code, are also ADAPL reserved words or commands, like for instance the do tag in the PEOPLE database: only by entering the tag as a string (in between quotes) into the code, ADAPL won't treat it as a command.
The indirection operator, the exclamation mark, is placed immediately before this variable, to use this functionality. To access subsequent elements of the tag, simply add the required occurrence number, enclosed in round or square brackets, to the name of the string.

The following piece of code displays the first line of the title of a book:

text tag_var[2]
tag_var = 'ti' /* title
errorm !tag_var[1]

With a dataset that has been opened using FACS, the FACS name of the dataset must be included in the text variable before the tag, e.g.:

text domain_tag[15]
domain_tag = 'PEOPLE do'
errorm !domain_tag[1]

This piece of code will display the first occurrence of the domain field in the PEOPLE database.
Note that a FACS declaration cannot contain the tag do, nor can you use tag indirection inside the FACS declaration so you have to use the method shown above.
Also note that all tags in an opened FACS database addressed in above shown way, no longer have to be specified in the FACS declaration.

Reading a FACS database (with the read command) using tag indirection is possible as well, but if that tag is an enumerative field too, then searching will only yield results if the Collections interface language is English. So the following only works in English and therefor shouldn't be used at all:

text domain_tag[15]
domain_tag = 'SUPPLIER do'
read SUPPLIER using !domain_tag = 'SUPPLIER'

The indirection operator may also appear in a different context, to directly address a tag in a record buffer, including tags which are also reserved words in ADAPL. Records buffers include FACS-declared databases and adlib_lite (which contains the contents or a currently edited record). For example, to retrieve the contents of the do tag from the currently edited record and display it in an error message:

errorm adlib_lite!do

Another example for the case in which a FACS database People has been declared:

if (enumval$(People!do, People!do, -1) = 'AUTHOR'){ … }

Sequence of evaluation in an expression

In the case of compound expressions, Collections will evaluate the various expressions in a fixed sequence. This sequence is based on the standard arithmetic sequence: exponentiation, multiplication, division, addition, and subtraction. Collections adheres to the following order:

In the event of equal priority, ADAPL will evaluate an expression from left to right.

Expressions and functions can occur within other expressions and functions if they are embedded in round brackets (). The evaluation always begins with the expression in the innermost round brackets, then working outwards. If expressions are used for comparisons, the expressions are evaluated before the comparison is carried out.

The sequence of evaluation in logical expressions is:

Independent expressions which are embedded in round brackets are evaluated first.