as: Infix Ops

 
 6.2.4 Infix Operators
 ---------------------
 
 "Infix operators" take two arguments, one on either side.  Operators
 have precedence, but operations with equal precedence are performed left
 to right.  Apart from '+' or '-', both arguments must be absolute, and
 the result is absolute.
 
   1. Highest Precedence
 
      '*'
           "Multiplication".
 
      '/'
           "Division".  Truncation is the same as the C operator '/'
 
      '%'
           "Remainder".
 
      '<<'
           "Shift Left".  Same as the C operator '<<'.
 
      '>>'
           "Shift Right".  Same as the C operator '>>'.
 
   2. Intermediate precedence
 
      '|'
 
           "Bitwise Inclusive Or".
 
      '&'
           "Bitwise And".
 
      '^'
           "Bitwise Exclusive Or".
 
      '!'
           "Bitwise Or Not".
 
   3. Low Precedence
 
      '+'
           "Addition".  If either argument is absolute, the result has
           the section of the other argument.  You may not add together
           arguments from different sections.
 
      '-'
           "Subtraction".  If the right argument is absolute, the result
           has the section of the left argument.  If both arguments are
           in the same section, the result is absolute.  You may not
           subtract arguments from different sections.
 
      '=='
           "Is Equal To"
      '<>'
      '!='
           "Is Not Equal To"
      '<'
           "Is Less Than"
      '>'
           "Is Greater Than"
      '>='
           "Is Greater Than Or Equal To"
      '<='
           "Is Less Than Or Equal To"
 
           The comparison operators can be used as infix operators.  A
           true results has a value of -1 whereas a false result has a
           value of 0.  Note, these operators perform signed comparisons.
 
   4. Lowest Precedence
 
      '&&'
           "Logical And".
 
      '||'
           "Logical Or".
 
           These two logical operations can be used to combine the
           results of sub expressions.  Note, unlike the comparison
           operators a true result returns a value of 1 but a false
           results does still return 0.  Also note that the logical or
           operator has a slightly lower precedence than logical and.
 
    In short, it's only meaningful to add or subtract the _offsets_ in an
 address; you can only have a defined section in one of the two
 arguments.