*
*
*
RDIVS:	LDX    NUMSTACK     ; POINT TO NUMERIC STACK.
	LDAA   0,X          ; GET UPPER BYTE OF DIVISOR.
	EORA   2,X          ; GET SIGN OF THE RESULT.
	PSHA                ; SAVE RESULT.
	LDD    0,X          ; GET DIVISOR OFF NUMERIC STACK. IS IT ZERO?
	BNE    RDIV1        ; NO. CONTINUE.
RDIV2:	LDAA   #ZDIVERR     ; YES. GET DIVIDE BY ZERO ERROR.
	JMP    RPTRERR      ; GO REPORT IT.
RDIV1:	BPL    RDIV3        ; IF POSITIVE IT'S OK.
	JSR    RNEG         ; IF NOT MAKE IT POSITIVE.
RDIV3:	TST    2,X          ; IS THE DIVIDEND NEGATIVE?
	BPL    RDIV4        ; NO. CONTINUE.
	LDD    2,X          ; YES. GET THE NUMBER.
	COMA                ; NEGATE IT.
	COMB
	ADDD   #1
	STD    2,X          ; SAVE THE RESULT.
RDIV4:	LDD    0,X          ; GET THE DIVISOR.
	LDX    2,X          ; GET THE DIVIDEND.
	XGDX                ; PUT THEM IN THE PROPER REGISTERS.
	IDIV                ; DO AN UNSIGNED DIVIDE.
	PSHX                ; SAVE THE QUOTIENT.
	LDX    NUMSTACK     ; POINT TO THE NUMERIC STACK.
	STD    2,X          ; SAVE THE REMAINDER.
*        PULD                 ; GET THE QUOTIENT.
	PULA
	PULB
	STD    0,X          ; PUT IT ON THE NUMERIC STACK.
	PULA                ; GET THE SIGN OF THE RESULT.
	TSTA                ; SET THE CONDITION CODES.
	BPL    RDIV5        ; IF PLUS, RESULT OK AS IS.
	JSR    RNEG         ; MAKE THE QUOTIENT NEGATIVE.
	LDD    2,X          ; GET THE REMAINDER.
	COMA                ; MAKE IT NEGATIVE.
	COMB
	ADDD   #1
	STD    2,X          ; SAVE THE RESULT.
RDIV5:	RTS                 ; RETURN.
*
*
RMOD:	BSR    RDIVS        ; GO GET QUOTIENT & REMAINDER.
	JSR    PULNUM       ; REMOVE INTEGER RESULT & LEAVE REMAINDER.
	RTS                 ; RETURN.
*
*
RMULT:	PSHY
	LDX    NUMSTACK
	LDAA   1,X
	LDAB   3,X
	MUL
*        PSHD
	PSHB
	PSHA
	TSY
	LDAA   1,X
	LDAB   2,X
	MUL
	ADDB   0,Y
	STAB   0,Y
	LDAA   0,X
	LDAB   3,X
	MUL
	ADDB   0,Y
	STAB   0,Y
	INX
	INX
*        PULD
	PULA
	PULB
	STD    0,X
	STX    NUMSTACK
	PULY
	RTS
*
*
RINDIR:	EQU    *
	RTS
*
*
RNOT:	EQU    *
	LDX    NUMSTACK
	LDD    0,X
	COMA
	COMB
	STD    0,X
	RTS
*
*
RNEG:	EQU    *
	BSR    RNOT
	ADDD   #1
	STD    0,X
	RTS
*
*
RLT:	EQU    *
	BSR    CMPNUM
	BGE    RLT1
RLT2:	INC    3,X
RLT1:	INX
	INX
	STX    NUMSTACK
	RTS
*
*
RGT:	EQU    *
	BSR    CMPNUM
	BLE    RLT1
	BRA    RLT2
*
*
RLTEQ:	EQU    *
	BSR    CMPNUM
	BGT    RLT1
	BRA    RLT2
*
*
RGTEQ:	EQU    *
	BSR    CMPNUM
	BLT    RLT1
	BRA    RLT2
*
*
REQ:	EQU    *
	BSR    CMPNUM
	BNE    RLT1
	BRA    RLT2
*
*
RNOTEQ:	EQU    *
	BSR    CMPNUM
	BEQ    RLT1
	BRA    RLT2
