Link here

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

>ASSM ( -- )

Consult the main glossary.

 
>FORTH

>FORTH ( -- )

Consult the main glossary.

 
ABA

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

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

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

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

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

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

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

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,

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

ALWAYS ( -- condition )

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

 
ANDA

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

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

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

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

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

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

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

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

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

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

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

ASSEMBLER ( -- )

Consult the main glossary.

 
BCC

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

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

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,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

CALL ( <name> -- )

Consult the main glossary.

 
CBA

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

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

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

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

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

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

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

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

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

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

CODE ( <name> -- )

Consult the main glossary.

 
COM

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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, ( -- )

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

END-CODE ( sys -- | balances CODE )

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

 
END.CODE

END.CODE ( sys -- | balances CODE )

Consult the main glossary.

 
ENDIF,

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

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

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

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

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

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

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

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

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

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

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,

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

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

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

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

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

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

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

INH ( -- )

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

 
INS

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

NEVER ( -- condition )

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

 
NOP

NOP ( -- )

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

 
ORAA

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

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

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

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

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

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

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

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

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

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

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

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, ( -- )

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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, ( -- )

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

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

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

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

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

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

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

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

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,

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

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

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

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,

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

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

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"

 
This page is about: Describes Words Used in Assembly Language Programming, within Forth Environment, Assembler Mode is Switched on Using ''CODE'' or ''>ASSM'' Keywords, Assembly Mode is Switched off Using ''END.CODE'' or ''>FORTH'' – Documents the assembly language programming primitives and functions available within the Forth environment
 
 
Navigation