please dont rip this site

Scenix XPL0 I2L

; *** DEBUG FREE NOPED TO FIT
;I2L.ASM	MAY-23-98	Version 0.91
;I2L.ASM	10-MAR-2000	Version 1.02	Richard Ottosen
;XPL0 Interpreter for the Scenix SX Microcontroller
;Copyright (C) 1998,1999,2000 Loren Blaney
;
;Assemble using MPASM.
;;This program executes the I2L code produced by the XPL6 compiler. This
; program is based on code written for the 6502 by: P.J.R. Boyle, Wayne Wall,
; Ted Dunning, Loren Blaney, Larry Fish and Richard Ottosen.
;
;See SXPL.DOC for details about what this program does and how it differs
; from other implementations of I2L.
;
;LICENSE:
;This program is free software; you can redistribute it and/or modify it under
; the terms of the GNU General Public License version 2 as published by the
; Free Software Foundation.
;This program is distributed in the hope that it will be useful, but WITHOUT
; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
; FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
; details.
;You should have received a copy of the GNU General Public License along with
; this program (in the file LICENSE.DOC); if not, write to the Free Software
; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
;
;You can reach me at:			Mail:	Loren Blaney
; Email: loren_blaney@idcomm.com		502 Pine Glade Dr.
;						Nederland, CO 80466, USA
;
;REVISIONS:
;1.0, MAY-09-98, Released.
;1.01, 22-FEB-2000, Changed the routine name "SWAP" to be "SWAPB" to prevent
;  conflicts with SX-Key assembler and removed references to pseudo-ops for
;  SXSIM.  R.O.
;1.02, 10-MAR-2000, Selected internal oscillator and enabled the watchdog
;  timer. Added CLRWDT to SOUND intrinsic and at OPGO label. Assigned
;  prescaler set to maximum time to watchdog.  R.O.

;
;
;CODING CONVENTIONS:
;Bank 0 is normally selected. This enables access to locations 00-1Fh.
;FSR is not set aside as the stack pointer (unlike in the 14-bit version);
; I2LSP is. I2LSP's bit 4 is undefined until it's used in PUSH or PULL.
;The least significant byte of a multi-byte value is at the lowest address
; (i.e. low byte first), except for the stack where the order is reversed.
;The MODE register is not assumed to be set to 0Fh.
;Location 01 is not assumed to be RTCC or W. The OPTION intrinsic can set
; it either way.
;
;Because of fragmented RAM a distinction is made between logical addresses
; and physical addresses. Logical addresses are continuous and range from
; 00 to 7Fh. Logical addresses 0-Fh correspond to physical addresses 10-1Fh.
; Bit 4 in the physical address is always set. Note that the I/O ports
; (RA, RB, RC) are not mapped into logical addresses. The intrinsics Pout
; and Pin are used to access them. All addresses are logical unless noted
; as physical addresses.
;

;***	PROCESSOR 16C57		;closest PIC chip
	RADIX	DEC
	ERRORLEVEL -302, -305	;bank args are in range; ",F" is the default
	LIST	ST=OFF		;we don't need no stinking symbol table

	INCLUDE	"SXDEFS.INC"	;macro definitions for new instructions, etc.
	ID	'X','P','L','0',' ',' ',' ',' '
;***DEVICE	EQU	PINS18+OSCRC+PAGES4+BANKS8+TURBO+SYNC+STACKX+OPTIONX+BOR40+WATCHDOG
DEVICE	EQU	PINS18+OSC4MHZ+PAGES4+BANKS8+TURBO+SYNC+STACKX+OPTIONX+WATCHDOG+BOR40


;Miscellaneous ASCII control codes:
Bel	EQU	07h		;bell
LF	EQU	0Ah		;line feed
FF	EQU	0Ch		;form feed
CR	EQU	0Dh		;carriage return
EOF	EQU	1Ah		;end of file
Esc	EQU	1Bh		;escape
Sp	EQU	20h		;space

;===============================================================================
;                              START OF RAM
;===============================================================================

	ORG	08h
TEMP	RES	1		;very temporary scratch location
RegA	RES	2		;16-bit scratch "register"
RegX	RES	1		;8-bit scratch "register"
I2LPC	RES	2		;interpreter's program counter
LOCDISP	RES	1		;base address of local variables

	ORG	0Fh
DISPLY	RES	3		;display vector table: holds base addresses of
DISPLY2	EQU	DISPLY*2	; heap variables, one for each (static) level

LEVEL	RES	1		;current (static) level (0..2)
HP	RES	1		;heap pointer, base of unused variable space
I2LSP	RES	1		;interpreter's stack pointer (physical address)

REMAIN	RES	2		;remainder from integer divide
RERUNF	RES	1		;rerun flag; set by RESTART intrinsic, etc.

ERRNO	RES	1		;I2L error number
TRAPS	RES	2		;16 flags to enable trapping specific I2L errors

NOWDEV	EQU	TEMP		;current I/O device number (always 0)

RegB	RES	2		;16-bit scratch "registers" used by various
RegC	RES	2		; routines such as MUL, DIV and DOERROR

FLAGS	RES	1		;eight scratch flag bits

	ORG	30h
HEAPLO	EQU	(($>>1) & 70h) | ($ & 0fh)	;use a logical address instead
				; of a physical one to cope with fragmented RAM
;The first two bytes in the heap are used to return integers from functions
	RES	2
SEED	RES	3		;random number seed (in unused heap space)

STACK	EQU	0FFh		;stack (PUSH =   MOVWF IND   DECF FSR)

;===============================================================================
	ORG	0		;START OF ROM
;===============================================================================
;GOTO and CALL extenders
;
ISR	FGOTO	ISRX		;interrupt vector at location 0
RESET	FGOTO	RESETX
DOERROR	FGOTO	DOERRORX
FETCHA	FGOTO	FETCHAX