*
*
CMPNUM:	EQU    *
	LDX    NUMSTACK
	LDD    2,X
	CLR    2,X
	CLR    3,X
	CPD    0,X
	RTS
*
*
RPWR:	EQU    *
	RTS
*
*
RABS:	EQU    *
	JSR    DONEXP
	LDX    NUMSTACK
	LDD    0,X
	BPL    RABS1
RABS2:	COMA
	COMB
	ADDD   #1
RABS1:	STD    0,X
	RTS
*
*
RSGN:	EQU    *
	JSR    DONEXP
	LDX    NUMSTACK
	LDD    0,X
	BEQ    RABS1
	LDD    #1
	TST    0,X
	BPL    RABS1
	BRA    RABS2
*
*
RCALL:	EQU    *
	JSR    DONEXP
	LDX    NUMSTACK
	LDX    0,X
	JSR    0,X
	BRA    RPEEK1
*
*
RPEEK:	EQU    *
	JSR    DONEXP
	LDX    NUMSTACK
	LDX    0,X
	LDAB   0,X
	CLRA
RPEEK1:	LDX    NUMSTACK
	STD    0,X
	RTS
*
*
RFEEP:	EQU    *
	JSR    DONEXP       ; GO GET SUBSCRIPT OF EEPROM ARRAY.
	LDX    NUMSTACK     ; POINT TO THE OPERAND STACK.
	LDD    0,X          ; GET THE SUBSCRIPT OFF THE STACK.
	CPD    #MAXEESUB    ; IS IT WITHIN THE LIMIT?
	BLS    RFEEP1       ; YES. GO GET THE VALUE.
	LDAA   #EESUBERR    ; NO. SUBSCRIPT ERROR.
RFEEP2:	JMP    RPTRERR      ; REPORT THE ERROR.
RFEEP1:	LSLD                ; MULT THE SUBSCRIPT BY 2.
	ADDD   #EEPBASAD    ; ADD IN THE BASE ADDRESS OF THE EEPROM ADDRESS.
	XGDX                ; PUT THE ADDRESS IN X.
	LDD    0,X          ; GET THE DATA.
	BRA    RPEEK1       ; GO STEAL SOME CODE.
*
*
RFDIV:	EQU    *
	JSR    DONEXP       ; GO EVALUATE THE DIVIDEND EXPRESSION.
	JSR    RSKIPSPC     ; SKIP SPACES.
	INY                 ; PASS UP THE COMMA.
	JSR    RSKIPSPC     ; SKIP SPACES AFTER THE COMMA.
	JSR    DONEXP       ; EVALUATE THE DIVISOR EXPRESSION.
	LDX    NUMSTACK     ; POINT TO OPERAND STACK.
	LDD    2,X          ; GET THE DIVIDEND.
	LDX    0,X          ; GET THE DIVISOR.
	FDIV                ; DO THE FRACTIONAL DIVIDE.
	BVC    RFDIV1       ; ALL IS OK IF V=0. (IX > D).
	LDAA   #OVDV0ERR    ; ERROR. EITHER OVERFLOW OR /0 ERROR.
RFDIV2:	BRA    RFEEP2       ; GO REPORT IT.
RFDIV1:	XGDX                ; PUT QUOTIENT IN D.
	LDX    NUMSTACK     ; POINT TO OPERAND STACK.
	INX                 ; REMOVE DIVISOR FROM STACK.
	INX
	STD    0,X          ; PUT QUITIENT ON OPERAND STACK.
	STX    NUMSTACK     ; SAVE NEW VALUE OF STACK POINTER.
	RTS                 ; RETURN.
*
*
RADC:	EQU    *
	JSR    DONEXP       ; GO GET THE CHANNEL NUMBER TO CONVERT.
	LDX    NUMSTACK     ; POINT TO THE RESULT.
	LDD    0,X          ; GET THE CHANNEL NUMBER.
	BMI    RADC4        ; NEGATIVE CHANNEL NUMBERS ARE ILLEGAL.
	CPD    #7           ; IS IT A VALID CHANNEL NUMBER?
	BLS    RADC1        ; YES. GO CONVERT IT.
RADC4:	LDAA   #INVCHERR    ; NO. INVALID CHANNEL NUMBER.
	BRA    RFDIV2       ; GO REPORT THE ERROR.
