This is the instruction set of the intermediate code --

Commands are in one of these forms:
   <op>  <ma1>  <ma2>  <ma3>
   <op>  <ma1>  <ma2>
   <op>  <ma1>

<op> is the operation to be performed.
<ma1>, <ma2>, and <ma3> are three memory addresses.
Sometimes <ma1>, <ma2>, or <ma2> is a number.

The <op> portion usually has the format of
  xxyy
where xx is the basic operation and yy specifies the type.


instruction                  type         action
---------------------        ---------    ----------------------------------
LD#I    <ma1>  <num>         integer      [ma1] <-- number
LD#C    <ma1>  <num>         cardinal     [ma1] <-- number
LD#CH   <ma1>  <num>         char         [ma1] <-- number
LD#R    <ma1>  <num>         real         [ma1] <-- number
LD#BS   <ma1>  <num>         bitset       [ma1] <-- number

LDI     <ma1>  <ma2>         integer      [ma1] <-- [ma2]
LDC     <ma1>  <ma2>         cardinal     [ma1] <-- [ma2]
LDCH    <ma1>  <ma2>         char         [ma1] <-- [ma2]
LDR     <ma1>  <ma2>         real         [ma1] <-- [ma2]
LDBS    <ma1>  <ma2>         bitset       [ma1] <-- [ma2]

LD@I    <ma1> <ma2> <off>    integer      [ma1] <-- [[ma2]+off]
LD@C    <ma1> <ma2> <off>    cardinal     [ma1] <-- [[ma2]+off]
LD@R    <ma1> <ma2> <off>    real         [ma1] <-- [[ma2]+off]
LD@CH   <ma1> <ma2> <off>    char         [ma1] <-- [[ma2]+off]
LD@BS   <ma1> <ma2> <off>    bitset       [ma1] <-- [[ma2]+off]

ST@I    <ma1> <ma2> <off>    integer      [[ma1]+off] <-- [ma2]
ST@C    <ma1> <ma2> <off>    cardinal     [[ma1]+off] <-- [ma2]
ST@R    <ma1> <ma2> <off>    real         [[ma1]+off] <-- [ma2]
ST@CH   <ma1> <ma2> <off>    char         [[ma1]+off] <-- [ma2]
ST@BS   <ma1> <ma2> <off>    bitset       [[ma1]+off] <-- [ma2]
ST@B    <ma1> <ma2> <off>    boolean      [[ma1]+off] <-- [ma2]

MULI    <ma1>  <ma2>         integer      [ma1] <-- [ma1] * [ma2]
MULC    <ma1>  <ma2>         cardinal     [ma1] <-- [ma1] * [ma2] (unsigned)
MULR    <ma1>  <ma2>         real         [ma1] <-- [ma1] * [ma2]
MULBS   <ma1>  <ma2>         bitset       [ma1] <-- [ma1] * [ma2] (set intersection)

ADDI    <ma1>  <ma2>         integer      [ma1] <-- [ma1] + [ma2]
ADDC    <ma1>  <ma2>         cardinal     [ma1] <-- [ma1] + [ma2] (unsigned)
ADDR    <ma1>  <ma2>         real         [ma1] <-- [ma1] + [ma2]
ADDBS   <ma1>  <ma2>         bitset       [ma1] <-- [ma1] + [ma2] (set union)

INDX    <ma1>  <ma2>  <ma3>  mixed        [ma1] <-- ma2(addr) + [ma3](card)

SUBI    <ma1>  <ma2>         integer      [ma1] <-- [ma1] + [ma2]
SUBC    <ma1>  <ma2>         cardinal     [ma1] <-- [ma1] + [ma2] (unsigned)
SUBR    <ma1>  <ma2>         real         [ma1] <-- [ma1] + [ma2]
SUBBS   <ma1>  <ma2>         bitset       [ma1] <-- [ma1] + [ma2] (set difference)

CPI     <ma1>  <ma2>         integer      set flags by : [ma1] - [ma2]
CPC     <ma1>  <ma2>         cardinal     set flags by : [ma1] - [ma2]
CPCH    <ma1>  <ma2>         char         set flags by : [ma1] - [ma2]
CPR     <ma1>  <ma2>         real         set flags by : [ma1] - [ma2]
CPB     <ma1>  <ma2>         boolean      set flags by : [ma1] - [ma2]
CPBS    <ma1>  <ma2>         bitset       set flags by : [ma1] - [ma2]

DIVI    <ma1>  <ma2>         integer      [ma1] <-- [ma1] / [ma2] (integer div)
DIVC    <ma1>  <ma2>         cardinal     [ma1] <-- [ma1] / [ma2] (unsigned int div)
DIVR    <ma1>  <ma2>         cardinal     [ma1] <-- [ma1] / [ma2]

MODI    <ma1>  <ma2>         integer      [ma1] <-- [ma1] MOD [ma2]
MODC    <ma1>  <ma2>         cardinal     [ma1] <-- [ma1] MOD [ma2] (unsigned)

ANDB    <ma1>  <ma2>         boolean      [ma1] <-- [ma1] AND [ma2]
ORB     <ma1>  <ma2>         boolean      [ma1] <-- [ma1] OR [ma2]

NEGI    <ma1>                integer      [ma1] <--   - [ma1]
NEGR    <ma1>                real         [ma1] <--   - [ma1]

INCC    <ma1>  <num>         cardinal     [ma1] <-- [ma1] + <num>
DECC    <ma1>  <num>         cardinal     [ma1] <-- [ma1] - <num>
SCALE   <ma1>  <num>         cardinal     [ma1] <-- [ma1] * <num>

CTOI    <ma1>  <ma2>         mixed        [ma1] (int) <-- [ma2] (card)
ITOC    <ma1>  <ma2>         mixed        [ma1] (card) <-- [ma2] (int)
CHTOC   <ma1>  <ma2>         mixed        [ma1] (card) <-- [ma2] (char)
BTOC    <ma1>  <ma2>         mixed        [ma1] (card) <-- [ma2] (boolean)

* note that the action taken depends on the type of the compare operation
* immediately preceeding the jump.
JUN     <ma1>                jump         jump to ma1 unconditional
JLT     <ma1>                jump         jump to ma1 if less than
JGT     <ma1>                jump         jump to ma1 if greater than
JLE     <ma1>                jump         jump to ma1 if less than or equal
JGE     <ma1>                jump         jump to ma1 if greater than or equal
JEQ     <ma1>                jump         jump to ma1 if equal
JNE     <ma1>                jump         jump to ma1 if not equal