Forth V4.0/V4.2 Assembler Glossary

This glossary describes the library of words used in assembly language programming within the Forth environment. Assembly mode is switched on using the CODE or >ASSM keywords, and switched off using END.CODE or >FORTH. Please consult the assembly programming manual for instruction in using the Forth assembler.

For help in understanding the notation used in the following function definitions, consult the description of stack symbols, abbreviations and naming conventions.

Software development in Forth (and its in-line assembler) uses the Mosaic IDE Integrated Development Environment; this is the same IDE used for software development in C. While Forth programmers will not use the IDE's C compiler, the IDE provides a full-featured text editor and customized terminal for rapid code downloads and interactive debugging sessions with the 68HC11 processor on the controller board.

The following glossary entries are alphabetized in ASCII Order: >ABCDEFGHIJKLMNOPQRSTUVWXYZ

>ASSM ( -- )

Consult the main glossary.

>FORTH ( -- )

Consult the main glossary.

ABA ( -- )

Compiles the opcode sequence for the ABA instruction into the dictionary. When later executed, this code adds the contents of accumulator A and accumulator B, and stores the result in accumulator A.
Pronunciation: "add-b-to-a"

ABX ( -- )

Compiles the opcode sequence for the ABX instruction into the dictionary. When later executed, this code adds the unsigned 8 bit contents of accumulator B to the contents of register X and leaves the result in X.
Pronunciation: "add-b-to-x"

ABY ( -- )

Compiles the opcode sequence for the ABY instruction into the dictionary. When later executed, this code adds the unsigned 8 bit contents of accumulator B to the contents of register Y and leaves the result in Y.
Pronunciation: "add-b-to-y"

ADCA ( arg\mode -- )

Compiles the opcode sequence for the ADCA instruction into the dictionary. When later executed, this code adds the carry bit to the sum of the operand (specified by arg and mode) and the contents of accumulator A, and places the result in accumulator A.
Pronunciation: "add-with-carry-to-a"

ADCB ( arg\mode -- )

Compiles the opcode sequence for the ADCB instruction into the dictionary. When later executed, this code adds the carry bit to the sum of the operand (specified by arg and mode) and the contents of accumulator B, and places the result in accumulator B.
Pronunciation: "add-with-carry-to-b"

ADDA ( arg\mode -- )

Compiles the opcode sequence for the ADDA instruction into the dictionary. When later executed, this code adds the operand (specified by arg and mode) and the contents of accumulator A, and places the result in accumulator A.
Pronunciation: "add-a"

ADDB ( arg\mode -- )

Compiles the opcode sequence for the ADDB instruction into the dictionary. When later executed, this code adds the operand (specified by arg and mode) and the contents of accumulator B, and places the result in accumulator B.
Pronunciation: "add-b"

ADDD ( arg\mode -- )

Compiles the opcode sequence for the ADDD instruction into the dictionary. When later executed, this code adds the operand (specified by arg and mode) and the contents of accumulator D, and places the result in accumulator D.
Pronunciation: "add-d"

AGAIN, ( -- )

Used within a code definition to designate the end of an assembly coded infinite loop. Use as:

BEGIN,    <code to be iterated>
AGAIN, 

The words between BEGIN, and AGAIN, are executed indefinitely. AGAIN, is equivalent to NEVER UNTIL,
Pronunciation: "again-comma"

ALWAYS ( -- condition )

Within a code definition, leaves a condition flag on the data stack. Indicates an "always true" condition.

ANDA ( arg\mode -- )

Compiles the opcode sequence for the ANDA instruction into the dictionary. When later executed, this code performs the logical AND of the operand (specified by arg and mode) and the contents of accumulator A, and places the result in accumulator A.
Pronunciation: "and-a"

ANDB ( arg\mode -- )

Compiles the opcode sequence for the ANDB instruction into the dictionary. When later executed, this code performs the logical AND of the operand (specified by arg and mode) and the contents of accumulator B, and places the result in accumulator B.
Pronunciation: "and-b"

ANY.BITS.CLR ( -- condition )

