Parentheses and operator precedence

Expression evaluation is from left to right; parentheses and operator precedence modify this.

When parentheses are encountered (other than those that identify function calls) the entire subexpression between the parentheses is evaluated immediately when the term is required.

When the following sequence is encountered, and operator2 has a higher precedence than operator1, the subexpression (term2 operator2 term3) is evaluated first. The same rule is applied repeatedly as necessary.
term1 operator1 term2 operator2 term3

However, individual terms are evaluated from left to right in the expression (that is, as soon as they are encountered). The precedence rules affect only the order of operations.

For example, * (multiply) has a higher priority than + (add), so 3+2*5 evaluates to 13 (rather than the 25 that would result if strict left to right evaluation occurred). To force the addition to occur before the multiplication, you could rewrite the expression as (3+2)*5. Adding the parentheses makes the first three tokens a subexpression. Similarly, the expression -3**2 evaluates to 9 (instead of -9) because the prefix minus operator has a higher priority than the power operator.

The order of precedence of the operators is as follows:
  1. + - ¬ \ (prefix operators)
  2. ** (power)
  3. * / % // (multiply and divide)
  4. + - (add and subtract)
  5. (blank) || (abuttal) (concatenation with or without blank)
  6. Comparison operators:
    • = > <
    • == >> <<
    • \= ¬=
    • >< <>
    • \> ¬>
    • \< ¬<
    • \== ¬==
    • \>> ¬>>
    • \<< ¬<<
    • >= >>=
    • <= <<=
    • /= /==
  7. & (and)
  8. | && (or, exclusive or)

Examples

The symbol A is a variable with a value of 3, DAY is a variable with a value of Monday, and other variables are uninitialized. The example expressions have the following evaluations: 
A+5                  ->    '8'
A-4*2                ->    '-5'
A/2                  ->    '1.5'
0.5**2               ->    '0.25'
(A+1)>7              ->    '0'         /* that is, False */
' '=''               ->    '1'         /* that is, True  */
' '==''              ->    '0'         /* that is, False */
' '¬==''             ->    '1'         /* that is, True  */
(A+1)*3=12           ->    '1'         /* that is, True  */
'077'>'11'           ->    '1'         /* that is, True  */
'077' >> '11'        ->    '0'         /* that is, False */
'abc' >> 'ab'        ->    '1'         /* that is, True  */
'abc' << 'abd'       ->    '1'         /* that is, True  */
'ab ' << 'abd'       ->    '1'         /* that is, True  */
Today is Day         ->    'TODAY IS Monday'
'If it is' day       ->    'If it is Monday'
Substr(Day,2,3)      ->    'ond'    /* Substr is a function */
'!'xxx'!'            ->    '!XXX!'
'000000' >> '0E0000' ->    '1'         /* that is, True  */
Note: In the last example, the answer is different if the operator is > rather than >>. Because '0E0000' is a valid number in exponential notation, a numeric comparison is done; thus '0E0000' and '000000' evaluate as equal. The REXX order of precedence usually causes no difficulty because it is the same as in conventional algebra and other computer languages. There are two differences from common notations:
  • The prefix minus operator always has a higher priority than the power operator.
  • Power operators (like other operators) are evaluated left-to-right.
For example: 
-3**2     ==  9  /* not -9  */
-(2+1)**2 ==  9  /* not -9  */
2**2**3   == 64  /* not 256 */