Conditional Expressions

All commands using conditions (COND, IF, DO,FOR, WHILE) use the same syntax and evaluation rules. A condition consists of one or more comparisons which are joined with logical (binary) operators. Each comparison compares two values and can evaluate to true or false.

condition = comparison [loperator comparison loperator … comparison loperator]

comparison

A comparison comprising two expressions separated by a comparison operator. There are two types of comparison supported - see below for comparison operators for details. Both types of comparison can be used within one IF command.

loperator

A logical operator, which combines the results of two comparisons. Logical operators are evaluated strictly from left to right; bracketing is not possible; it is explicitly undefined if a part of an expression that is strictly not required for judging on the truth, or falshood, of the whole expression, gets evaluated, or not.

Logical Operators

The logical operators supported by STx conditional commands are the following:

AND

returns true if both comparison results are true

&&

the same as AND

OR

returns true if either of the comparison results are true

||

the same as OR

• Logical operators are evaluated strictly from left to right.
• Bracketing is not possible.
• It is explicitly undefined if a part of an expression that is strictly not required for judging on the truth, or falshood, of the whole expression, gets evaluated, or not. So you should not use expressions with side-effects.

Comparison Operators

STx supports two types of comparison operator:

1. Simple comparison operators for numerical expression and case-insensitive string comparisons.
2. Pattern matching operators using wild-cards or regular expressions. These pattern matching operators may be applied to strings or, more specifically, to STx names.

The general syntax for a comparison is as follows:

expression operator expression

expression

A numerical expression or a string.

operator

A comparison operator (see below).

Simple Comparison

A simple comparison will be numerical if both arguments are numerical. Otherwise, a case-insensitive string comparison will be performed.

There are the following simple comparison operators:

==

evaluates to true if both sides are equal.

!=

evaluates to true if sides are not equal

<

evaluates to true if the left hand side is less than the right hand side

>

evaluates to true if the left hand side is greater than the right hand side

<=

evaluates to true if the left hand side is less than or equal to the right hand side

>=

evaluates to true if the left hand side is greater than or equal to the right hand side

Pattern Matching

The general syntax of a pattern-matching comparison is:

string operator mask

For example:

'the quick brown fox' !SI '*brown*' // search for the word 'brown' in the left hand side string

Note that, instead of a string, the argument to a pattern matching comparison may also be an STx name, i.e. a string subject to the syntax restrictions for STx names. You can discern the full string comparison operators from the name comparison operators by there second character which is "S" for string comparison (e.g. !SI), and "N" for name comparison (e.g. !NI).

There are two types of pattern matching supported by STx conditional commands:

1. Wild-card pattern matching
2. POSIX regular expression pattern matching

Wild-card pattern matching

=SI	returning true if string matches pattern, ignoring the case
!SI	returning true if string does not match pattern, ignoring the case
=SR	returning true if the string matches the pattern, respecting the case
!SR	returning true if the string does not match the pattern, respecting the case
=NI	returning true if name matches pattern, ignoring the case
!NI	returning true if name does not match pattern, ignoring the case
=NR	returning true if the name matches the pattern, respecting the case
!NR	returning true if the name does not match the pattern, respecting the case

POSIX regular expression pattern matching

=RSI	returns true if the string matches the regular expression, ignoring case
!RSI	returns true if string does not match the regular expression, ignoring the case
=RSR	returns true if the string matches the regular expression, respecting case
!RSR	returns true if the string does not match the regular expression, respecting the case
=RNI	returns true if the name matches the regular expression, ignoring case
!RNI	returns true if name does not match the regular expression, ignoring the case
=RNR	returns true if the string matches the regular expression, respecting case
!RNR	returns true if the name does not match the regular expression, respecting the case

Regular expressions make heavy use of characters that have a special meaning for STx. In order to use such characters, you need to escape them with the STx escape character, "`" (back-tick). The STx regular expressions are implemented using the TRE library.

Examples

For an example of regular expression in use, see the example script file regular_expressions.sts.