Within a code definition, leaves a condition flag on the data stack. Used in conjunction with a single-byte argument (which we'll designate as P) and a bit mask (designated as Q). The condition is true if any bits are clear in the result obtained by performing the logical AND operation P AND Q. This condition code is associated with the test and branch instructions BRSET and BRCLR.
Pronunciation: "any-bits-clear"

ANY.BITS.SET ( -- condition )

Within a code definition, leaves a condition flag on the data stack. Used in conjunction with a single-byte argument (which we'll designate as P) and a bit mask (designated as Q). The condition is true if any bits are set in the result obtained by performing the logical AND operation P AND Q. This condition code is associated with the test and branch instructions BRSET and BRCLR.

ASL ( arg\mode -- )

Compiles the opcode sequence for the ASL instruction into the dictionary. When later executed, this code causes an arithmetic shift left of the 8-bit operand which is specified by arg and mode. The C (carry) bit in the CCR is loaded from the most significant bit of arg, and 0 is shifted into the least significant bit.
Pronunciation: "arithmetic-shift-left"

ASLA ( -- )

Compiles the opcode sequence for the ASLA instruction into the dictionary. When later executed, this code causes an arithmetic shift left of the contents of accumulator A. The C (carry) bit in the CCR is loaded from the most significant bit of accumulator A, and 0 is shifted into the least significant bit.
Pronunciation: "arithmetic-shift-left-a"

ASLB ( -- )

Compiles the opcode sequence for the ASLB instruction into the dictionary. When later executed, this code causes an arithmetic shift left of the contents of accumulator B. The C (carry) bit in the CCR is loaded from the most significant bit of accumulator B, and 0 is shifted into the least significant bit.
Pronunciation: "arithmetic-shift-left-b"

ASLD ( -- )

Compiles the opcode sequence for the ASLD instruction into the dictionary. When later executed, this code causes an arithmetic shift left of the contents of accumulator D. The C (carry) bit in the CCR is loaded from the most significant bit of accumulator D, and 0 is shifted into the least significant bit.
Pronunciation: "arithmetic-shift-left-d"

ASR ( arg\mode -- )

Compiles the opcode sequence for the ASR instruction into the dictionary. When later executed, this code causes an arithmetic shift right of the operand specified by arg and mode. The C (carry) bit in the CCR is loaded from the least significant bit of arg. The most significant bit is held constant.
Pronunciation: "arithmetic-shift-right"

ASRA ( -- )

Compiles the opcode sequence for the ASRA instruction into the dictionary. When later executed, this code causes an arithmetic shift right of the contents of accumulator A. The C (carry) bit in the CCR is loaded from the least significant bit of accumulator A. The most significant bit is held constant.
Pronunciation: "arithmetic-shift-right-a"

ASRB ( -- )

Compiles the opcode sequence for the ASRB instruction into the dictionary. When later executed, this code causes an arithmetic shift right of the contents of accumulator B. The C (carry) bit in the CCR is loaded from the least significant bit of accumulator B. The most significant bit is held constant.
Pronunciation: "arithmetic-shift-right-b"

ASSEMBLER ( -- )

Consult the main glossary.

BCC ( arg\mode -- | mode must be REL )

Compiles the opcode sequence for the BCC instruction into the dictionary. When later executed, this code executes a branch to the address equal to PC + arg + 2, if C in CCR is clear.
Pronunciation: "branch-if-carry-clear"

BCLR ( byte1\arg\mode -- | byte1 = mask )

Compiles the opcode sequence for the BCLR instruction into the dictionary. When later executed, this code clears bits in the operand (specified by arg and mode) which are set in the mask byte1.
Pronunciation: "bit-clear"

BCS ( arg\mode -- | mode must be REL )

Compiles the opcode sequence for the BCS instruction into the dictionary. When later executed, this code executes a branch to the address equal to PC + arg + 2, if C in CCR is set.
Pronunciation: "branch-if-carry-set"

BEGIN, ( -- )

Used within a code definition to designate the beginning of a looping structure. Use as:

BEGIN, . . . . condition.flag UNTIL, 

or

BEGIN, . . . . condition.flag WHILE, . . . . REPEAT, 

or

BEGIN, . . . . AGAIN, 

The words after UNTIL, or REPEAT, are executed after the loop structure terminates. BEGIN, . . . . AGAIN, is an infinite loop.
Pronunciation: "begin-comma"

BEQ ( arg\mode -- | mode must be REL )

Compiles the opcode sequence for the BEQ instruction into the dictionary. When later executed, this code executes a branch to the address equal to PC + arg + 2, if Z in CCR is set.
Pronunciation: "branch-if-equal"

BGE ( arg\mode -- | mode must be REL )

Compiles the opcode sequence for the BGE instruction into the dictionary. When later executed, this code executes a branch to the address equal to PC + arg + 2, if either N and V in the CCR are both set, or N and V are both clear. Typically used after a subtraction or comparison of signed numbers, causes a branch if the result is greater than or equal to 0.
Pronunciation: "branch-if-greater-than-or-equal-to"

BGT ( arg\mode -- | mode must be REL )

Compiles the opcode sequence for the BGT instruction into the dictionary. When later executed, this code executes a branch to the address equal to PC + arg + 2, if Z is clear, and either N and V in the CCR are both set, or N and V are both clear. Typically used after a subtraction or comparison of signed numbers, causes a branch if the result is greater than 0.
Pronunciation: "branch-if-greater-than"

BHI ( arg\mode -- | mode must be REL )

Compiles the opcode sequence for the BHI instruction into the dictionary. When later executed, this code executes a branch to the address equal to PC + arg + 2, if C and Z in CCR are both clear. Typically used after a subtraction or comparison of unsigned numbers, causes a branch if the result is greater than 0.
Pronunciation: "branch-if-higher"

BHS ( arg\mode -- | mode must be REL )

Compiles the opcode sequence for the BHS instruction into the dictionary. When later executed, this code executes a branch to the address equal to PC + arg + 2, if C in CCR is clear. Typically used after a subtraction or comparison of unsigned numbers, causes a branch if the result is greater than or equal to 0.
Pronunciation: "branch-if-higher-or-same"

BITA ( arg\mode -- )

Compiles the opcode sequence for the BITA instruction into the dictionary. When later executed, this code modifies the bits in the condition code register according to the result of performing a logical AND between the operand (specified by arg and mode) and accumulator A. Neither the contents of accumulator A nor the operand are affected.
Pronunciation: "bit-test-a"

BITB ( arg\mode -- )

Compiles the opcode sequence for the BITB instruction into the dictionary. When later executed, this code modifies the bits in the condition code register according to the result of performing a logical AND between the operand (specified by arg and mode) and accumulator B. Neither the contents of accumulator B nor the operand are affected.
Pronunciation: "bit-test-b"

BLE ( arg\mode -- | mode must be REL )

Compiles the opcode sequence for the BLE instruction into the dictionary. When later executed, this code executes a branch to the address equal to PC + arg + 2, if Z is set, or N is set and V is clear, or N is clear and V is set in the CCR. Typically used after a subtraction or comparison of signed numbers, causes a branch if the result is less than or equal to 0.
Pronunciation: "branch-if-less-than-or-equal-to"

BLO ( arg\mode -- | mode must be REL )

Compiles the opcode sequence for the BCS instruction into the dictionary. When later executed, this code executes a branch to the address equal to PC + arg + 2, if C in CCR is set. Typically used after a subtraction or comparison of unsigned numbers, causes a branch if the result is less than 0.
Pronunciation: "branch-if-lower or same"

BLS ( arg\mode -- | mode must be REL )

Compiles the opcode sequence for the BLS instruction into the dictionary. When later executed, this code executes a branch to the address equal to PC + arg + 2, if either C or Z in CCR is set. Typically used after a subtraction or comparison of unsigned numbers, causes a branch if the result is less than or equal to 0.
Pronunciation: "branch-if-lower-or-same"

BLT ( arg\mode -- | mode must be REL )

Compiles the opcode sequence for the BLT instruction into the dictionary. When later executed, this code executes a branch to the address equal to PC + arg + 2, if either N is set and V is clear in the CCR, or N is clear and V is set. Typically used after a subtraction or comparison of signed numbers, causes a branch if the result is less than 0.
Pronunciation: "branch-if-less-than"

BMI ( arg\mode -- | mode must be REL )

Compiles the opcode sequence for the BMI instruction into the dictionary. When later executed, this code executes a branch to the address equal to PC + arg + 2, if N in CCR is set.
Pronunciation: "branch-if-minus"

BNE ( arg\mode -- | mode must be REL )

Compiles the opcode sequence for the BNE instruction into the dictionary. When later executed, this code executes a branch to the address equal to PC + arg + 2, if Z in CCR is clear.
Pronunciation: "branch-if-not-equal"

BPL ( arg\mode -- | mode must be REL )

Compiles the opcode sequence for the BPL instruction into the dictionary. When later executed, this code executes a branch to the address equal to PC + arg + 2, if N in CCR is clear.
Pronunciation: "branch-if-plus"

BRA ( arg\mode -- | mode must be REL )

Compiles the opcode sequence for the BRA instruction into the dictionary. When later executed, this code executes an unconditional branch to the address equal to PC + arg + 2.
Pronunciation: "branch-always"

BRCLR ( byte1\mode1\byte2\arg\mode2 -- | byte1=offset, mode1=REL, byte2 =mask )

Compiles the opcode sequence for the BRCLR instruction into the dictionary. When later executed, this code causes a branch to an address if the bits set in the mask byte2 are clear in the operand specified by arg and mode2. The address branched to is equal to

PC + 4 + byte1 

when mode2 is DIR or IND,X. When mode2 is IND,Y the address branched to is

PC + 5 + byte1 

Pronunciation: "branch-if-bits-clear"

BRN ( arg\mode -- | mode must be REL )

Compiles the opcode sequence for the BRN instruction into the dictionary. When later executed, this code acts as a two byte NOP instruction.
Pronunciation: "branch-never"

BRSET ( byte1\mode1\byte2\arg\mode2 -- | byte1=offset, mode1=REL, byte2=mask )

Compiles the opcode sequence for the BRSET instruction into the dictionary. When later executed, this code causes a branch to an address if the bits set in the mask byte2 are also set in the operand specified by arg and mode2. The address branched to is equal to

PC + 4 + byte1 

when mode2 is DIR or IND,X. When mode2 is IND,Y the address branched to is

PC + 5 + byte1

Pronunciation: "branch-if-bits-set"

BSET ( byte1\arg\mode -- | byte1 = mask )

Compiles the opcode sequence for the BSET instruction into the dictionary. When later executed, this code sets bits in the operand (specified by arg and mode) which are set in the mask byte1.
Pronunciation: "bit-set"

BSR ( arg\mode -- | mode must be REL )

Compiles the opcode sequence for the BSR instruction into the dictionary. When later executed, this code causes the PC to be incremented by 2 and pushed onto the return stack, and then branches to the address equal to PC + arg.
Pronunciation: "branch-to-subroutine"

BVC ( arg\mode -- | mode must be REL )

Compiles the opcode sequence for the BVC instruction into the dictionary. When later executed, this code executes a branch to the address equal to PC + arg + 2, if V in CCR is clear.
Pronunciation: "branch-if-overflow-clear"

BVS ( arg\mode -- | mode must be REL )

Compiles the opcode sequence for the BVS instruction into the dictionary. When later executed, this code executes a branch to the address equal to PC + arg + 2, if V in CCR is set.
Pronunciation: "branch-if-overflow-set"

CALL ( <name> -- )

Consult the main glossary.

CBA ( -- )

Compiles the opcode sequence for the CBA instruction into the dictionary. When later executed, this code modifies the bits in the condition code register according to the comparison A - B. The contents of accumulators A and B are not affected.
Pronunciation: "compare-b-to-a"

CC ( -- condition )

Used within a code definition, leaves a condition flag on the data stack. The condition is true when the carry flag in the condition code register is 0. Note: if you wish to use the hex number CC within an assembly definition, type it as 0CC to avoid confusion with this condition code.
Pronunciation: "carry-clear"

CLC ( -- )

Compiles the opcode sequence for the CLC instruction into the dictionary. When later executed, this code clears the C (carry) bit in the condition code register.
Pronunciation: "clear-carry"

CLI ( -- )

Compiles the opcode sequence for the CLI instruction into the dictionary. When later executed, this code clears the I (global interrupt enable) bit in the condition code register. Maskable interrupts are enabled when the I bit is clear.
Pronunciation: "clear-interrupt-mask"

CLR ( arg\mode -- )

Compiles the opcode sequence for the CLR instruction into the dictionary. When later executed, this code clears the contents of the operand specified by arg and mode.
Pronunciation: "clear"

CLRA ( -- )

Compiles the opcode sequence for the CLRA instruction into the dictionary. When later executed, this code clears the contents of accumulator A.
Pronunciation: "clear-a"

CLRB ( -- )

Compiles the opcode sequence for the CLRB instruction into the dictionary. When later executed, this code clears the contents of accumulator B.
Pronunciation: "clear-b"

CLV ( -- )

Compiles the opcode sequence for the CLV instruction into the dictionary. When later executed, this code clears the V bit (the 2s complement overflow bit) in the CCR.
Pronunciation: "clear-overflow-bit"

CMPA ( arg\mode -- )

Compiles the opcode sequence for the CMPA instruction into the dictionary. When later executed, this code subtracts the operand specified by arg and mode from the contents of accumulator A and sets the condition code register bits accordingly. The operand and accumulator A are unaffected.
Pronunciation: "compare-a"

CMPB ( arg\mode -- )

Compiles the opcode sequence for the CMPB instruction into the dictionary. When later executed, this code subtracts the operand specified by arg and mode from the contents of accumulator B and sets the condition code register bits accordingly. The operand and accumulator B are unaffected.
Pronunciation: "compare-b"

CODE ( <name> -- )

Consult the main glossary.

COM ( arg\mode -- )

Compiles the opcode sequence for the COM instruction into the dictionary. When later executed, this code replaces the operand specified by arg and mode with its ones complement.
Pronunciation: "complement"

COMA ( -- )

Compiles the opcode sequence for the COMA instruction into the dictionary. When later executed, this code replaces the contents of accumulator A with its ones complement (which is formed by complementing the state of each bit).
Pronunciation: "complement-a"

COMB ( -- )

Compiles the opcode sequence for the COMB instruction into the dictionary. When later executed, this code replaces the contents of accumulator B with its ones complement (which is formed by complementing the state of each bit).
Pronunciation: "complement-b"

CPD ( arg\mode -- )

Compiles the opcode sequence for the CPD instruction into the dictionary. When later executed, this code subtracts the operand specified by arg and mode from the contents of accumulator D and sets the condition code register bits accordingly. The operand and accumulator D are unaffected.
Pronunciation: "compare-d"

CPX ( arg\mode -- )

Compiles the opcode sequence for the CPX instruction into the dictionary. When later executed, this code subtracts the operand specified by arg and mode from the contents of accumulator X and sets the condition code register bits accordingly. The operand and accumulator X are unaffected.
Pronunciation: "compare-x"

CPY ( arg\mode -- )

Compiles the opcode sequence for the CPY instruction into the dictionary. When later executed, this code subtracts the operand specified by arg and mode from the contents of accumulator Y and sets the condition code register bits accordingly. The operand and accumulator Y are unaffected.
Pronunciation: "compare-y"

CS ( -- condition )

Used within a code definition, leaves a condition flag on the data stack. The condition is true when the carry flag in the condition code register is 1.
Pronunciation: "carry-set"

DAA ( -- )

Compiles the opcode sequence for the DAA instruction into the dictionary. When later executed, this code decimal adjusts the contents of accumulator A to facilitate binary-coded-decimal calculations. For a detailed description of operation, consult the DAA entry in the Motorola HC11 manual.
Pronunciation: "decimal-adjust-a"

DEC ( arg\mode -- )

Compiles the opcode sequence for the DEC instruction into the dictionary. When later executed, this code subtracts one from the operand specified by arg and mode.
Pronunciation: "decrement"

DECA ( -- )

Compiles the opcode sequence for the DECA instruction into the dictionary. When later executed, this code subtracts one from the contents of accumulator A.
Pronunciation: "decrement-a"

DECB ( -- )

Compiles the opcode sequence for the DECB instruction into the dictionary. When later executed, this code subtracts one from the contents of accumulator B.
Pronunciation: "decrement-b"

DES ( -- )

Compiles the opcode sequence for the DES instruction into the dictionary. When later executed, this code subtracts one from the contents of the S register which is the return stack pointer.
Pronunciation: "decrement-s"

DEX ( -- )

Compiles the opcode sequence for the DEX instruction into the dictionary. When later executed, this code subtracts one from the contents of the index register X.
Pronunciation: "decrement-x"

DEY ( -- )

Compiles the opcode sequence for the DEY instruction into the dictionary. When later executed, this code subtracts one from the contents of the index register Y.
Pronunciation: "decrement-y"

DIR ( -- mode )

Used within a code definition, leaves a constant on the stack indicating that the direct addressing mode should be used by an instruction opcode.
Pronunciation: "direct"

ELSE, ( -- )

ELSE, is used in assembly coded routines to mark the beginning of the "else portion" of a conditional structure. Use as:

condition IF,    . . . .
ELSE,    . . . .
ENDIF,  ( or THEN,) 

When executed, ELSE, causes a branch instruction to be compiled into the dictionary and resolves IF,'s branch. When the compiled code is later executed, the code between ELSE, and ENDIF, is executed if the condition is not met.
Pronunciation: "else-comma"

END-CODE ( sys -- | balances CODE )

A synonym for END.CODE. Consult the main glossary.

END.CODE ( sys -- | balances CODE )

Consult the main glossary.

ENDIF, ( -- )

ENDIF, is used in assembly coded routines to mark the end of a conditional IF, structure. ENDIF, and THEN, are synonyms. Use as:

condition IF,    . . . .
ELSE,    . . . .
ENDIF, 

When executed, ENDIF, resolves the branch instructions used in the conditional structure. When the code compiled by the control structure is executed, the code between IF, and ELSE, is executed if the condition is true, and then control passes to the code following ENDIF,. If the condition is false, the code between ELSE, and ENDIF, is executed, and execution continues with the code following ENDIF,. An alternate form is

condition IF, . . . . ENDIF, 

When the code compiled by this control structure is executed, the code between IF, and ENDIF, is executed if the condition is true, and is not executed if the condition is false.
Pronunciation: "end-if-comma"

EORA ( arg\mode -- )

Compiles the opcode sequence for the EORA instruction into the dictionary. When later executed, this code performs a logical exclusive or between the contents of accumulator A and the operand specified by arg and mode. The result is stored in accumulator A.
Pronunciation: "exclusive-or-a"

EORB ( arg\mode -- )

Compiles the opcode sequence for the EORB instruction into the dictionary. When later executed, this code performs a logical exclusive or between the contents of accumulator B and the operand specified by arg and mode. The result is stored in accumulator B.
Pronunciation: "exclusive-or-b"

EQ ( -- condition )

Used within a code definition, leaves a condition flag on the data stack. Used after a comparison of the form P - Q, indicates the condition P = Q. Alternate interpretation: Condition is true if the Z bit in the condition code register is set.
Pronunciation: "equal"

EXT ( -- mode )

Used within a code definition, leaves a constant on the stack indicating that the extended addressing mode should be used by an instruction opcode.
Pronunciation: "extended"

FDIV ( -- )

Compiles the opcode sequence for the FDIV instruction into the dictionary. When later executed, this code performs an unsigned fractional divide of the 16-bit numerator in accumulator D by the 16-bit denominator in the index register X. The quotient is stored in index register X and the remainder is stored in accumulator D.
Pronunciation: "fractional-divide"

GE ( -- condition )

Within a code definition, leaves a condition flag on the data stack. Used after a comparison of the form P - Q, indicates the condition P ≥ Q using signed math. Alternate interpretation: Condition is true if the N and V bits in the condition code register are either both set or both clear.
Pronunciation: "greater-than-or-equal-to"

GT ( -- condition )

Within a code definition, leaves a condition flag on the data stack. Used after a comparison of the form P - Q, indicates the condition P > Q using signed math. Alternate interpretation: Condition is true if the Z bit is clear, and the N and V bits are either both set or both clear in the condition code register.
Pronunciation: "greater-than"

HI ( -- condition )

Within a code definition, leaves a condition flag on the data stack. Used after a comparison of the form P - Q, indicates the condition P > Q using unsigned math. Alternate interpretation: Condition is true if C and Z in the condition code register are zero.
Pronunciation: "higher"

HS ( -- condition )

Within a code definition, leaves a condition flag on the data stack. Used after a comparison of the form P - Q, indicates the condition P ≥ Q using unsigned math. Alternate interpretation: Condition is true if the C (carry) bit in the condition code register is clear.
Pronunciation: "higher-or-same"

IDIV ( -- )

Compiles the opcode sequence for the IDIV instruction into the dictionary. When later executed, this code performs an unsigned integer divide of the 16-bit numerator in accumulator D by the 16-bit denominator in the index register X. The quotient is stored in index register X and the remainder is stored in accumulator D.
Pronunciation: "integer-divide"

IF, ( condition -- )

IF, is used in assembly coded routines to mark the start of a conditional structure. Use as:

condition IF,    . . . .
ELSE,    . . . .
ENDIF,   ( or THEN,) 

or

condition IF,    . . . .
ENDIF,   ( or THEN,) 

When the branch compiled by IF, is executed, the code following IF, is executed if the condition is met, otherwise control is transferred to the code following ELSE, or ENDIF,. (THEN, and ENDIF, are synonyms).
Pronunciation: "if-comma"

IMM ( -- mode )

Used within a code definition, leaves a constant on the stack indicating that the immediate addressing mode should be used by an instruction opcode.
Pronunciation: "immediate"

INC ( arg\mode -- )

Compiles the opcode sequence for the INC instruction into the dictionary. When later executed, this code adds one to the operand specified by arg and mode.
Pronunciation: "increment"

INCA ( -- )

Compiles the opcode sequence for the INCA instruction into the dictionary. When later executed, this code adds one to the contents of accumulator A.
Pronunciation: "increment-a"

INCB ( -- )

Compiles the opcode sequence for the INCB instruction into the dictionary. When later executed, this code adds one to the contents of accumulator B.
Pronunciation: "increment-b"

IND,X ( -- mode )

Used within a code definition, leaves a constant on the stack indicating that the index register X addressing mode should be used by an instruction opcode.
Pronunciation: "indexed-x"

IND,Y ( -- mode )

Used within a code definition, leaves a constant on the stack indicating that the index register Y addressing mode should be used by an instruction opcode.
Pronunciation: "indexed-y"

INH ( -- )

Defined as a no-op. May be used within a code definition if desired to indicate the inherent addressing mode.
Pronunciation: "inherent"

INS ( -- )

Compiles the opcode sequence for the INS instruction into the dictionary. When later executed, this code adds one to the S register which is the return stack pointer.
Pronunciation: "increment-s"

INX ( -- )

Compiles the opcode sequence for the INX instruction into the dictionary. When later executed, this code adds one to index register X.
Pronunciation: "increment-x"

INY ( -- )

Compiles the opcode sequence for the INY instruction into the dictionary. When later executed, this code adds one to index register Y.
Pronunciation: "increment-y"

JMP ( arg\mode -- )

Compiles the opcode sequence for the JMP instruction into the dictionary. When later executed, this code transfers control to the instruction stored at the effective address specified by arg and mode.
Pronunciation: "jump"

JSR ( arg\mode -- )

Compiles the opcode sequence for the JSR instruction into the dictionary. When later executed, this code increments PC properly and pushes it onto the return stack. Program control is then transferred to the effective address specified by arg and mode.
Pronunciation: "jump-to-subroutine"

LDAA ( arg\mode -- )

Compiles the opcode sequence for the LDAA instruction into the dictionary. When later executed, this code loads the operand specified by arg and mode into accumulator A.
Pronunciation: "load-accumulator-a"

LDAB ( arg\mode -- )

Compiles the opcode sequence for the LDAB instruction into the dictionary. When later executed, this code loads the operand specified by arg and mode into accumulator B.
Pronunciation: "load-accumulator-b"

LDD ( arg\mode -- )

Compiles the opcode sequence for the LDD instruction into the dictionary. When later executed, this code loads the operand specified by arg and mode into accumulator D.
Pronunciation: "load-d"

LDS ( arg\mode -- )

Compiles the opcode sequence for the LDS instruction into the dictionary. When later executed, this code loads the operand specified by arg and mode into the S register which is the return stack pointer.
Pronunciation: "load-s"

LDX ( arg\mode -- )

Compiles the opcode sequence for the LDX instruction into the dictionary. When later executed, this code loads the contents of the operand specified by arg and mode into index register X.
Pronunciation: "load-x"

LDY ( arg\mode -- )

Compiles the opcode sequence for the LDY instruction into the dictionary. When later executed, this code loads the contents of the operand specified by arg and mode into index register Y.
Pronunciation: "load-y"

LE ( -- condition )

Used within a code definition, leaves a condition flag on the data stack. Used after a comparison of the form P - Q, indicates the condition P ≤ Q using signed math. Alternate interpretation: Condition is true if the Z bit is set, or the N bit is set and V bit is clear, or the N bit is clear and the V bit is set in the condition code register.
Pronunciation: "less-than-or-equal-to"

LO ( -- condition )

Used inside a code definition, leaves a condition flag on the data stack. Used after a comparison of the form P - Q, indicates the condition P < Q using unsigned math. Alternate interpretation: Condition is true if the C (carry) bit in the condition code register is set.
Pronunciation: "lower"

LS ( -- condition )

Used within a code definition, leaves a condition flag on the data stack. Used after a comparison of the form P - Q, indicates the condition P ≤ Q using unsigned math. Alternate interpretation: Condition is true if either C or Z in the condition code register is set.
Pronunciation: "lower-or-same"

LSL ( arg\mode -- )

Compiles the opcode sequence for the LSL instruction into the dictionary. When later executed, this code causes a logical shift left of the 8-bit operand which is specified by arg and mode. The C (carry) bit in the CCR is loaded from the most significant bit of arg, and 0 is shifted into the least significant bit.
Pronunciation: "logical-shift-left"

LSLA ( -- )

Compiles the opcode sequence for the LSLA instruction into the dictionary. When later executed, this code causes a logical shift left of the contents of accumulator A. The C (carry) bit in the CCR is loaded from the most significant bit of accumulator A, and 0 is shifted into the least significant bit.
Pronunciation: "logical-shift-left-a"

LSLB ( -- )

Compiles the opcode sequence for the LSLB instruction into the dictionary. When later executed, this code causes a logical shift left of the contents of accumulator B. The C (carry) bit in the CCR is loaded from the most significant bit of accumulator B, and 0 is shifted into the least significant bit.
Pronunciation: "logical-shift-left-b"

LSLD ( -- )

Compiles the opcode sequence for the LSLD instruction into the dictionary. When later executed, this code causes a logical shift left of the contents of accumulator D. The C (carry) bit in the CCR is loaded from the most significant bit of accumulator D, and 0 is shifted into the least significant bit.
Pronunciation: "logical-shift-left-d"

LSR ( arg\mode -- )

Compiles the opcode sequence for the LSR instruction into the dictionary. When later executed, this code causes a logical shift right of the contents of the operand specified by arg and mode. The C (carry) bit in the CCR is loaded from the least significant bit of arg. A 0 is shifted into the most significant bit.
Pronunciation: "logical-shift-right"

LSRA ( -- )

Compiles the opcode sequence for the LSRA instruction into the dictionary. When later executed, this code causes a logical shift right of the contents of accumulator A. The C (carry) bit in the CCR is loaded from the least significant bit of accumulator A. A 0 is shifted into the most significant bit.
Pronunciation: "logical-shift-right-a"

LSRB ( -- )

Compiles the opcode sequence for the LSRB instruction into the dictionary. When later executed, this code causes a logical shift right of the contents of accumulator B. The C (carry) bit in the CCR is loaded from the least significant bit of accumulator B. A 0 is shifted into the most significant bit.
Pronunciation: "logical-shift-right-b"

LSRD ( -- )

Compiles the opcode sequence for the LSRD instruction into the dictionary. When later executed, this code causes a logical shift right of the contents of accumulator D. The C (carry) bit in the CCR is loaded from the least significant bit of accumulator D. A 0 is shifted into the most significant bit.
Pronunciation: "logical-shift-right-d"

LT ( -- condition )

Used within a code definition, leaves a condition flag on the data stack. Used after a comparison of the form P - Q, indicates the condition P < Q using signed math. Alternate interpretation: Condition is true if the N bit is set and V bit is clear, or the N bit is clear and the V bit is set in the condition code register.
Pronunciation: "less-than"

MI ( -- condition )

Used within a code definition, leaves a condition flag on the data stack. Used after a comparison of the form P - Q = R, indicates the condition R < 0 using signed math. Alternate interpretation: Condition is true if the N bit in the condition code register is set.
Pronunciation: "minus"

MUL ( -- )

Compiles the opcode sequence for the MUL instruction into the dictionary. When later executed, this code multiplies the contents of accumulator A by the contents of accumulator B and stores the result in accumulator D.
Pronunciation: "multiply"

NE ( -- condition )

Used within a code definition, leaves a condition flag on the data stack. Used after a comparison of the form P - Q, indicates the condition P not equal to Q. Alternate interpretation: Condition is true if the Z bit in the condition code register is clear.
Pronunciation: "not-equal"

NEG ( arg\mode -- )

Compiles the opcode sequence for the NEG instruction into the dictionary. When later executed, this code replaces the contents of the operand specified by arg and mode with its twos complement which is formed by inverting the state of each bit and adding 1.
Pronunciation: "negate"

NEGA ( -- )

Compiles the opcode sequence for the NEGA instruction into the dictionary. When later executed, this code replaces the contents of accumulator A with its twos complement which is formed by inverting the state of each bit and adding 1.
Pronunciation: "negate-a"

NEGB ( -- )

Compiles the opcode sequence for the NEGB instruction into the dictionary. When later executed, this code replaces the contents of accumulator B with its twos complement which is formed by inverting the state of each bit and adding 1.
Pronunciation: "negate-b"

NEVER ( -- condition )

Used within a code definition, leaves a condition flag on the data stack. Indicates a "never true" condition.

NOP ( -- )

Compiles the opcode sequence for the NOP instruction into the dictionary. When later executed, this code does nothing.
Pronunciation: "no-op"

ORAA ( arg\mode -- )

Compiles the opcode sequence for the ORAA instruction into the dictionary. When later executed, this code performs a logical OR operation between the contents of accumulator A and the contents of the operand specified by arg and mode. The result is stored in accumulator A.
Pronunciation: "or-accumulator-a"

ORAB ( arg\mode -- )

Compiles the opcode sequence for the ORAB instruction into the dictionary. When later executed, this code performs a logical OR operation between the contents of accumulator B and the contents of the operand specified by arg and mode. The result is stored in accumulator B.
Pronunciation: "or-accumulator-b"

PL ( -- condition )

Used within a code definition, leaves a condition flag on the data stack. Used after a comparison of the form P - Q = R, indicates the condition R ≥ 0 using signed math. Alternate interpretation: Condition is true if the N bit in the condition code register is clear.
Pronunciation: "plus"

PSHA ( -- )

Compiles the opcode sequence for the PSHA instruction into the dictionary. When later executed, this code stores the contents of accumulator A at the next available location on the return stack pointed to by the S register and decrements the S register.
Pronunciation: "push-a"

PSHB ( -- )

Compiles the opcode sequence for the PSHB instruction into the dictionary. When later executed, this code stores the contents of accumulator B at the next available location on the return stack pointed to by the S register and decrements the S register.
Pronunciation: "push-b"

PSHX ( -- )

Compiles the opcode sequence for the PSHX instruction into the dictionary. When later executed, this code stores the contents of index register X at the next available locations on the return stack pointed to by the S register and decrements the S register by 2.
Pronunciation: "push-x"

PSHY ( -- )

Compiles the opcode sequence for the PSHY instruction into the dictionary. When later executed, this code stores the contents of index register Y at the next available locations on the return stack pointed to by the S register and decrements the S register by 2.
Pronunciation: "push-y"

PULA ( -- )

Compiles the opcode sequence for the PULA instruction into the dictionary. When later executed, this code pops the top value off the return stack (pointed to by the S register) into accumulator A and increments the S register.
Pronunciation: "pull-a"

PULB ( -- )

Compiles the opcode sequence for the PULB instruction into the dictionary. When later executed, this code pops the top value off the return stack (pointed to by the S register) into accumulator B and increments the S register.
Pronunciation: "pull-b"

PULX ( -- )

Compiles the opcode sequence for the PULX instruction into the dictionary. When later executed, this code pops the top 2 bytes off the return stack (pointed to by the S register) into index register X and increments the S register by 2.
Pronunciation: "pull-x"

PULY ( -- )

Compiles the opcode sequence for the PULY instruction into the dictionary. When later executed, this code pops the top 2 bytes off the return stack (pointed to by the S register) into index register Y and increments the S register by 2.
Pronunciation: "pull-y"

REL ( -- mode )

Used within a code definition, leaves a constant on the stack indicating that the relative addressing mode should be used by an instruction opcode.
Pronunciation: "relative"

REPEAT, ( -- )

REPEAT, is used to designate the end of an assembly coded structure.

BEGIN,          . . . .
condition.flag WHILE,    . . . .
REPEAT, 

See also BEGIN, and WHILE,
Pronunciation: "repeat-comma"

ROL ( arg\mode -- )

Compiles the opcode sequence for the ROL instruction into the dictionary. When later executed, this code shifts the bits in the operand specified by arg and mode left by one bit. The C (carry) bit is shifted into the least significant bit of arg, and the most significant bit in arg is shifted into C.
Pronunciation: "rotate-left"

ROLA ( -- )

Compiles the opcode sequence for the ROLA instruction into the dictionary. When later executed, this code shifts the bits in accumulator A left by one bit. The C (carry) bit is shifted into the least significant bit of accumulator A, and the most significant bit in accumulator A is shifted into C.
Pronunciation: "rotate-left-a"

ROLB ( -- )

Compiles the opcode sequence for the ROLB instruction into the dictionary. When later executed, this code shifts the bits in accumulator B left by one bit. The C (carry) bit is shifted into the least significant bit of accumulator B, and the most significant bit in accumulator B is shifted into C.
Pronunciation: "rotate-left-b"

ROR ( arg\mode -- )

Compiles the opcode sequence for the ROR instruction into the dictionary. When later executed, this code shifts the bits in the operand specified by arg and mode right by one bit. The C (carry) bit is shifted into the most significant bit of arg, and the least significant bit in arg is shifted into C.
Pronunciation: "rotate-right"

RORA ( -- )

Compiles the opcode sequence for the RORA instruction into the dictionary. When later executed, this code shifts the bits in accumulator A right by one bit. The C (carry) bit is shifted into the most significant bit of accumulator A, and the least significant bit in accumulator A is shifted into C.
Pronunciation: "rotate-right-a"

RORB ( -- )

Compiles the opcode sequence for the RORB instruction into the dictionary. When later executed, this code shifts the bits in accumulator B right by one bit. The C (carry) bit is shifted into the most significant bit of accumulator B, and the least significant bit in accumulator B is shifted into C.
Pronunciation: "rotate-right-b"

RTI ( -- )

Compiles the opcode sequence for the RTI instruction into the dictionary. When later executed, this code restores accumulators A and B, and registers X, Y and PC with values pulled from the stack.
Pronunciation: "return-from-interrupt"

RTS ( -- )

Compiles the opcode sequence for the RTS instruction into the dictionary. When later executed, this code restores the program counter with a value pulled from the stack, thereby resuming execution just after the point where the subroutine was called.
Pronunciation: "return-from-subroutine"

SBA ( -- )

Compiles the opcode sequence for the SBA instruction into the dictionary. When later executed, this code subtracts the contents of accumulator B from accumulator A and stores the result in accumulator A. The contents of accumulator B are not affected.
Pronunciation: "subtract-b-from-a"

SBCA ( arg\mode -- )

Compiles the opcode sequence for the SBCA instruction into the dictionary. When later executed, this code subtracts the contents of the operand specified by arg and mode and the contents of C from accumulator A and stores the result in accumulator A.
Pronunciation: "subtract-with-carry-a"

SBCB ( arg\mode -- )

Compiles the opcode sequence for the SBCB instruction into the dictionary. When later executed, this code subtracts the contents of the operand specified by arg and mode and the contents of C from accumulator B and stores the result in accumulator B.
Pronunciation: "subtract-with-carry-b"

SEC ( -- )

Compiles the opcode sequence for the SEC instruction into the dictionary. When later executed, this code sets the C (carry) bit in the condition code register.
Pronunciation: "set-carry"

SEI ( -- )

Compiles the opcode sequence for the SEI instruction into the dictionary. When later executed, this code sets the I (global interrupt enable) bit in the condition code register. When the I bit is set, all maskable interrupts are disabled.
Pronunciation: "set-interrupt-mask"

SEV ( -- )

Compiles the opcode sequence for the SEV instruction into the dictionary. When later executed, this code sets the V (2's complement overflow) bit in the condition code register.
Pronunciation: "set-overflow-bit"

STAA ( arg\mode -- )

Compiles the opcode sequence for the STAA instruction into the dictionary. When later executed, this code stores the contents of accumulator A into the effective address specified by arg and mode.
Pronunciation: "store-accumulator-a"

STAB ( arg\mode -- )

Compiles the opcode sequence for the STAB instruction into the dictionary. When later executed, this code stores the contents of accumulator B into the effective address specified by arg and mode.
Pronunciation: "store-accumulator-b"

STD ( arg\mode -- )

Compiles the opcode sequence for the STD instruction into the dictionary. When later executed, this code stores the contents of accumulator D into the effective address specified by arg and mode.
Pronunciation: "store-d"

STOP ( -- )

Compiles the opcode sequence for the STOP instruction into the dictionary. When later executed, this code halts all system clocks and places the system in a minimum power consumption mode if the S bit in the CCR register is clear. If the S bit is set, STOP is disabled and acts like a NOP. Recovery is accomplished by a reset, or an active low signal on XIRQ, or a non-masked IRQ interrupt.

STS ( arg\mode -- )

Compiles the opcode sequence for the STS instruction into the dictionary. When later executed, this code stores the contents of the S register (which is the return stack pointer) at the effective address specified by arg and mode.
Pronunciation: "store-s"

STX ( arg\mode -- )

Compiles the opcode sequence for the STX instruction into the dictionary. When later executed, this code stores the contents of index register X at the effective address specified by arg and mode.
Pronunciation: "store-x"

STY ( arg\mode -- )

Compiles the opcode sequence for the STY instruction into the dictionary. When later executed, this code stores the contents of index register Y at the effective address specified by arg and mode.
Pronunciation: "store-y"

SUBA ( arg\mode -- )

Compiles the opcode sequence for the SUBA instruction into the dictionary. When later executed, this code subtracts the operand specified by arg and mode from the contents of accumulator A and places the result in accumulator A.
Pronunciation: "subtract-a"

SUBB ( arg\mode -- )

Compiles the opcode sequence for the SUBB instruction into the dictionary. When later executed, this code subtracts the operand specified by arg and mode from the contents of accumulator B and places the result in accumulator B.
Pronunciation: "subtract-b"

SUBD ( arg\mode -- )

Compiles the opcode sequence for the SUBD instruction into the dictionary. When later executed, this code subtracts the contents of the operand specified by arg and mode from the contents of accumulator D and places the result in accumulator D.
Pronunciation: "subtract-d"

SWI ( -- )

Compiles the opcode sequence for the SWI instruction into the dictionary. When later executed, this code invokes a software interrupt. It stores the CCR, accumulators A and B, and registers X, Y and PC on the stack. The stack pointer is decremented by 1 for each byte stored on the stack. The I bit in the CCR register is set. The PC register is then loaded with the address located at the interrupt vector for SWI, and instruction execution resumes at this location.
Pronunciation: "software interrupt"

TAB ( -- )

Compiles the opcode sequence for the TAB instruction into the dictionary. When later executed, this code transfers the contents of accumulator A to accumulator B.
Pronunciation: "transfer-a-to-b"

TAP ( -- )

Compiles the opcode sequence for the TAP instruction into the dictionary. When later executed, this code transfers the contents of accumulator A to the condition code register.
Pronunciation: "transfer-a-to-condition-code-register"

TBA ( -- )

Compiles the opcode sequence for the TBA instruction into the dictionary. When later executed, this code transfers the contents of accumulator B to accumulator A.
Pronunciation: "transfer-b-to-a"

TEST ( -- )

Compiles the opcode sequence for the TEST instruction into the dictionary. When later executed, this code causes the PC to be continuously incremented. This instruction can only be executed when the CPU is configured to operate in test mode. If executed in any mode other than test, the instruction is treated as an illegal opcode.

THEN, ( -- )

THEN, is used in assembly coded routines to mark the end of a conditional IF, structure. It is a synonym for ENDIF,.

See also ENDIF,
Pronunciation: "then-comma"

TPA ( -- )

Compiles the opcode sequence for the TPA instruction into the dictionary. When later executed, this code transfers the contents of the condition code register into accumulator A.
Pronunciation: "transfer-condition-code-register-to-a"

TST ( arg\mode -- )

Compiles the opcode sequence for the TST instruction into the dictionary. When later executed, this code subtracts zero from the contents of the operand specified by arg and mode and sets the condition code register's bits accordingly. The operand is unaffected by the subtraction.
Pronunciation: "test"

TSTA ( -- )

Compiles the opcode sequence for the TSTA instruction into the dictionary. When later executed, this code subtracts zero from the contents of accumulator A and sets the condition code register's bits accordingly. Accumulator A is unaffected.
Pronunciation: "test-a"

TSTB ( -- )

Compiles the opcode sequence for the TSTB instruction into the dictionary. When later executed, this code subtracts zero from the contents of accumulator B and sets the condition code register's bits accordingly. Accumulator B is unaffected.
Pronunciation: "test-b"

TSX ( -- )

Compiles the opcode sequence for the TSX instruction into the dictionary. When later executed, this code loads index register X with one plus the contents of the S register (which is the return stack pointer). After this operation the X register points to the top item on the return stack.
Pronunciation: "transfer-stack-to-x"

TSY ( -- )

Compiles the opcode sequence for the TSY instruction into the dictionary. When later executed, this code loads index register Y with one plus the contents of the S register (which is the return stack pointer). After this operation the Y register points to the top item on the return stack.
Pronunciation: "transfer-s-to-y"

TXS ( -- )

Compiles the opcode sequence for the TXS instruction into the dictionary. When later executed, this code loads the S register (which is the return stack pointer) with the contents of the index register X minus one.
Pronunciation: "transfer-x-to-s"

TYS ( -- )

Compiles the opcode sequence for the TYS instruction into the dictionary. When later executed, this code loads the S register (which is the return stack pointer) with the contents of the index register Y minus one.
Pronunciation: "transfer-y-to-s"

UNTIL, ( condition -- )

UNTIL, designates the end of an assembly coded looping structure and resolves branch instructions according to the specified condition. Use as:

BEGIN,       . . . code to be executed . . .
condition UNTIL, 

If the condition is true, the loop terminates and execution continues with the code following UNTIL,. If the condition is false, looping continues and execution passes to the code following BEGIN,.
Pronunciation: "until-comma"

VC ( -- condition )

Used within a code definition, leaves a condition flag on the data stack. The condition is true when the V (2's complement overflow) flag in the condition code register is 0.
Pronunciation: "overflow-clear"

VS ( -- condition )

Used within a code definition, leaves a condition flag on the data stack. The condition is true when the V (2's complement overflow) flag in the condition code register is 1.
Pronunciation: "overflow-set"

WAI ( -- )

Compiles the opcode sequence for the WAI instruction into the dictionary. When later executed, this code saves the condition code register, accumulators A and B, and register X, Y and PC on the stack. The stack pointer is decremented for each byte stored. The CPU the enters a lower power consumption mode, while waiting for an interrupt which has not been masked. When an interrupt is recognized, the CPU sets the I bit in the CCR, and execution resumes at the address stored in the appropriate interrupt vector.
Pronunciation: "wait-for-interrupt"

WHILE, ( condition -- )

WHILE, is used in assembly coded routines to mark the beginning of a the "while true" portion of a BEGIN, . . . WHILE, . . . REPEAT, loop. Use as:

BEGIN,       . . . .
condition WHILE,   . . . .
REPEAT, 

When executed, WHILE, causes a branch instruction to be compiled into the dictionary.

When the compiled code is executed, if the condition is true, the loop continues and the code between WHILE, and REPEAT, are executed, after which control is transferred to the code following BEGIN,. If the condition is false, the loop terminates and execution continues with the code following REPEAT,.
Pronunciation: "while-comma"

XGDX ( -- )

Compiles the opcode sequence for the XGDX instruction into the dictionary. When later executed, this code exchanges the contents of accumulator D with the contents of index register X.
Pronunciation: "exchange-d-and-x"

XGDY ( -- )

Compiles the opcode sequence for the XGDY instruction into the dictionary. When later executed, this code exchanges the contents of accumulator D with the contents of index register Y.
Pronunciation: "exchange-d-and-y"