;-------------------------------------------------------------------------------
;Routine to quickly load global and local variables onto the stack. Since this
; is the most common I2L instruction, it is optimized. This is a single-byte
; instruction with the high bit set. The other 7 bits are the offset. Globals
; are indicated by odd offsets, and locals by even offsets.
;
FASTLOD	BCF	RegX,7		;clear high bit of opcode to get the offset
	MOVF	LOCDISP,W	;get base address of local variables
	BTFSC	RegX,0		;skip if offset is even (it's a local variable)
	 MOVF	DISPLY,W	; else get base address of global variables
	ADDWF	RegX,W		;add offset to get (logical) address in heap
OPGOLOD	CALL	GETVAR		;f variable from heap and put it into RegA
OPGOPA	MOVF	RegA,W		;push RegA, low byte first
OPGOPAW	CALL	PUSH
	MOVF	RegA+1,W	;push RegA high byte
OPGOPW	CALL	PUSH		;fall into dispatch loop...

;===============================================================================
;			    MAIN DISPATCH LOOP
;===============================================================================
;
OPGO	CLRWDT			;***???  R.O.
	CALL	FETCH		;f opcode at I2LPC and increment I2LPC
	MOVWF	RegX		;save copy of opcode in RegX
	BTFSC	RegX,7		;skip if MSB (bit 7) is clear
	 GOTO	FASTLOD		; else go handle fast global or local load
	BTFSC	RegX,6		;skip if bit 6 is clear
	 GOTO	SSIMOP		; else go handle short, short immediate load
	ADDWF	PC		;jump to routine that handles this opcode

;Opcode Jump Table:		Opcode / No. of Bytes / Description
	GOTO	EXTOP		;$00,1, Display error message then go to START
	GOTO	LODOP		;$01,3, Load a variable onto stack
	GOTO	LDXOP		;$02,3, Indexed load a byte variable
	GOTO	STOOP		;$03,3, Store into a variable
	GOTO	STXOP		;$04,3, Indexed store into a byte
	GOTO	CALOP		;$05,4, Call a procedure
	GOTO	RETOP		;$06,1, Return from procedure
	GOTO	JMPOP		;$07,3, Jump
	GOTO	JPCOP		;$08,3, Jump if top-of-stack (TOS) is false (=0)
	GOTO	HPIOP		;$09,2, Increase heap pointer (HP) by argument
	GOTO	ARGOP		;$0A,2, Move arguments from stack to heap
	GOTO	IMMOP		;$0B,3, Load 16-bit immediate value
	GOTO	CMLOP		;$0C,2, Call an intrinsic ('code') routine
	GOTO	ADDOP		;$0D,1, Add
	GOTO	SUBOP		;$0E,1, Subtract
	GOTO	MULOP		;$0F,1, Multiply
	GOTO	DIVOP		;$10,1, Divide
	GOTO	NEGOP		;$11,1, Negate (2's complement)
	GOTO	EQOP		;$12,1, Test for =
	GOTO	NEOP		;$13,1, Test for #
	GOTO	GEOP		;$14,1, Test for >=
	GOTO	GTOP		;$15,1, Test for >
	GOTO	LEOP		;$16,1, Test for <=
	GOTO	LTOP		;$17,1, Test for <
	GOTO	FOROP		;$18,3, 'for' loop control
	GOTO	INCOP		;$19,5, Increment, push & jump ('for' loop)
	GOTO	OROP		;$1A,1, Or
	GOTO	ANDOP		;$1B,1, And
	GOTO	NOTOP		;$1C,1, Not (1's complement)
	GOTO	XOROP		;$1D,1, Exclusive or
	GOTO	DBAOP		;$1E,1, TOS:= NOS + TOS*2 (for arrays)
	GOTO	STDOP		;$1F,1, Store TOS at address in NOS
	GOTO	DBXOP		;$20,1, Load(TOS*2 + NOS)
	GOTO	ADROP		;$21,3, Load address of a variable
	GOTO	LDX2OP		;$22,2, Indexed load global or local byte
	GOTO	BRAOP		;$23,2, Branch to I2L code
	GOTO	SIMOP		;$24,2, Load short (8-bit) immediate value
	GOTO	CJPOP		;$25,3, Case jump
	GOTO	JSROP		;$26,3, Optimized procedure call
	GOTO	RTSOP		;$27,1, Optimized procedure return

;To save space the following code replaces external call and floating point ops
;-------------------------------------------------------------------------------
;$28
;Routine to pull TOS and discard it. This is used to clean up the stack in
; unusual situations such as a 'return' inside a 'for' loop.
;
DRPOP	CALL	PULLA		;$28,1, Discard TOS
	GOTO	OPGO		;($29)

;-------------------------------------------------------------------------------
;Pull into RegB and add it to RegA
;
PBDADD	CALL	PULLB		;($2A)
				;fall into DADD...
;-------------------------------------------------------------------------------
;RegA:= RegA + RegB.
;
DADD	MOVF	RegB,W		;($2B) add low bytes
	ADDWF	RegA		;($2C)
	MOVF	RegB+1,W	;($2D) get ready to add high bytes
	BTFSC	STATUS,C	;($2E) skip if there was no carry into high byte
	 INCFSZ	RegB+1,W	;($2F)  else add in carry; if zero then high byte
	 ADDWF	RegA+1		;($30)  doesn't change and carry is still set
	RETP			;($31)  i.e. carry is correct

;-------------------------------------------------------------------------------
;Compare RegA to RegB by subtracting (RegB+$8000) from (RegA+$8000). The $8000
; offset allows an unsigned compare to be used. If the carry flag is set then
; RegA is >= RegB. This works for the entire range of values so, for example,
; -30000 is correctly determined to be smaller than +30000. RegA and RegB are
; changed.
;
DCMP	MOVLW	80h		;($32) add $8000 to avoid discontinuity between
	XORWF	RegA+1		;($33)  -1 and 0
	XORWF	RegB+1		;($34) fall into DSUB...

;-------------------------------------------------------------------------------
;RegA:= RegA - RegB (with correct carry). Returns with RegB+1 in W.
;
DSUB	MOVF	RegB,W		;($35) subtract low bytes
	SUBWF	RegA		;($36)
	MOVF	RegB+1,W	;($37) get ready to subtract high bytes
	BTFSS	STATUS,C	;($38) skip if there's no borrow from high byte
	 INCFSZ	RegB+1,W	;($39)  else increase amount to subtract by 1
	 SUBWF	RegA+1		;($3A)  if it's 0 then high byte doesn't change,
	RETP			;($3B)  nor does carry

;-------------------------------------------------------------------------------
;(Resume Opcode Jump Table)

	GOTO	STO2OP		;$3C,2, Store into global or local variable
	GOTO	STX2OP		;$3D,2, Indexed store into global or local

;-------------------------------------------------------------------------------
;$3E
;Shift left. TOS:= NOS << TOS
; Only the low byte of the shift count is used. It should normally be < 16.
;
LSLOP	NOP			;$3E,1, Shift left (the NOP is necessary)
				; fall into LSROP...
;-------------------------------------------------------------------------------
;$3F
;Shift right. TOS:= NOS >> TOS
;
LSROP	CALL	PULLB		;$3F,1; TOS into RegB, low byte of RegB is in W
	BTFSC	STATUS,Z	; and the status is set accordingly
	 GOTO	OPGO		;branch if shifting zero places
	CALL	PULLA		;NOS into RegA

LSR20	BCF	STATUS,C	;clear carry bit for shifting
	BTFSS	RegX,0		;skip if odd numbered opcode (LSROP)
	 GOTO	LSR30		; else branch to shift left
	RRF	RegA+1		;shift right  -->
	RRF	RegA
	GOTO	LSR40
LSR30	RLF	RegA		;shift left  <--
	RLF	RegA+1
LSR40	DECFSZ	RegB		;loop for the number of places in RegB (=TOS)
	 GOTO	LSR20
	GOTO	OPGOPA		;go push RegA

;===============================================================================
;				  SUBROUTINES
;===============================================================================
;Return the heap address of a variable. This fetches an instruction's level and
; offset and returns the corresponding heap address in W.
;
HEAPADR	CALL	FETCH		;fetch level (times 2)
	MOVWF	FSR
	MOVLW	DISPLY2		;add base of display vector table (times 2)
	ADDWF	FSR
	RRF	FSR		;undo times 2 (carry is clear because of ADDWF)
	CALL	FETCH		;get offset (does not change FSR)
	ADDWF	IND,W		;add it to base address from table to get addr
	RETP			; in heap

;-------------------------------------------------------------------------------
;Return the heap address of a local or global variable. This fetches an
; instruction's offset and returns the corresponding heap address in W.
; Bank 0 is no longer selected.
;
HEAPADRX CALL	FETCH		;fetch offset
	MOVWF	FSR		;BANK 0 IS NO LONGER SELECTED
	MOVF	LOCDISP,W	;get base address for local level
	BTFSC	FSR,0		;skip if offset is even (it's a local variable)
	 MOVF	DISPLY,W	; else get base address of global variables
	ADDWF	FSR,W		;add offset to get heap address
	RETP

;-------------------------------------------------------------------------------
;Convert the logical address in W into a physical address in FSR (to cope with
; fragmented RAM). Bank 0 is no longer selected.
;
LOGPHYS MOVWF	FSR		;BANK 0 IS NO LONGER SELECTED
	ANDLW	0F0h		;shift the high nibble left
	ADDWF	FSR		;(bit 4 will be set later)
	BSF	FSR,4		;make sure FSR is pointing to high half of bank
	RETP

;-------------------------------------------------------------------------------
;Get the variable pointed to by W and put it into RegA.
;
GETVAR	CALL	LOGPHYS		;convert logical address to physical address
	MOVF	IND,W		;fetch low byte
	MOVWF	RegA

	INCF	FSR
	BSF	FSR,4		;make sure FSR is pointing to high half of bank
	MOVF	IND,W		;fetch high byte
	MOVWF	RegA+1
	GOTO	PULL90		;restore access to bank 0 and return

;-------------------------------------------------------------------------------
;Fetch the I2L code byte pointed to by I2LPC and then bump I2LPC. (I2LPC++) -> W
; FSR is not changed.
;
FETCH	BTFSC	I2LPC+1,3	;skip if fetching from below address 800h
	 GOTO	FET50		; else go fetch two nibbles
	MOVF	I2LPC+1,W	;fetch byte at I2LPC
	MOVWM
	MOVF	I2LPC,W
	IREAD			;return byte in W

	INCFSZ	I2LPC		;increment interpreter's program counter
	 RETP			;most of the time it returns from here
	INCF	I2LPC+1		;increment high byte
	BTFSS	I2LPC+1,3	;skip if 800h--ignore reset vector at 7FFh
	 RETP			; return

	DECF	I2LPC		;convert 800h back to 7FFh
	DECF	I2LPC+1

;When fetching at or above address 7FFh, the location to actually fetch from is:
; = (I2LPC - 7FFh)*2 + PROGLO
; = (I2LPC - (800h-1))*2 + PROGLO
; = 2*I2LPC - 1000h + 2 + PROGLO   Since 1000h is over the top, it has no effect
; = 2*I2LPC + PROGLO + 2
FET50	RLF	I2LPC,W		;RegB:= 2*I2LPC
	MOVWF	RegB
	RLF	I2LPC+1,W
	FCALL	FETCOM
	INCFSZ	I2LPC		;increment interpreter's program counter
	 RETP			; most of the time it returns from here
	INCF	I2LPC+1		;increment high byte
	RETP			;return

;-------------------------------------------------------------------------------
;Check for memory overflow. If HP > I2LSP then I2L error # 2: Out of memory.
;
CHKMEM	MOVF	HP,W		;convert logical address in HP to physical
	ANDLW	0F0h		; address in W, except that bit 4 is clear
	ADDWF	HP,W

	BCF	I2LSP,4		;compare to similar physical address in I2LSP
	SUBWF	I2LSP,W		;I2LSP - HP
	MOVLW	2		;error 2
	BTFSS	STATUS,C	;skip if no overflow
	 GOTO	DOERROR		; else flag error and return
	RETP			;return with no error

;-------------------------------------------------------------------------------
;Move arguments from stack to heap. The number of bytes of arguments to move is
; in the W register. The location in the heap is pointed to by the heap pointer
; (HP). RegX, and RegA are changed.
;
;Example showing how 2 arguments (4 bytes) are passed. FROG(NOS, TOS);
;
;      Initial	   STACK	   --->		    HEAP
;      I2LSP -->|          |			|          |
;		+----------+			+----------+
;	      1	| TOS high |		  HP -->| NOS low  |
;		+----------+			+----------+
;	      2	| TOS low  |			| NOS high |
;		+----------+			+----------+
;	      3	| NOS high |			| TOS low  |
;		+----------+			+----------+
;	      4	| NOS low  |<-- Final I2LSP	| TOS high |
;		+----------+			+----------+
;							    <-- Initial RegA
;
MOVARGS	MOVWF	RegX		;save byte count
	ADDWF	HP,W		;add base address (HP) to get pointer into heap
	MOVWF	RegA		;save this pointer

MOV10	CALL	PULL		;pull TOS byte from stack
	MOVWF	RegA+1		;save it temporarily in high byte of RegA

	DECF	RegA		;decrement pointer to heap
	MOVF	RegA,W
	CALL	LOGPHYS		;convert logical address to physical address

	MOVF	RegA+1,W	;store TOS byte into heap
	MOVWF	IND
	BANKX	0		;restore access to bank 0 (PULL needs it)

	DECFSZ	RegX		;loop for the specified number of bytes
	 GOTO	MOV10
	RETP

;-------------------------------------------------------------------------------
;Pull the 16-bit value in TOS into RegA. Returns with copy of RegA in W.
;
PULLA	CALL	PULL		;high byte
	MOVWF	RegA+1
	CALL	PULL		;low byte
	MOVWF	RegA
	RETP

;-------------------------------------------------------------------------------
;Pull the 16-bit value in TOS into RegB. Returns with copy of RegB in W.
;
PULLB	CALL	PULL		;high byte
	MOVWF	RegB+1
	CALL	PULL		;low byte
	MOVWF	RegB
	RETP

;-------------------------------------------------------------------------------
;Pull the 16-bit value in TOS into RegC. Returns with copy of RegC in W.
;
PULLC	CALL	PULL		;high byte
	MOVWF	RegC+1
	CALL	PULL		;low byte
	MOVWF	RegC
	RETP

;-------------------------------------------------------------------------------
;Pull the 16-bit value in TOS into I2LPC. Returns with copy of I2LPC in W.
;
PULLPC	CALL	PULL		;high byte
	MOVWF	I2LPC+1
	CALL	PULL		;low byte
	MOVWF	I2LPC
	RETP

;-------------------------------------------------------------------------------
;Pull a byte from the stack and return it in W with its correct Z status.
;
PULL	INCF	I2LSP		;increment stack pointer
	BSF	I2LSP,4		;make sure it's in the high half of the bank
	MOVF	I2LSP,W		;set FSR as the stack pointer
	MOVWF	FSR
	MOVF	IND,W		;get byte from stack and set Z status
PULL90	BANKX	0		;restore access to bank 0
	RETP

;-------------------------------------------------------------------------------
;Push byte in W onto the stack (without changing W or carry).
;
PUSH	MOVWF	TEMP		;save W
	BSF	I2LSP,4		;make sure it's in the high half of the bank
	MOVF	I2LSP,W		;get stack pointer
	MOVWF	FSR
	MOVF	TEMP,W		;store W onto stack
	MOVWF	IND
	BANKX	0		;restore access to bank 0
REPUSH	BCF	I2LSP,4		;force low half of bank
	DECF	I2LSP		;decrement stack pointer
	RETP			; (I2LSP is forced to high half of bank later)

;-------------------------------------------------------------------------------
;Subroutine to set up arguments for divide opcode
;
DIV100	CALL	PULLA		;TOS -> RegA
	MOVF	RegA+1,W	;get sign bit and
	XORWF	FLAGS		;toggle sign flag if its negative
				;fall into ABSA...
;-------------------------------------------------------------------------------
;Return the absolute value of RegA.
;
ABSA	BTFSS	RegA+1,7	;skip if negative and fall into NEGA...
	 RETP			; else return with positive value

;-------------------------------------------------------------------------------
;Negate RegA (two's complement).
;
NEGA	COMF	RegA
	COMF	RegA+1
				;fall into INCA...
;-------------------------------------------------------------------------------
;Increment RegA (without altering W).
;
INCA	INCFSZ	RegA
	 RETP
	INCF	RegA+1
	RETP

;===============================================================================
;		      ROUTINES TO EXECUTE I2L INSTRUCTIONS
;===============================================================================
;$00
;Exit routine. One-byte instruction. Since in this ROM-based environment there
; is nothing to exit back to (such as an operating system), this is an error.
;
EXTOP	FGOTO	ERREXIT

;-------------------------------------------------------------------------------
;$01
;Routine to fetch a 16-bit variable's value from the heap and push it onto the
; stack. This instruction is usually replaced by the fast global or local load
; (FASTLOD), but when the variable's level is neither global or local (when it's
; intermediate), this routine is used instead. This is a three-byte instruction:
;	1. The opcode ($01).
;	2. The level in the display vector table for the base address (times 2).
;	3. The offset from that base address to the variable.
;
LODOP	CALL	HEAPADR		;fetch level & offset and point W to heap addr
	GOTO	OPGOLOD		;go get variable from heap and push it on stack

;-------------------------------------------------------------------------------
;$02
;Routine to push an 8-bit byte onto the stack. This opcode contains the level
; and offset of a variable that points to the base of a character (byte) array.
; An index, which is on the stack, is added to this base address to get the
; address of the byte to push. The byte is pushed as a 16-bit value with its
; high byte zeroed. Three-byte instruction: opcode, level, and offset.
;
LDXOP	CALL	HEAPADR		;fetch level & offset and point W to heap addr
LDXOPX	CALL	GETVAR		;get array base address from heap into RegA
	CALL	PBDADD		;pull index and add it to base of array
	CALL	FETCHA		;fetch (into W) the byte pointed to by RegA
LDXPA	CLRF	RegA+1		;zero the high byte
	GOTO	OPGOPAW		;go push W & RegA+1 onto the stack

;-------------------------------------------------------------------------------
;$22
;Compact form of LDX instruction. Used when the variable is global or local.
; Two-byte instruction: opcode, offset.
;
LDX2OP	CALL	HEAPADRX	;get heap address for local or global into W
	GOTO	LDXOPX		;go to common code for LDX instruction

;-------------------------------------------------------------------------------
;$03
;Routine to store top-of-stack (TOS) into a variable.
; Three-byte instruction: opcode, level, and offset.
;
STOOP	CALL	PULLA		;TOS -> RegA
	CALL	HEAPADR		;fetch level & offset and point W to heap addr

;Store RegA into heap location pointed to by W
STOOPX	CALL	LOGPHYS		;convert logical address into physical address
	MOVF	RegA,W		;get low byte of TOS
	MOVWF	IND		;store it into heap
	INCF	FSR
	MOVF	RegA+1,W	;get high byte
	BSF	FSR,4		;make sure FSR is pointing to high half of bank
STOOPY	MOVWF	IND		;store it too
	BANKX	0		;restore access to bank 0
	GOTO	OPGO		;go process next instruction

;-------------------------------------------------------------------------------
;$3C
;Compact form of STO instruction. Used when the variable is global or local.
; Two-byte instruction: opcode, offset.
;
STO2OP	CALL	PULLA		;TOS -> RegA
	CALL	HEAPADRX	;get heap address for local or global into W
	GOTO	STOOPX		;go do common code for STO instruction

;-------------------------------------------------------------------------------
;$04
;Routine to store the value on the stack into an indexed array element. Similar
; to LDX except that the value to store is pushed on the stack after the index
; (i.e: index=NOS, value=TOS). The high byte of the value is ignored and the low
; byte is stored into the heap. Three-byte instruction: opcode, level, offset.
;
STXOP	CALL	HEAPADR		;fetch level & offset and point W to heap addr
STXOPX	CALL	GETVAR		;copy base address of array from heap into RegA

	INCF	I2LSP		;discard high byte
	CALL	PULL		;pull byte to store into array
	MOVWF	RegX		; and save it for now in RegX
	CALL	PBDADD		;pull index and add it to base of array in RegA

	MOVLW	15		;make sure high byte is clear, else flag
	MOVF	RegA+1		; I2L error # 15: Attempt to store into ROM
	BTFSS	STATUS,Z
	 CALL	DOERROR

	MOVF	RegA,W		;point FSR to RAM address
	CALL	LOGPHYS		;convert logical address to physical address
	MOVF	RegX,W		;get byte that is to be stored into the array
	GOTO	STOOPY		;go store it and return to OPGO

;-------------------------------------------------------------------------------
;$3D
;Compact form of STX instruction. Used when variable is global or local.
; Two-byte instruction: opcode, offset.
;
STX2OP	CALL	HEAPADRX	;get heap address for local or global into W
	GOTO	STXOPX		;go do common code for STX instruction

;-------------------------------------------------------------------------------
;$05
;Routine to call a procedure.
; The instruction consists of 4 bytes:
;	1. The opcode.
;	2. The (new) level of the procedure being called (high 3 bits) and the
;	   number of bytes of arguments to be passed (low 5 bits) (see ARGOP).
;	3. The procedure entry address (low byte).
;	4. The procedure entry address (high byte).
;
; After a procedure call, the stack contains:
;	1. Return address (high byte, low byte).
;	2. Base address of variables (in heap) for the called procedure
;	   (i.e. value in display vector table at the new level).
;	3. Level of procedure we are calling from.
;
;The entry in the display vector table at the new level is set to the value in
; the heap pointer (HP). This is the base address of any local variables in the
; called procedure.
;
CALOP	CALL	FETCH		;get level and number of arguments
	MOVWF	RegC		;save copy for later
	ANDLW	1Fh		;get the number of arguments
	BTFSS	STATUS,Z	;skip if no arguments
	 CALL	MOVARGS		; else move W bytes of args from stack to heap

	MOVF	LEVEL,W		;push level we are calling from
	CALL	PUSH

;Push the value in the display vector table at the new level
	SWAPF	RegC		;move the level in the high 3 bytes down
	RRF	RegC,W
	ANDLW	07h
	MOVWF	LEVEL		;set the level for the called procedure

	MOVLW	DISPLY		;index into display vector table
	ADDWF	LEVEL,W
	MOVWF	FSR		;(bank 0 is still selected)
	MOVF	IND,W		;get the base address for the called level
	MOVWF	RegC		;temporarily save base address in RegC

	MOVF	HP,W		;change this entry in the display vector table
	MOVWF	IND		; to the current heap pointer
	MOVWF	LOCDISP		;also save a copy for accessing local variables

	MOVF	RegC,W		;push base address for the called level
	CALL	PUSH		;fall into JSROP...

;-------------------------------------------------------------------------------
;$26
;Optimized procedure call. Used only if no local variables are present. Since
; the scope is unchanged, this is equivalent to a machine language call. This
; instruction is also used to load the address of a string and then jump over
; the string. Three-byte instruction: opcode, low byte of called address, high
; byte of called address.
;
JSROP	MOVLW	2		;push return address (=I2LPC+2)
	ADDWF	I2LPC,W
	CALL	PUSH		;push low byte (and don't disturb carry)
	CLRF	TEMP		;shift carry into W
	RLF	TEMP,W
	ADDWF	I2LPC+1,W	;add high byte
	CALL	PUSH		;push resulting high byte
	GOTO	JMPOP		;go do jump to procedure then return to OPGO

;-------------------------------------------------------------------------------
;$27
;Optimized procedure return, to match the above call. Pulls the return address
; and puts it into I2LPC. Single-byte instruction.
;
RTSOP	CALL	PULLPC		;pull return address into I2LPC
	GOTO	OPGO

;-------------------------------------------------------------------------------
;$06
;Routine to return from a procedure. This pops the stuff pushed by CALOP.
; Single-byte instruction.
;
RETOP	MOVF	LOCDISP,W	;restore heap pointer to its location before
	MOVWF	HP		; the call

	CALL	PULLPC		;pull return address into I2LPC

	CALL	PULL		;pull base address of variables we're ret from
	MOVWF	RegA		;save it temporarily in RegA

	CALL	PULL		;pull level for procedure we are returning to
	MOVWF	RegX		;save it temporarily in RegX

;Restore base address entry in display table for level we are returning from
	MOVLW	DISPLY		;index into display vector table for current
	ADDWF	LEVEL,W		; level
	MOVWF	FSR		;(bank 0 is still selected)
	MOVF	RegA,W		;restore base address
	MOVWF	IND

	MOVF	RegX,W		;set LEVEL to the level we are returning to
	MOVWF	LEVEL
	MOVLW	DISPLY		;get base address of variables for this level
	ADDWF	LEVEL,W
	MOVWF	FSR		;(bank 0 is still selected)
	MOVF	IND,W
	MOVWF	LOCDISP		;set pointer for locals we're returning to
	GOTO	OPGO

;-------------------------------------------------------------------------------
;$08
;The two jump instructions are each three bytes long:
;	Opcode.
;	Low order of target address.
;	High order of target address.
;
;Conditional jump routine. This routine jumps on false, not on true. Note that
; false is zero, and non-zero is true. The result of the last boolean expression
; (typically a compare) is on the stack. Note that the entry point is at JPCOP.
;
JPCOPX	MOVLW	2		;move past address to jump to. i.e. don't jump
	ADDWF	I2LPC		;skip two bytes of I2L code
	BTFSC	STATUS,C
	 INCF	I2LPC+1
	GOTO	OPGO

JPCOP	CALL	PULLA		;pull bytes
	IORWF	RegA+1,W	;combine high and low bytes
	BTFSS	STATUS,Z	;skip if false (zero) and fall into JMPOP...
	 GOTO	JPCOPX		; else TOS was true so go move past jump address

;-------------------------------------------------------------------------------
;$07
;Jump instruction.
;
JMPOP	CALL	FETCH		;get low byte of address to jump to
	MOVWF	RegX		;save it temporarily in X
	CALL	FETCH		;get high byte (pointed to by I2LPC)
	MOVWF	I2LPC+1		;now update I2L's PC
	MOVF	RegX,W
	MOVWF	I2LPC
	GOTO	OPGO

;-------------------------------------------------------------------------------
;$09
;Routine to increase the heap pointer. This is used to reserve heap space for
; local variables. Two-byte instruction: opcode, number of bytes to reserve.
;
HPIOP	CALL	FETCH		;add the amount to reserve onto HP
	ADDWF	HP
	CALL	CHKMEM		;check for memory overflow (HP > I2LSP)
	GOTO	OPGO

;-------------------------------------------------------------------------------
;$0A
;Routine to move procedure arguments from the stack to the heap. The called
; procedure will then reserve the space with an HPIOP, and the local variables
; thus created will be preset to their appropriate values. Two-byte instruction:
; opcode, number of bytes of arguments.
;
ARGOP	CALL	FETCH		;get number of bytes of arguments
	CALL	MOVARGS		;move W bytes of arguments from stack to heap
	GOTO	OPGO

;-------------------------------------------------------------------------------
;$0B
;Load a 16-bit constant onto the stack. Three-byte instruction: Opcode, low
; byte of constant, high byte of constant.
; TOS:= immediate value.
;
IMMOP	CALL	FETCH		;get low byte of constant
	MOVWF	RegA
	CALL	FETCH		;get high byte
	MOVWF	RegA+1
	GOTO	OPGOPA		;go push RegA

;===============================================================================
;			     ARITHMETIC OPERATIONS
;===============================================================================
;
;These routines operate on the two items on the top-of-stack (TOS and NOS) and
; return the result in TOS (which replaces NOS). They are all single-byte
; instructions. Items are on the stack as shown. Note that the low byte is
; pushed first. Addresses increase downward.
;
;	       Initial I2LSP -->|          |
;				+----------+
;			      1	| TOS high |
;				+----------+
;			      2	| TOS low  |<-- I2LSP when finished
;				+----------+
;			      3	| NOS high |
;				+----------+
;			      4	| NOS low  |
;				+----------+
;
;-------------------------------------------------------------------------------
;$0D
;Add. TOS:= NOS + TOS. Single-byte instruction.
;
ADDOP	CALL	PULLA		;get TOS into RegA
ADDOPX	CALL	PBDADD		;get NOS into RegB and RegA:= RegA + RegB
	GOTO	OPGOPA		;go push RegA

;-------------------------------------------------------------------------------
;$0E
;Subtract. TOS:= NOS - TOS. Single-byte instruction.
;
SUBOP	CALL	PULLB		;get TOS into RegB
	CALL	PULLA		;get NOS into RegA
	CALL	DSUB		;RegA:= RegA - RegB
	GOTO	OPGOPA		;go push RegA

;-------------------------------------------------------------------------------
;$0F
;16-bit signed multiply. TOS:= NOS * TOS. Single-byte instruction. This uses an
; early-out algorithm.
;
;	<-- RegB      RegC -->
;         + RegA -->
;
MULOP	CALL	PULLC		;get TOS (multiplier) into RegC
	CALL	PULLB		;get NOS (multiplicand) into RegB
	CLRF	RegA		;clear product register
	CLRF	RegA+1
	GOTO	MUL30

MUL10	CALL	DADD		;RegA:= RegA + RegB
	BCF	STATUS,C
MUL20	RLF	RegB		;shift multiplicand left   <-- B
	RLF	RegB+1

MUL30	BCF	STATUS,C	;clear carry (don't shift in garbage)
	RRF	RegC+1		;shift least significant bit of multiplier
	RRF	RegC		; into carry
	BTFSC	STATUS,C	;skip if bit was a 0
	 GOTO	MUL10		; else it was a 1--go add B to A

	MOVF	RegC,W		;are there any more 1 bits in C?
	IORWF	RegC+1,W
	BTFSS	STATUS,Z	;skip if not--all done
	 GOTO	MUL20		; else loop back skipping add (carry is clear)
	GOTO	OPGOPA		;go return and push product onto the stack

;-------------------------------------------------------------------------------
;$10
;16-bit signed divide. TOS:= NOS / TOS. Single-byte instruction.
;
DIVOP	CLRF	FLAGS		;bit 7 is used to determine sign of quotient
	CALL	DIV100		;get TOS and handle sign
	FCALL	DMOVAB		;copy RegA to RegB

	IORWF	RegB,W		;check for divide by 0
	MOVLW	1		;flag I2L error 1
	BTFSC	STATUS,Z	;skip if no error
	 CALL	DOERROR

	CALL	DIV100		;get NOS and handle sign
	FCALL	DIV		;RegA:= RegA / RegB.
	BTFSC	FLAGS,7		;skip if quotient should be positive
DIV90	 CALL	NEGA		; otherwise make it negative
	GOTO	OPGOPA		;go push RegA

;-------------------------------------------------------------------------------
;$11
;Negate. TOS:= -TOS. Single-byte instruction.
;
NEGOP	CALL	PULLA		;get TOS into RegA
	GOTO	DIV90		;go make it negative and push it

;===============================================================================
;			       COMPARE OPERATIONS
;===============================================================================
;
;Integer compares use the top two items on the stack, and return either a
; true ($FFFF) or false ($0000) value on the stack. They are all one-byte
; instructions. Note that RegX contains the opcode.
;
;-------------------------------------------------------------------------------
;$12
;Equal? TOS:= NOS = TOS. Single-byte instruction.
;
EQOP				;fall into NEOP...

;-------------------------------------------------------------------------------
;$13
;Not equal? TOS:= NOS # TOS. Single-byte instruction.
;
NEOP	CALL	PULLA		;get TOS into RegA
	CALL	PULLB		;get NOS into RegB (low byte of RegB is in W)

	SUBWF	RegA,W		;compare TOS to NOS
	BTFSS	STATUS,Z	;skip if equal
	 GOTO	EQOP3		; else branch--go return reversed logic
	MOVF	RegB+1,W	;compare high bytes
	SUBWF	RegA+1,W
	BTFSS	STATUS,Z	;skip if equal
EQOP3	 INCF	RegX		;reverse logic by flipping LSB
EQOP4	MOVLW	0		;push either a true or false value depending
	BTFSS	RegX,0		; on logic
	 MOVLW	0FFh		;use 'true' value
PUSHW2	CALL	PUSH		;push value in W twice and return
	GOTO	OPGOPW		;go push W

;-------------------------------------------------------------------------------
;$17
;Less than? TOS:= NOS < TOS. Single-byte instruction.
;
LTOP				;fall into GEOP...

;-------------------------------------------------------------------------------
;$14
;Greater than or equal? TOS:= NOS >= TOS. Single-byte instruction.
;
GEOP	CALL	PULLB		;get TOS into RegB
	CALL	PULLA		;get NOS into RegA

GEOP2	CALL	DCMP		;compare NOS to TOS
	BTFSS	STATUS,C	;skip if NOS >= TOS
	 GOTO	EQOP3		; else branch--go reverse logic
	GOTO	EQOP4		;go return unreversed logic

;-------------------------------------------------------------------------------
;$15
;Greater than? TOS:= NOS > TOS. Single-byte instruction.
;
GTOP				;fall into LEOP...

;-------------------------------------------------------------------------------
;$16
;Less than or equal? TOS:= NOS <= TOS. Single-byte instruction.
;
LEOP	CALL	PULLA		;get TOS into RegA
	CALL	PULLB		;get NOS into RegB
	GOTO	GEOP2		;go compare TOS to NOS

;===============================================================================
;			        FOR-LOOP CONTROL
;===============================================================================
;$19
;Routine to increment a variable's value. Five-byte instruction: opcode, level,
; offset, and two bytes for the jump address to continue the 'for' loop.
;
INCOP	CALL	HEAPADR		;fetch level & offset and point W to heap addr
	CALL	LOGPHYS		;convert logical address to physical address
	INCF	IND		;increment low byte of 'for' control variable
	MOVF	IND,W		;and save a copy
	MOVWF	RegA
	INCFSZ	FSR		;increment stack pointer without changing Z stat
	BSF	FSR,4		;make sure FSR is pointing to high half of bank
	BTFSC	STATUS,Z	;skip if no carry into high byte of variable
	 INCF	IND		; otherwise increment high byte of variable
	MOVF	IND,W		;save a copy
	MOVWF	RegA+1
	BANKX	0		;restore access to bank 0

	MOVF	RegA,W		;push RegA, low byte first
	CALL	PUSH
	MOVF	RegA+1,W	;push RegA high byte
	CALL	PUSH
	GOTO	JMPOP		;go jump to top of 'for' loop

;-------------------------------------------------------------------------------
;$18
;This routine handles the test and branch of the 'for' loop. The stack contains
; the limit (NOS) and a copy of the loop control variable (TOS). They are
; compared and if the loop variable is greater than the limit, the 'FOR' loop is
; finished. In which case this instruction's address is jumped to, and the stack
; is cleaned up. Otherwise, the 'for' loop continues and the I2LPC is advanced
; to the next opcode, leaving the limit value on the stack. Three-byte
; instruction: opcode, low byte of branch address, high byte.
;
FOROP	CALL	PULLB		;pull TOS (= control variable) into RegB
	CALL	PULLA		;pull NOS (= limit) into RegA

	CALL	DCMP		;compare limit to control variable
	BTFSS	STATUS,C	;skip if limit >= control variable
	 GOTO	JMPOP		; otherwise go jump out of the 'for' loop

	CALL	REPUSH		;effectively push limit back onto stack
	CALL	REPUSH
	GOTO	JPCOPX		;skip past branch address in opcode so that the
				; 'for' loop will continue

;===============================================================================
;			       BOOLEAN OPERATIONS
;===============================================================================
;$1A
;"OR" operation--bitwise on all 16 bits. Single-byte instruction.
; TOS:= NOS ! TOS.
;
OROP	CALL	PULLA		;TOS into RegA
	CALL	PULLB		;NOS into RegB
	IORWF	RegA		;RegA:= RegA ! RegB
	MOVF	RegB+1,W
	IORWF	RegA+1
	GOTO	OPGOPA		;go push RegA

;-------------------------------------------------------------------------------
;$1B
;"AND" operation--bitwise on all 16 bits. Single-byte instruction.
; TOS:= NOS & TOS.
;
ANDOP	CALL	PULLA		;TOS into RegA
	CALL	PULLB		;NOS into RegB
	ANDWF	RegA		;RegA:= RegA & RegB
	MOVF	RegB+1,W
	ANDWF	RegA+1
	GOTO	OPGOPA		;go push RegA

;-------------------------------------------------------------------------------
;$1C
;"NOT" complements all sixteen bits. Single-byte instruction.
; TOS:= ~TOS.
;
NOTOP	CALL	PULLA		;TOS into RegA
	COMF	RegA,W		;RegA:= ~RegA (sort of)
	COMF	RegA+1
	GOTO	OPGOPAW		;go push W & RegA+1

;-------------------------------------------------------------------------------
;$1D
;"XOR" operation--bitwise on all 16 bits. Single-byte instruction.
; TOS:= NOS | TOS.
;
XOROP	CALL	PULLA		;TOS into RegA
	CALL	PULLB		;NOS into RegB
	XORWF	RegA		;RegA:= RegA | RegB
	MOVF	RegB+1,W
	XORWF	RegA+1
	GOTO	OPGOPA		;go push RegA

;===============================================================================
;			        ARRAY OPERATIONS
;===============================================================================
;$1E
; TOS:= NOS + TOS*2. Single-byte instruction.
;
DBAOP	CALL	PULLA		;TOS into RegA
	ADDWF	RegA		;RegA:= RegA * 2
	RLF	RegA+1
	GOTO	ADDOPX		;go add RegA to NOS and return to OPGO

;-------------------------------------------------------------------------------
;$1F
;Store TOS into address in NOS and pop both. Single-byte instruction.
;
STDOP	CALL	PULLA		;TOS into RegA
	CALL	PULLB		;NOS into RegB

	MOVLW	15		;make sure high byte of address is 0, otherwise
	MOVF	RegB+1		;flag I2L error # 15: Attempt to store into ROM
	BTFSS	STATUS,Z
	 CALL	DOERROR

	MOVF	RegB,W		;get low byte of address
	GOTO	STOOPX		;store RegA into this address and return

;-------------------------------------------------------------------------------
;$20
;Form NOS+TOS*2 and then use that value as an address of a word to push onto TOS
; PUSH(NOS+TOS*2). Single-byte instruction.
;
DBXOP	CALL	PULLA		;get TOS into RegA
	ADDWF	RegA		;RegA:= RegA * 2
	RLF	RegA+1
	CALL	PBDADD		;get NOS into RegB and RegA:= RegA + RegB
	CALL	FETCHA		;fetch low byte pointed to by RegA
	CALL	PUSH		;push it
	CALL	FETCHA		;fetch high byte
	GOTO	OPGOPW		;go push it

;-------------------------------------------------------------------------------
;$21
;Load the (logical) address of a variable onto the stack. Conventional three-
; byte instruction: opcode, level, offset.
;
ADROP	CALL	HEAPADR		;fetch level & offset and point W to heap addr
	GOTO	LDXPA		;go push W & a cleared high byte indicating a
				; RAM address cuz all heap variables are in RAM
;===============================================================================
;			    MISCELLANEOUS OPERATIONS
;===============================================================================
;$23
;Short relative jump instruction. BRA 0 branches back to the BRA opcode forming
; an infinite loop. Two-byte instruction: opcode, number of bytes to branch back
;
BRAOP	CALL	FETCH		;get number of opcode bytes to branch back
	SUBWF	I2LPC		;subtract from current I2LPC
	BTFSS	STATUS,C	;skip if no borrow
	 DECF	I2LPC+1

	MOVLW	2		;adjust for the two FETCHes that incremented
	SUBWF	I2LPC		; I2LPC twice (once for opcode and once for
	BTFSS	STATUS,C	; the number of bytes to branch back)
	 DECF	I2LPC+1
	GOTO	OPGO

;-------------------------------------------------------------------------------
;$40..$7F
;Short, short immediate load of an 8-bit, signed constant.
; Single-byte instruction. $40 => -1,  $41 => 0,  $42 => 1,  ...  $7F => 62.
;
SSIMOP	MOVLW	41h		;convert opcode to constant by subtracting 41h
	SUBWF	RegX,W
	GOTO	SIMOPX		;enter common code

;-------------------------------------------------------------------------------
;$24
;TOS:= 8-bit, signed, immediate constant. Two-byte instruction: opcode, constant
;
SIMOP	CALL	FETCH		;get constant byte from opcode
SIMOPX	MOVWF	RegA
SIMOPY	CLRF	RegA+1		;assume high byte is clear
	BTFSC	RegA,7		;skip if low byte is positive
	 COMF	RegA+1		; otherwise set high byte to 0FFh (extend sign)
	GOTO	OPGOPA		;go push RegA

;-------------------------------------------------------------------------------
;$25
;This routine optimizes the case statement a little. It pops TOS, compares it
; to NOS, and takes the jump only if they are not equal. Three-byte instruction:
; opcode, low byte of jump address, high byte of jump address.
;
CJPOP	CALL	PULLB		;TOS into RegB
	CALL	PULLA		;NOS into RegA (low byte of RegA is in W)
	CALL	REPUSH		;effectively push NOS back onto stack
	CALL	REPUSH
	SUBWF	RegB,W		;compare low bytes of NOS to TOS
	BTFSS	STATUS,Z	;skip if they are equal
	 GOTO	JMPOP		; otherwise branch
	MOVF	RegA+1,W	;compare high bytes
	SUBWF	RegB+1,W
	BTFSS	STATUS,Z	;skip if equal
	 GOTO	JMPOP		; otherwise branch
	GOTO	JPCOPX		;TOS = NOS: move I2LPC past address to jump to

;-------------------------------------------------------------------------------
;$0C
;Routine to call an intrinsic. Note that intrinsics return by a direct jump to
; OPGO. Arguments, if any, are on the stack in the order they are called (TOS
; is last). If an intrinsic returns a value, it will be in TOS. The intrinsic
; must keep the stack balanced. A common way to bomb yourself is to pass the
; wrong number of arguments. Two-byte instruction: opcode, intrinsic number.
;
	ORG	1FFh		;(RETP for FETCH sets page bits for Jump Table)
CMLOP	CALL	FETCH		;get intrinsic number
	ADDWF	PC		;jump to corresponding routine

;Intrinsic Routine Jump Table:   No. / Description
	GOTO	ABS		; 0 Absolute value
	GOTO	RAN		; 1 Random number
	GOTO	REM		; 2 Remainder of last divide
	GOTO	RESERVE		; 3 Reserve array space
	GOTO	SWAPB		; 4 Swap bytes
	GOTO	EXTEND		; 5 Extend sign from low byte
	GOTO	RESTART		; 6 Restart XPL0 program
	GOTO	CHIN		; 7 Input a byte
	GOTO	CHOUT		; 8 Output a byte
	GOTO	CRLF		; 9 New line
	GOTO	INTIN		;10 Input an integer
	GOTO	INTOUT		;11 Output an integer
	GOTO	TEXT		;12 Output a string
	GOTO	OPENI		;13 Initialize input device
	GOTO	OPENO		;14 Initialize output device
	GOTO	CLOSE		;15 Close an output device
	GOTO	RESETX		;16 Reset
	GOTO	TRAP		;17 Set trap flags
	GOTO	FREE		;18 Determine remaining heap space
	GOTO	RERUN		;19 Test rerun flag
	GOTO	POUT		;20 Port output
	GOTO	SETHP		;21 Set heap pointer
	GOTO	GETERR		;22 Get I2L error number
	GOTO	PIN		;23 Port input
	GOTO	SOUND		;24 Squeak the speaker
	GOTO	SETRUN		;25 Set the rerun flag
	GOTO	HEXIN		;26 Input a hex integer
	GOTO	HEXOUT		;27 Output a hex integer
	GOTO	DOCLRWDT	;28 CLRWDT instruction
	GOTO	DOOPTION	;29 OPTION instruction
	GOTO	DOSLEEP		;30 SLEEP instruction

;-------------------------------------------------------------------------------
;GOTO and CALL extenders
;
ABSAX	FGOTO	ABSA
PULLAX	FGOTO	PULLA
PULLBX	FGOTO	PULLB
PUSHX	FGOTO	PUSH

;===============================================================================
;				  SUBROUTINES
;===============================================================================
;
;Pull TOS into NOWDEV. Currently any device number other than 0 is illegal.
; If illegal device number then RegA, RegB, RegC, RegX and FLAGS are changed.
;
PULLNOWDEV
	CALL	PULLBX		;pull device number
	MOVWF	NOWDEV		;store low byte into NOWDEV (ignore high byte)

	BTFSC	STATUS,Z	;skip if not device 0
	 RETP			; else return with no error
	MOVLW	3		;flag illegal device number
	GOTO	DOERRORX	;report error and possibly return

;-------------------------------------------------------------------------------
;Output a carriage return and line feed (new line) to NOWDEV.
;
DOCRLF	MOVLW	CR		;carriage return
	CALL	OUTTO
	MOVLW	LF		;line feed
	GOTO	OUTTO		;output byte and return

;-------------------------------------------------------------------------------
;Output a text string pointed to by RegA. The string terminates on a character
; with its MSB (bit 7) set. RegA is left pointing to the end of the string +1.
; Note that the entry point is at TEXTOUT.
;
TXT10	CALL	OUTTO		;output char
TEXTOUT	CALL	FETCHAX		;get character
	MOVWF	TEMP		;test MSB
	BTFSS	TEMP,7		;skip if MSB is set
	 GOTO	TXT10		; else loop back
	ANDLW	7Fh		;clear MSB
	GOTO	OUTTO		;output last char and return

;-------------------------------------------------------------------------------
;Multiply RegA by 16, 4, or 2. The W register is not changed.
;
REGAX16	CALL	REGAX4		;multiply RegA by 16
REGAX4	CALL	REGAX2		;multiply RegA by 4
REGAX2	BCF	STATUS,C	;multiply RegA by 2
	RLF	RegA
	RLF	RegA+1
	RETP

;-------------------------------------------------------------------------------
;Move RegA to RegB.
;
DMOVAB	MOVF	RegA,W		;move low byte
	MOVWF	RegB
	MOVF	RegA+1,W	;move high byte
	MOVWF	RegB+1
	RETP

;-------------------------------------------------------------------------------
;Routine to fetch a byte pointed to by RegA and then bump RegA. (RegA++) -> W.
; This fetches from both RAM and ROM. RAM ranges from $0000 through $00FF, and
; ROM ranges from $0100 through $FFFF. WARNING: This cannot be used to fetch
; from ROM below $0100; specifically, error messages cannot reside below $0100.
;
FETCHAX	MOVF	RegA+1,W	;load and test high byte of address pointer
	BTFSC	STATUS,Z	;skip if it's a ROM address
	 GOTO	FETA20		; else go fetch from RAM

;Fetch from ROM:
	BTFSC	RegA+1,3	;skip if fetching below 800h
	 GOTO	FETA10		; else go fetch two nibbles
	MOVWM			;fetch the byte pointed to by RegA
	MOVF	RegA,W
	IREAD			;fetch byte into W

	INCFSZ	RegA		;increment pointer
	 RETP			; most of the time it returns from here
	INCF	RegA+1		;increment high byte
	BTFSS	RegA+1,3	;skip if 800h--ignore reset vector at 7FFh
	 RETP			; return

	DECF	RegA		;convert 800h back to 7FFh
	DECF	RegA+1

;When fetching at or above address 7FFh, the location to actually fetch from is:
; = (RegA - 7FFh)*2 + PROGLO
; = (RegA - (800h-1))*2 + PROGLO
; = 2*RegA - 1000h + 2 + PROGLO   Since 1000h is over the top, it has no effect
; = 2*RegA + PROGLO + 2
FETA10	RLF	RegA,W		;RegB:= 2*RegA
	MOVWF	RegB
	RLF	RegA+1,W
	CALL	FETCOM
	GOTO	INCAX		;exit

;Fetch from RAM:
FETA20	MOVF	RegA,W		;point FSR to RAM address
	FCALL	LOGPHYS		;convert logical address to physical address
	MOVF	IND,W		;fetch byte from RAM
	BANKX	0		;restore access to bank 0
INCAX	FGOTO	INCA		;increment RegA and return

;-------------------------------------------------------------------------------
;Common code for FETCH and FETCHA. FSR is not changed.
;
FETCOM	MOVWF	RegB+1
	BCF	RegB,0		;clear possible carry in

	MOVLW	low (PROGLO+2)	;RegB:= RegB + PROGLO + 2
	ADDWF	RegB
	BTFSC	STATUS,C
	 INCF	RegB+1
	MOVLW	high (PROGLO+2)
	ADDWF	RegB+1

	MOVF	RegB+1,W	;fetch from location pointed to by RegB
	MOVWM
	MOVF	RegB,W
	IREAD
	MOVMW			;save high nibble in TEMP
	MOVWF	TEMP

	MOVF	RegB+1,W	;fetch from next location
	MOVWM
	INCF	RegB,W		;(PROGLO must be even to prevent possible carry)
	IREAD

	MOVMW			;get low nibble
	SWAPF	TEMP		;combine it with high nibble
	IORWF	TEMP,W
	RETP			;and return the resulting byte in W

;-------------------------------------------------------------------------------
;Output the 16-bit, signed integer in RegA in ASCII decimal format. RegA, RegB,
; RegC, RegX and FLAGS are changed.
;
#define	SUPRLZ	FLAGS,1		;flag: suppress leading zeros

INTO	MOVLW	'-'		;get a minus sign
	BTFSC	RegA+1,7	;skip if RegA is positive
	 CALL	OUTTO		; else output the minus sign

	CALL	ABSAX		;use absolute value of RegA
	MOVLW	4		;set up loop counter and index for POWER table
	MOVWF	RegC
	BSF	SUPRLZ		;set flag to suppress leading zeros

;Subtract a power-of-10 from RegA until it is negative. Count the number
; of subtractions in RegX.
IO20	CLRF	RegX		;init subtraction counter

	DECF	RegC,W		;move current power-of-ten into RegB
	CALL	POWERL		;index into POWER table = loop counter -1
	MOVWF	RegB
	DECF	RegC,W
	CALL	POWERH
	MOVWF	RegB+1

IO30	FCALL	DSUB		;subtract power-of-10 from RegA
	INCF	RegX		;count number of subtractions
	BTFSS	RegA+1,7	;loop until negative result
	 GOTO	IO30

	FCALL	DADD		;add back one power-of-ten
	DECFSZ	RegX,W		;undo one subtraction and get counter in W
				;skip if counter is zero
	 BCF	SUPRLZ		; else set flag to output zeros from now on
	IORLW	30h		;convert binary to an ASCII digit
	BTFSS	SUPRLZ		;skip if leading zeros are being suppressed
	 CALL	OUTTO		; else output digit

	DECFSZ	RegC		;loop for powers 10000 down to 10
	 GOTO	IO20

	MOVF	RegA,W		;the one's digit is left in RegA
	IORLW	030h		;output it whether it's a zero or not
	GOTO	OUTTO		; and return

;Power-of-Ten Tables
;
POWERL	ADDWF	PC
	RETLW	low    10	;1
	RETLW	low   100	;2
	RETLW	low  1000	;3
	RETLW	low 10000	;4

POWERH	ADDWF	PC
	RETLW	high    10	;1
	RETLW	high   100	;2
	RETLW	high  1000	;3
	RETLW	high 10000	;4

;-------------------------------------------------------------------------------
;Input a signed integer in decimal ASCII format. The 16-bit binary result is
; returned in RegA. RegB, RegX and FLAGS are changed.
;
#define	SignFlg	FLAGS,2		;sign flag: set if negative number
#define	NumFlg	FLAGS,3		;number flag: set when digit is read in

GETNO
II00	CLRF	RegA		;initialize
	CLRF	RegA+1
	CLRF	FLAGS		;clear SignFlg and NumFlg

	CALL	INPB		;read in an ASCII character
	MOVWF	RegX		;save a copy
	XORLW	EOF		;is it an end-of-file character?
	BTFSC	STATUS,Z	;skip if not
	 GOTO	II90		; branch if so--return with RegA = 0
	XORLW	EOF^'-'		;is character a minus sign? (undoes XOR EOF too)
	BTFSS	STATUS,Z	;skip if so
	 GOTO	II30		; branch if not
	BSF	SignFlg		;set the sign flag

II20	CALL	INPB		;read in an ASCII digit
	MOVWF	RegX		;save a copy
II30	MOVLW	'0'		;compare digit to '0'
	SUBWF	RegX		;save result (0-9) in RegX
	BTFSS	STATUS,C	;skip if it's >= '0'
	 GOTO	II80		; branch if digit < '0'
	MOVLW	10		;compare resulting digit to 10
	SUBWF	RegX,W		;(don't mess up RegX)
	BTFSC	STATUS,C	;skip if it's < 10
	 GOTO	II80		;branch if it's >= 10
	BSF	NumFlg		;indicate a digit (0-9) was read in

	CALL	DMOVAB		;RegA:= RegA *10
	CALL	REGAX4
	FCALL	DADD
	CALL	REGAX2
	MOVF	RegX,W		;RegA:= RegA + digit
	ADDWF	RegA
	BTFSC	STATUS,C	;propagate carry if necessary (required)
	 INCF	RegA+1
	GOTO	II20		;loop until a non-digit character is read in
II80
	BTFSS	NumFlg		;come here when a non-digit character is read in
	 GOTO	II00		;start over if no digits were read in

	BTFSS	SignFlg		;if there was no minus sign then
II90	 RETP			; just return
	FGOTO	NEGA		; else negate RegA and return

;-------------------------------------------------------------------------------
;Output the binary value in RegA as four ASCII hex digits. RegA is preserved;
; RegX is changed.
;
HEX4OUT	MOVF	RegA+1,W	;output high byte
	CALL	HEX2OUT
	MOVF	RegA,W		;get low byte and fall into HEX2OUT...

;-------------------------------------------------------------------------------
;Output the binary value in the W register as two ASCII hex digits. RegX is
; changed.
;
HEX2OUT	MOVWF	RegX		;save copy
	SWAPF	RegX,W		;output high nibble
	CALL	HEX1OUT
	MOVF	RegX,W		;get saved low nibble and fall into HEX1OUT...

;-------------------------------------------------------------------------------
;Output the binary value in the W register as an ASCII hex digit.
;
HEX1OUT	ANDLW	00Fh		;get nibble
	MOVWF	TEMP		;save copy
	MOVLW	10		;compare it to 10
	SUBWF	TEMP,W
	MOVLW	'A'-'0'-10	;set up for case where it's >= 10
	BTFSC	STATUS,C	;skip if it's less than 10
	 ADDWF	TEMP		; else add 'A' (-'0') to amount nibble is >= 10
	MOVLW	'0'		;convert to ASCII
	ADDWF	TEMP,W
	GOTO	OUTTO		;output char and return

;-------------------------------------------------------------------------------
;Randomize the random number generator.
; WARNING: A lockup condition exists if all bits in SEED are ones.
;
RANDIZE	BANKA	SEED
	MOVF	RB,W		;RB is not zeroed by initialization code
	ANDLW	0F7h
	MOVWF	SEED+1
	MOVWF	SEED+2
	BANKX	0
	RETP

;===============================================================================
;				 I/O ROUTINES
;===============================================================================
;
;Since there is only one I/O device, the dispatch routine is eliminated.
; BEWARE: These I/O routines must not change any registers used by the
; interpreter (except W and FSR).
;
;-------------------------------------------------------------------------------
;Input an ASCII character and return it in the W register
;
INPB	RETP	;***INPUTX	;GOTO	Rcv		*** DEBUG ***
				;fall into OUTTO to echo it...
;-------------------------------------------------------------------------------
;Output ASCII character in the W register
;
OUTTO	RETP	;***OUTPUTX	;GOTO	Xmit		*** DEBUG ***

;-------------------------------------------------------------------------------
;Initialize device for input
;
INIDEV
;	RETP

;-------------------------------------------------------------------------------
;Initialize device for output
;
INODEV
;	RETP

;-------------------------------------------------------------------------------
;Close output device
;
CLODEV
	RETP

;===============================================================================
;			      INTRINSIC ROUTINES
;===============================================================================
;0
;Intrinsic to return the absolute value of top-of-stack (TOS).
;	VAL:= ABS(VAL);
;
ABS	CALL	PULLAX		;pull TOS into RegA
	CALL	ABSAX		;take absolute value of RegA
OPGOPAX	FGOTO	OPGOPA		;go push RegA and return to OPGO

;-------------------------------------------------------------------------------
;1
;Intrinsic to generate a random number. The value returned is between 0 and
; TOS-1.
; If TOS = 0 then the seed is initialized for a repeatable sequence.
; If TOS < 0 then the seed is randomized and RAN(-TOS) is returned.
;	VAL:= RAN(10);		\VAL gets 0 through 9
;
RAN	CALL	PULLAX		;get the limit, which is in TOS
	IORWF	RegA+1,W	;check for limit = 0
	BTFSS	STATUS,Z	;skip if zero (W holds 0, which is used below)
	 GOTO	RAN10		; else branch if not zero

	BANKA	SEED
	CLRF	SEED		;initialize for a repeatable sequence
	CLRF	SEED+1
	CLRF	SEED+2
	BANKX	0
PUSHW2X	FGOTO	PUSHW2		;return a zero (in W) on the stack

RAN10	BTFSC	RegA+1,7	;skip if limit is positive
	 CALL	RANDIZE		; else randomize seed
	CALL	ABSAX		;use positive range
	CALL	DMOVAB		;copy limit into RegB

;pseudo-random generator using 24-bit feedback shift register
	BANKA	SEED
	RLF	SEED,W		;XNOR the 2 most significant bits
	XORLW	0FFh
	XORWF	SEED,W
	MOVWF	TEMP		;and shift result into carry
	ADDWF	TEMP

	RRF	SEED+2		;rotate the entire 24-bit shift register
	RRF	SEED+1
	RRF	SEED

	SWAPF	SEED+1,W	;move SEED into RegA (backwards)
	MOVWF	RegA
	SWAPF	SEED,W		;scramble the bits a bit
	MOVWF	RegA+1
	BCF	RegA+1,7	;force number positive
	BANKX	0

	FCALL	DIV		;RegA:= RegA / RegB
	GOTO	REM10		;go return remainder as the random number

;-------------------------------------------------------------------------------
;2
;Get remainder of most recent integer division. The argument is an expression
; whose result is thrown away. This expression can contain a division or just
; be zero to get the result of an earlier division.
;	VAL:= REM(17/5);	\VAL gets 2
;	VAL:= REM(0);
;
REM	CALL	PULLAX		;discard TOS
REM10	MOVF	REMAIN+1,W	;copy remainder of latest division into RegA
	MOVWF	RegA+1
	MOVF	REMAIN,W
	FGOTO	OPGOPAW		;go push W & RegA+1 and return to OPGO

;-------------------------------------------------------------------------------
;3
;Intrinsic to reserve bytes in the heap and return the base address of the
; reserved space. This is the way arrays are created. Since space is reserved
; in the heap allocation of a procedure, the array will disappear when the
; procedure is exited.
;	ARRAY:= RESERVE(5*2);	\Reserve a 5x3 integer array
;	for I:= 0, 5-1 do ARRAY(I):= RESERVE(3*2);
;
RESERVE	CALL	PULLAX		;get number of bytes to reserve
	MOVF	HP,W		;return the current HP on the stack
	CALL	PUSHX		;push low byte (a 0 high byte is pushed later)
	MOVF	RegA,W		;add number of bytes to reserve to current HP
	ADDWF	HP

	MOVLW	0FFh		;check for memory overflow (error 2)
	BTFSC	STATUS,C	;if there was a carry into high byte of amount
	 MOVWF	RegA+1		; to reserve then force an error (RegA+1:= 0FFh)
	MOVF	RegA+1		;test high byte of sum
	BTFSS	STATUS,Z	;skip if it's zero
	 MOVWF	HP		; else force an error (HP:= 0FFh)
	FCALL	CHKMEM		;check for memory overflow (HP > I2LSP)

	MOVLW	0		;push high byte = 0, since RAM starts at $0000
OPGOPWX	FGOTO	OPGOPW

;-------------------------------------------------------------------------------
;4
;Intrinsic to swap the high and low bytes of the value in top-of-stack.
;	VAL:= SWAP($1234);	\VAL gets $3412
;
SWAPB	CALL	PULLAX		;TOS into RegA
	MOVF	RegA+1,W	;push new low byte
	CALL	PUSHX
	MOVF	RegA,W		;push new high byte
	GOTO	OPGOPWX		;go push W

;-------------------------------------------------------------------------------
;5
;Intrinsic to extend the sign of the low byte into the high byte.
;	VAL:= EXTEND(VAL);
;
EXTEND	CALL	PULLAX		;TOS into RegA
	FGOTO	SIMOPY		;go do it (W = RegA)

;-------------------------------------------------------------------------------
;6
;Intrinsic to restart the XPL0 program.
;	RESTART;
;
RESTART	MOVLW	0FFh		;set rerun flag to true
	MOVWF	RERUNF
	GOTO	START

;-------------------------------------------------------------------------------
;7
;Intrinsic to input a byte and return it on the stack.
;	VAL:= CHIN(0);
;
CHIN	CALL	PULLNOWDEV	;pull device number
	CALL	INPB		;input a byte
LDXPAX	FGOTO	LDXPA		;go push W reg then push 0

;-------------------------------------------------------------------------------
;8
;Intrinsic to output the byte on the stack.
;	CHOUT(0, ^A);
;
CHOUT	CALL	PULLAX		;pull byte and save it in RegA
	CALL	PULLNOWDEV	;pull device number
	MOVF	RegA,W		;get byte
	CALL	OUTTO		;send it
OPGOX	FGOTO	OPGO

;-------------------------------------------------------------------------------
;9
;Intrinsic to output a carriage return and line feed, i.e. start a new line.
;	CRLF(0);
;
CRLF	CALL	PULLNOWDEV	;pull device number
	CALL	DOCRLF		;output CR & LF
	GOTO	OPGOX

;-------------------------------------------------------------------------------
;10
;Intrinsic to input a signed integer and return its value on the stack.
;	VAL:= INTIN(0);
;
INTIN	CALL	PULLNOWDEV	;pull device number
	CALL	GETNO		;input the integer into RegA
	GOTO	OPGOPAX		;go push RegA

;-------------------------------------------------------------------------------
;11
;Intrinsic to output the value on the stack in signed, decimal ASCII format.
;	INTOUT(0, -123);
;
INTOUT	CALL	PULLAX		;pull integer into RegA
	CALL	PULLNOWDEV	;pull device number
	CALL	INTO		;output it
	GOTO	OPGOX

;-------------------------------------------------------------------------------
;12
;Intrinsic to output a text string.
;	TEXT(0, "Hello");
;
TEXT	CALL	PULLAX		;pull address of string into RegA
	CALL	PULLNOWDEV	;pull device number
	CALL	TEXTOUT		;output the string
	GOTO	OPGOX

;-------------------------------------------------------------------------------
;13
;Intrinsic to open, or initialize, an input device.
;	OPENI(0);
;
OPENI	CALL	PULLNOWDEV	;pull device number
	CALL	INIDEV
	GOTO	OPGOX

;-------------------------------------------------------------------------------
;14
;Intrinsic to open, or initialize, an output device.
;	OPENO(0);
;
OPENO	CALL	PULLNOWDEV	;pull device number
	CALL	INODEV
	GOTO	OPGOX

;-------------------------------------------------------------------------------
;15
;Intrinsic to close an output device.
;	CLOSE(0);
;
CLOSE	CALL	PULLNOWDEV	;pull device number
	CALL	CLODEV
	GOTO	OPGOX

;-------------------------------------------------------------------------------
;16
;Intrinsic to abort the XPL0 program by jumping to the RESET start-up code.
;	RESET;
; (No code necessary--see Intrinsic Routine Jump Table.)
;
;-------------------------------------------------------------------------------
;17
;Intrinsic to set the error trap flags.
;	TRAP($FFFD);		\Ignore divide by zero (bit 1 is clear)
;
TRAP	CALL	PULLAX		;pull flag bits into RegA
	MOVWF	TRAPS		;copy RegA into TRAPS
	MOVF	RegA+1,W
	MOVWF	TRAPS+1
	GOTO	OPGOX

;-------------------------------------------------------------------------------
;18
;Intrinsic to return the number of bytes of unused space available in the heap.
; This space should not all be reserved because some will probably be needed
; for the stack and for local variables in any procedures that are called.
;	RESERVE(FREE-8);
; Return logical(I2LSP) - HP
;
FREE	MOVF	I2LSP,W		;convert physical address to logical address
;*** DEBUG
;	ANDLW	0Fh		;convert I2LSP to logical address in TEMP
;	MOVWF	TEMP		;simply shift high nibble of I2LSP right
;	RRF	I2LSP,W		; one bit, leave low nibble intact
;	ANDLW	70h
;	IORWF	TEMP
;
;	MOVF	HP,W		;temp - HP
;	SUBWF	TEMP,W		;return result on stack
;	GOTO	LDXPAX		;push W reg then push 0

;-------------------------------------------------------------------------------
;19
;Intrinsic to return the value of the rerun flag.
;	FLAG:= RERUN;
;
RERUN	MOVF	RERUNF,W	;get the flag
	GOTO	PUSHW2X		;go push W twice

;-------------------------------------------------------------------------------
;20
;Intrinsic to output a byte to any "port" address. "Port" is not restricted
; to locations 5 through 7, thus any RAM location can be written.
;	POUT(value, port, mode);
; If "mode" is not 0 then output "value" to the control register specified by
; mode. In this case only these "ports" are valid:
;	5	TRIS RA
;	6	TRIS RB
;	7	TRIS RC
;
POUT	CALL	PULLAX		;pull mode
	BTFSS	STATUS,Z	;skip if mode = 0
	 GOTO	POUT00		; else go do TRIS

	CALL	PULLBX		;pull port address and save it in RegB
	CALL	PULLAX		;pull byte to output and save it in RegA
	MOVF	RegB,W		;set FSR to port address
	MOVWF	FSR		;BANK 0 IS NO LONGER SELECTED
	MOVF	RegA,W		;get byte to output
	MOVWF	IND		;write it to specified port
	BANKX	0		;restore access to bank 0
	GOTO	OPGOX

POUT00	MOVWM			;store pulled mode value into MODE register
	CALL	PULLBX		;pull port address and save it in RegB
	CALL	PULLAX		;pull byte to output, it's in W

	BTFSC	RegB,1		;port address bits: X01 X10 X11
	 GOTO	POUT20		;corresponds to:    RA  RB  RC

	BTFSC	RegB,0
	 TRIS	RA
	GOTO	OPGOX

POUT20	BTFSS	RegB,0
	 TRIS	RB
	BTFSC	RegB,0
	 TRIS	RC
	GOTO	OPGOX

;-------------------------------------------------------------------------------
;21
;Intrinsic to set the heap pointer. The current value of the heap pointer is
; gotten by calling RESERVE(0). The user should have a good idea of the
; functioning of I2L before dinging with the heap pointer, or he will surely
; bomb himself.
;	SETHP($40);
;
SETHP	CALL	PULLAX		;get (logical) address
	MOVWF	HP		;set new heap pointer
	GOTO	OPGOX

;-------------------------------------------------------------------------------
;22
;Intrinsic to return the latest I2L error number and then clear it.
;	ERR:= GETERR;
;
GETERR	MOVF	ERRNO,W		;get error number
	CLRF	ERRNO		;clear error number
	GOTO	LDXPAX		;go push W then push 0

;-------------------------------------------------------------------------------
;23
;Intrinsic to read a byte from any "port" address and return it on the stack.
; Port is not restricted to locations 5-7, thus any RAM location can be read.
;	variable:= PIN(port, mode);
;
PIN	CALL	PULLAX		;pull mode
	BTFSS	STATUS,Z	;skip if mode = 0
	 GOTO	PIN00		; else go do TRIS

	CALL	PULLAX		;pull port address
	MOVWF	FSR		;put low byte into FSR
	MOVF	IND,W
	BANKX	0		;restore access to bank 0
	GOTO	LDXPAX		;go push W reg then push 0

PIN00	MOVWM			;store pulled mode value into MODE register
	CALL	PULLAX		;pull port address and discard it
	TRIS	RB		;port is assumed to be RB; swap W with ctrl reg
	MOVWF	RegA		;save control register value in RegA
	TRIS	RB		;swap back to restore original value in ctrl reg
	CLRF	RegA+1		;clear high byte
	GOTO	OPGOPAX		;go push RegA and return

;-------------------------------------------------------------------------------
;24
;Intrinsic to emit a sound.
;	SOUND(vol, cycles, period)
;The actual period of the square wave depends on the microcontroller oscillator.
; "cycles" is actually "half-cycles". "Vol" (volume) is either full on or off.
; When the volume is off, this intrinsic provides a time delay.
;
#define	VOL	FLAGS,0		;flag indicating that volume is on

SOUND	CALL	PULLAX		;pull period
	FCALL	PULLC		;pull number of half-cycles
	CALL	PULLBX		;pull volume (on/off)
	BSF	VOL		;assume volume is on
	IORWF	RegB+1		;if any bit is set, volume is on
	BTFSC	STATUS,Z	;skip if not zero
	 BCF	VOL		; else clear volume flag

;Put out RegC half-cycles of sound
	INCF	RegC		;compensate for DECFSZ below
	INCF	RegC+1		; (RegC might be 0)
	GOTO	SND30		;go check for zero cycles

SND20	MOVLW	80h		;set bit corresponding to speaker
	BTFSC	VOL		;skip if volume is off
	 XORWF	RB		; else flip speaker bit

	CALL	DMOVAB		;delay for half a cycle; period -> RegB
	INCF	RegB		;compensate for DECF below
	INCF	RegB+1
SND50	CLRWDT			;kill 5 cycles per loop (in turbo mode)
				; (Was an NOP  R.O.)
	DECFSZ	RegB		;loop on low byte
	 GOTO	SND50
	DECFSZ	RegB+1		;loop on high byte
	 GOTO	SND50

SND30	DECFSZ	RegC		;loop on low cycle byte
	 GOTO	SND20
	DECFSZ	RegC+1		;loop on high cycle byte
	 GOTO	SND20
	GOTO	OPGOX		;return when cycle count is zero

;-------------------------------------------------------------------------------
;25
;Intrinsic to set or clear the rerun flag.
;	SETRUN(true);
;
SETRUN	CALL	PULLAX		;get TOS
	IORWF	RegA+1,W	;if any bit is set, the flag is set (true)
	MOVWF	RERUNF
	GOTO	OPGOX

;-------------------------------------------------------------------------------
;26
;Intrinsic to input a hex integer and return it in top-of-stack.
;	HEX:= HEXIN(0);
;Input an unsigned, 16-bit ASCII hex number into RegA. Any leading non-hex
; characters are ignored (including a minus sign). The number is terminated
; either by a non-hex character or after 4 digits have been read in. 
; RegA and RegX are changed.
;
HEXIN	CALL	PULLNOWDEV	;pull device number
	CLRF	RegA		;initialize hex value
	CLRF	RegA+1
	MOVLW	4		;init digit counter
	MOVWF	RegX

HI00	CALL	INPB		;read in an ASCII character
	MOVWF	TEMP		;save copy
	XORLW	EOF		;is it an end-of-file character?
	BTFSC	STATUS,Z	;skip if not
	 GOTO	HI90		; branch if it is--return with RegA=0

	MOVLW	'0'		;subtract lower limit
	SUBWF	TEMP
	MOVLW	10		;compare to upper limit (>= 10)
	SUBWF	TEMP
	BTFSS	STATUS,C	;skip if character is > '9' or < '0'
	 GOTO	HI30		; else character is in range '0' through '9'

	BCF	TEMP,5		;make sure possible 'a'-'f' is uppercase
	MOVLW	'A'-('0'+10)	;compensate TEMP for above subtracts and
	SUBWF	TEMP		; also subtract 'A'
	MOVLW	'F'-'A'+1	;(= 6) test for upper limit of 'F'
	SUBWF	TEMP,W
	BTFSC	STATUS,C	;skip if result is negative--i.e. in range
	 GOTO	HI40		; else not a valid hex digit
	MOVLW	10		;get fix-up value
HI30	ADDWF	TEMP,W		;add 10 to get binary value

	CALL	REGAX16		;multiply current value by 16 (W is unchanged)
	IORWF	RegA		;insert hex digit

	DECFSZ	RegX		;loop for a maximum of 4 digits
	 GOTO	HI00
HI40
	BTFSC	RegX,2		;skip if any digits read in
	 GOTO	HI00		; else go back and keep trying
HI90	GOTO	OPGOPAX		;go push RegA

;-------------------------------------------------------------------------------
;27
;Intrinsic to output the value in top-of-stack in ASCII hex format.
;	HEXOUT(0, $1234);
;
HEXOUT	CALL	PULLAX		;pull integer into RegA
	CALL	PULLNOWDEV	;pull device number
	CALL	HEX4OUT		;output it
	GOTO	OPGOX

;-------------------------------------------------------------------------------
;28
;Intrinsic to execute CLRWDT instruction.
;	CLRWDT;
;
DOCLRWDT CLRWDT			;clear WDT & prescaler; set STATUS,TO & PD
	GOTO	OPGOX

;-------------------------------------------------------------------------------
;29
;Intrinsic to set the OPTION register.
;	OPTION($85);	\enable RTCC interrupt and set prescaler to divide by 64
;
DOOPTION CALL	PULLAX		;pull integer into RegA, W = low byte
	OPTION			;move W to OPTION register
	GOTO	OPGOX

;-------------------------------------------------------------------------------
;30
;Intrinsic to execute SLEEP instruction.
;	SLEEP;
;
DOSLEEP	SLEEP			;clear WDT & prescaler; set STATUS,TO & clear PD
	GOTO	OPGOX		; *** DEBUG ***

;-------------------------------------------------------------------------------
;I2L error handler. Call with error number in W register. Possible errors are:
;	 0: RETURN FROM MAIN
;	 1: DIV BY 0
;	 2: OUT OF MEMORY
;	 3: I/O ERROR (ILLEGAL DEVICE NUMBER)
;	 4: BAD OPCODE (DISABLED)
;	 5: BAD INTRINSIC (DISABLED)
;	15: STORE INTO ROM
; If the corresponding bit in the TRAP flags is clear then this routine returns,
; otherwise it is a fatal error and the interpreter is restarted, which restarts
; the XPL0 program. If this returns, ERRNO, RegC and RegX are changed.
;
DOERRORX MOVWF	ERRNO		;save the error number
	MOVWF	RegX		;set up loop counter

	MOVF	TRAPS,W		;use copy of trap flags
	MOVWF	RegC
	MOVF	TRAPS+1,W
	MOVWF	RegC+1

ERR10	RRF	RegC+1		;shift bit corresponding to error into bit 0
	RRF	RegC
	DECFSZ	RegX
	 GOTO	ERR10		;loop

	BTFSS	RegC,0		;if this trap bit is clear then return and
	 RETP			; ignore the error, else fall into ERREXIT...

;-------------------------------------------------------------------------------
;Send an error message and restart the interpreter
;
ERREXIT	CLRF	NOWDEV		;send I2L error message to console
	CALL	DOCRLF		;new line
	MOVLW	low ERRMSG	;display: "Error "
	MOVWF	RegA
	MOVLW	high ERRMSG
	MOVWF	RegA+1
	CALL	TEXTOUT

	MOVF	ERRNO,W		;display error number (can be 0)
	MOVWF	RegA
	CLRF	RegA+1
	CALL	INTO
	CALL	DOCRLF		;new line
	GOTO	START		;restart interpreter

;ERRMSG	DT	Bel, "Error", Sp+80h
ERRMSG	DT	Bel		;(for SxSim)   *** DEBUG ***
	DT	'E'
	DT	'r'
	DT	'r'
	DT	'o'
	DT	'r'
	DT	' '+80h

;WARNING: Messages in ROM cannot reside below 100h because of how FETCHA works.

;===============================================================================
;                            RESET ENTRY POINT
;===============================================================================
RESETX	BTFSS	STATUS,TO	;If TO=0 then WDT timeout occurred
	GOTO	START		; bypass clearing RAM and do a restart

;Clear RAM from 08h up through highest enabled bank. Also clears FSR.
	CLRF	FSR
RES10	BTFSS	FSR,4		;skip if 10-1F in each bank
	 BSF	FSR,3		; else skip if 0-7 (skip special registers)
	CLRF	IND		;clear location
	INCFSZ	FSR
	 GOTO	RES10

;Reset clears rerun flag (RERUNF). Restart leaves it set.
START	MOVLW	STACK		;initialize interpreter's stack pointer
	MOVWF	I2LSP

	MOVLW	HEAPLO		;initialize heap pointer to base of heap space
	MOVWF	HP
	MOVWF	DISPLY		;also init level 0 in display vector table
	CLRF	LEVEL

	MOVLW	0FFh		;trap all errors
	MOVWF	TRAPS
	MOVWF	TRAPS+1
	CLRF	ERRNO		;clear error number

;Initialize intrinsic routines
	CALL	RANDIZE		;randomize random number generator

	MOVLW	low PROGLO	;set interpreter's program counter to start
	MOVWF	I2LPC		; of I2L code
	MOVLW	high PROGLO
	MOVWF	I2LPC+1
	GOTO	OPGOX		;go start interpreting

;===============================================================================
;16-bit, unsigned divide. RegA:= RegA / RegB. Remainder in REMAIN.
;
;	REMAIN <-- RegA    RegX
;	- RegB
;
	ORG	400h
DIV	CLRF	REMAIN		;initialize remainder "register"
	CLRF	REMAIN+1

	MOVLW	17		;initialize loop counter
	MOVWF	RegX
	GOTO	DIV20		;(carry doesn't matter cuz RegA is shifted 17x)

DIV10	RLF	REMAIN		;shift in high bit from RegA
	RLF	REMAIN+1

	MOVF	RegB+1,W	;compare REMAIN to RegB
	SUBWF	REMAIN+1,W	;compare high bytes
	BTFSS	STATUS,Z	;skip if equal
	 GOTO	DIV15		; else branch if not equal
	MOVF	RegB,W		;compare low bytes
	SUBWF	REMAIN,W
DIV15
	BTFSS	STATUS,C	;skip if REMAIN >= RegB (carry is set)
	 GOTO	DIV20		; otherwise branch (carry is clear)

	MOVF	RegB,W		;REMAIN:= REMAIN - RegB
	SUBWF	REMAIN		;subtract low bytes
	MOVF	RegB+1,W	;get ready to subtract high bytes
	BTFSS	STATUS,C	;skip if there was no borrow from high byte
	 INCFSZ	RegB+1,W	; else increase amount to subtract by 1; if it's
	 SUBWF	REMAIN+1	; 0 then high byte doesn't change, carry is set
DIV20
	RLF	RegA		;shift carry bit into quotient
	RLF	RegA+1
	DECFSZ	RegX		;loop until done (don't disturb carry)
	 GOTO	DIV10
	RETP

;===============================================================================
;                        INTERRUPT SERVICE ROUTINE
;===============================================================================
;
ISRX	MOVLW	-100		;interrupt every 100 RTCC cycles
	RETIW

;NOTE: If code is added, PROGLO will move, and RUN.CMD might need to be changed.

;===============================================================================
;				    I2L CODE
;===============================================================================

	ERRORLEVEL	-306	;don't display "crossing page boundary" message
	ORG	($+1)&0FFEh	;this must agree with loc used by SXLODI2L.XPL
				; and it must be even because of FETCOM

;-------------------------------------------------------------------------------
;Example showing how an XPL0 program is compiled into .I2L code and how the
; loader converts it to DATA instructions.
;
;XPL0 program:
;	loop Text(0, "Hello World! ");
;
;I2L code (with commentary added):
;	;0000 0905	HPI 5		reserve space for global 0 (a real)
;	      41	IMM 0		push device 0
;	      26*0000	JSR		push address of string and jump over it
;	;0006 48656C6C6F20576F726C642120	"Hello World! "
;	;0012 A0			terminator (space char with MSB set)
;	;0013
;	^0004				fix JSR address to jump here
;	      0C0C	CML Text	call intrinsic routine to output string
;	      2313	BRA loop	branch back
;	$				end-of-file marker
;
;I2L code converted to (unpacked) DATA instructions by SXLODI2L:
;
;PROGLO	EQU	$
;	DATA	09h, 05h
;	DATA	41h
;	DATA	26h
;	DATA	13h+low PROGLO, 00h+high PROGLO
;	DATA	'H'
;	DATA	'e'
;	DATA	'l'
;	DATA	'l'
;	DATA	'o'
;	DATA	' '
;	DATA	'W'
;	DATA	'o'
;	DATA	'r'
;	DATA	'l'
;	DATA	'd'
;	DATA	'!'
;	DATA	' '|80h
;	DATA	0Ch, 0Ch
;	DATA	23h, 13h
;
;	ORG	7FFh
;	GOTO	RESET
;	END
;-------------------------------------------------------------------------------


file: /Techref/scenix/xpl0/I2L.ASM, 76KB, , updated: 2000/5/12 18:20, local time: 2018/10/15 11:29,
TOP NEW HELP FIND: 
54.196.26.1:LOG IN

 ©2018 These pages are served without commercial sponsorship. (No popup ads, etc...).Bandwidth abuse increases hosting cost forcing sponsorship or shutdown. This server aggressively defends against automated copying for any reason including offline viewing, duplication, etc... Please respect this requirement and DO NOT RIP THIS SITE. Questions?
Please DO link to this page! Digg it! / MAKE! / 

<A HREF="http://techref.massmind.org/techref/scenix/xpl0/I2L.ASM"> scenix xpl0 I2L</A>

Did you find what you needed?

 

Welcome to massmind.org!

 

Welcome to techref.massmind.org!

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

  .