RADC1:	LDX    IOBaseV
	STAB   ADCTL,X      ; START THE CONVERSION ON THE SELECTED.
RADC2:	TST    ADCTL,X      ; IS THE CONVERSION COMPLETE?
	BPL    RADC2        ; NO. WAIT FOR 4 CONVERSIONS ON 1 CHANNEL.
	CLRA                ; YES. NOW AVERAGE THE 4 CONVERSIONS.
	LDAB   ADR1,X       ; GET 1ST RESULT.
	ADDB   ADR2,X       ; ADD IN THE SECOND.
	ADCA   #0           ; ADD IN CARRY.
	ADDB   ADR3,X       ; ADD IN THE THIRD.
	ADCA   #0           ; ADD IN CARRY.
	ADDB   ADR4,X       ; ADD IN THE FOURTH.
	ADCA   #0           ; ADD IN CARRY.
	LSRD                ; DIVIDE RESULT BY 4.
	LSRD
	LDX    NUMSTACK     ; POINT TO THE RESULT.
	STD    0,X          ; PUT THE RESULT ON THE OPERAND STACK.
	RTS                 ; RETURN.
*
*
RRND:	EQU    *
	JSR    DONEXP       ; GO GET FUNCTION ARGUMENT.
	LDX    NUMSTACK     ; GET ARGUMENT OFF STACK. GET NEW RANDOM NUMBER?
	LDD    0,X
	BEQ    RRND2        ; YES. GO GET NEXT RANDOM NUMBER IN THE SERIES.
	BMI    RRND1        ; IF NEG., START A NEW SERIES.
	LDD    RANDOM       ; IF POSITIVE, GET LAST RANDOM NUMBER.
	BRA    RRND3        ; RETURN.
RRND1:	LDX    IOBaseV
	LDD    TCNT,X       ; USE THE TIMER VALUE AS THE NEW SEED.
	STD    RANDOM       ; SAVE IT.
RRND2:	LDD    RANDOM       ; GET PREVIOUS RANDOM NUMBER (USE AS SEED).
	ASLB                ; DO SOME OPERATIONS.
	ABA
	LDAB   RANDOM+1
	ASLD
	ASLD
	ADDD   RANDOM
	ADDD   #$3619
	STD    RANDOM
RRND3:	LSRD                ; MAKE THE NUMBER POSITIVE.
	STD    0,X          ; PUT THE NUMBER ON THE STACK.
	RTS                 ; RETURN.
*
*
ITAB:	EQU    *
ICHRS:	EQU    *
IHEX:	EQU    *
IHEX2:	EQU    *
	LDAA   #PRFUNERR	; THESE FUNCTIONS MUST BE USED ONLY IN
	JMP    RPTRERR	; PRINT STATEMENTS.
*
*
RFTIME:	LDD    TIMEREG      ; GET THE TIME IN SECONDS.
	BRA    RFPORTA2     ; GO PUT NUMBER ON THE STACK.
*
*
RFPACC:	LDX    IOBaseV
	LDAB   PACNT,X      ; GET THE CURRENT VALUE OF THE PULSE ACCUMULATOR.
	CLRA
	BRA    RFPORTA2     ; GO PUT THE NUMBER ON THE STACK.
*
*
RFPORTA:	EQU    *
	LDAB   #PORTAIO      ; GET DATA FROM PORTA.
RFPORTA1:	LDX    IOBaseV
	ABX
	LDAB   0,X
	CLRA                ; CLEAR UPPER BYTE OF WORD.
RFPORTA2:	DEY                 ; DECREMENT IP BECAUSE CALLING ROUTINE WILL TRY
	DEY                 ; TO BUMP IT PAST AN OPENING & CLOSING PAREN
*                             ; WHICH ISN'T THERE.
	JMP    PSHNUM4      ; GO PUSH VALUE ON OPERAND STACK & RETURN.
*
RFPORTB:	EQU    *
	LDAB   #PORTBIO
	BRA    RFPORTA1
*
RFPORTC:	EQU    *
	LDAB   #PORTCIO
	BRA    RFPORTA1
*
RFPORTD:	EQU    *
	LDAB   #PORTDIO
	BRA    RFPORTA1
*
RFPORTE:	EQU    *
	LDAB   #PORTEIO
	BRA    RFPORTA1
*
*