Expressions

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 people.inf (or possible tags like if, is, on, no, or): only* by entering the tag as a string (in between quotes) into the code, ADAPL won't treat it as a command. To put it in other words: you cannot refer anywhere in ADAPL code to a field tag like do, because do is also a reserved word in ADAPL (it can appear in a DO ... UNTIL loop, for example). Only everything in between quotes doesn't conflict with reserved words or commands, because everything in between quotes, is considered a meaningless character string by ADAPL.

Tag indirection is just a clever trick to allow you to use a tag like do still, by changing a meaningless character string into some meaningful still: the idea is that you declare a text variable of sufficient length, then you assign the (meaningless) character string 'do' to it (including the quotes) and from then on, if you'd like to retrieve the contents of the field tag do, you'll use the text variable name with an exclamation mark (the indirection operator) directly in front of it. That way, ADAPL will take the string from the variable but treats it as field tag.
In a before-storage adapl for people.inf for example (where you have direct access to all field tags in the record about to be saved) you could put the contents of tag do via an error message on screen like so:

text tag_var[2]
tag_var = 'do' /* name type
errorm !tag_var

Note that the length of the variable has been set to two because do consists of two characters, but you can set the length to a bigger value too. And the you name the variable any way you like, it doesn't have to be tag_var.

To access a specific occurrence of the tag, simply add the occurrence number enclosed in round or square brackets behind the variable name:

errorm !tag_var[2]

In the above example, field tags from the record were directly accessible because the code was assumed to be part of before-storage code. However, if you need access to a different database table than the one that you're currently working in, you will be using FACS. And if from that other database table you need to retrieve data from tags like do, then what do you do? Because also a FACS declaration is not allowed to contain tags that are also reserved words, nor can you use tag indirection inside a FACS declaration, so you have to solve this differently but still similar to the examples above.

So you can't include the tag in the FACS declaration, but you can still assign it as a string to a text variable. This time though, the FACS name of the dataset must be included in the text variable in front of the tag, separated by a space e.g.:

fdstart MYPEOPLE '../data+people>people'
  %0 is MYPEOPLE_priref
  BA is MYPEOPLE_name
fdend

open MYPEOPLE
if &E {
  errorm 'FACS database table MYPEOPLE could not be opened. Error: ' + &E
  end
}

text domain_tag[15]
domain_tag = 'MYPEOPLE do'
read MYPEOPLE using MYPEOPLE_priref = 1
if (&E = 0) {
  errorm 'Name and first name type in record 1: ' + MYPEOPLE_name + ', ' + !domain_tag[1]
}
end

Note that you can use the above methods of tag indirection for all tags in an opened (FACS or current) database table, not necessarily only for tags which conflict with reserved words, but then those (non-conflicting) tags do not need 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 therefore 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 (without using those tags as strings). Records buffers include FACS-declared datasets and adlib_lite (which contains the contents of 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, you can also use:

errorm adlib_lite!do

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

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.